Spring初阶_01

Spring介绍

spring是一个轻量级Java开发框架，最早有Rod Johnson创建，目的是为了解决企业级应用开发的业务逻辑层和其他各层的耦合问题，他是一个分层的JavaSE/JavaEE full-stack（一站式）轻量级开源框架，未开发Java程序提供全面的基础架构支持。spring负责基础架构，因此Java开发者可以专注于应用程序的开发。

spring最根本的使命是解决企业级应用开发的复杂性，即简化Java开发。

spring可以做很多事情，它为企业级开发提供给丰富的功能，但是这些功能的底层都依赖于它的两个核心特性，也就是依赖注入（dependency injection，DI）和面向切面编程（aspect-oriented programming，AOP）

Spring相关的网站链接

官网地址：https://spring.io/projects/spring-framework#overview

spring4中文手册：https://waylau.gitbooks.io/spring-framework-4-reference

压缩包下载地址：https://repo.spring.io

源码地址：https://github.com/spring-projects/spring-framework

架构的演变过程

单一应用架构
当网站流量很小的时候，只需要一个应用，将所有功能都部署在一起，以减少部署节点和成本，此时简化增删改查工作量的数据访问框架（ORM）是关键。

垂直应用架构
当访问量组件增大，单一应用增加机器带来的加速度越来越小，提升效率的方法之一是将应用拆成互不相干的几个应用，以提升效率。此时，用于加速前端页面开发的web框架（MVC）是关键。

分布式服务架构
当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提升业务复用及整合的分布式服务框架（RPC）是关键。

流动计算架构
当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实现管理集群容量，提高集群利用率。此时，用于提高机器利用率的资源调度和治理中心（SOA）是关键。

简略核心解释

	依赖注入---dependency injection，DI
	面向切面编程---aspect-oriented programming，AOP
	spring是一个轻量级的开源框架
	spring是为了简化企业开发而生，使得开发变得更加优雅和简洁。
	spring是一个IOC和AOP的容器框架
			IOC：控制反转
			AOP：面向切面编程
			容器：包含并管理用用对象的生命周期

使用spring的优点

1、spring通过DI、AOP和消除样板式代码来简化企业级Java开发
2、spring框架之外还存在一个构建在核心框架之上的庞大生态圈，它将spring扩展到不同的领域，如web服务、REST、移动开发以及NoSQL
3、低侵入式设计，代码污染极低
4、独立于各种应用服务器，基于sparing框架的应用可以真正实现Write Once，Run Anywhere的承诺
5、spring的IOC容器降低了业务对象替换的复杂性，提高了组件之间的解耦
6、spring的AOP支持允许将一些通用任务和安全、事务、日志等进行集中式处理，从而提供了更好的复用
7、spring的ORM和DAO提供了与第三方持久层框架的良好整合，并简化了底层的数据库访问
8、spring的高度开放性，并不强制应用完全依赖spring，开发者可以自由选用spring框架的部分或者全部
9、任何一个语言或者任何一个框架想要立于不败之地，那么很重要的就是它的生态

模块解释
Test：spring的单元测试模块
Core Container：核心容器模块
AOP+Aspects：面向切面编程模块
Instrumentation：提供了class instrumentation支持和类加载器的实现来在特定的应用服务器上使用，几乎不用
Messaging：包括一系列的用来映射消息到方法的注解，几乎不用
Data Access/Integration：数据的获取/整合模块，包括了JDBC，ORM，OXM，JMS和事务模块
Web：提供面向web整合特性

IOC

基本概念：IOC是一种设计思想，在Java开发中，将你设计好的对象交给容器控制，而不是显示地运用代码进行对象的创建

把创建和查找依赖对象的控制全交给IOC容器，由IOC容器进行注入，组合对象之间的关系，这样对象与对象之间是松耦合、功能复用（减少对象的创建和内存消耗），使得程序的整个体系可维护性、灵活性、扩展性更高。所谓IOC，就简短一句话：对象由spring来创建、管理、装配！

代码示例

常规写法：
目录结构

package dao;

/**
 * @Author Joe
 * dao
 * @Date 2021-11-24 0:03
 */
public interface IUserDao {
    void getUser();
}

package dao.impl;

import dao.IUserDao;

/**
 * @Author Joe
 * dao.impl
 * @Date 2021-11-24 0:03
 */
public class UserDaoImpl implements IUserDao {
    @Override
    public void getUser() {
        //查询数据库
        System.out.println("查询数据库");
    }
}

package service;

/**
 * @Author Joe
 * service
 * @Date 2021-11-24 0:01
 */
public interface IUserService {
    void getUser();
}

package service.impl;

import dao.IUserDao;
import dao.impl.UserDaoImpl;
import service.IUserService;

/**
 * @Author Joe
 * service.Impl
 * @Date 2021-11-24 0:02
 */
public class UserServiceImpl implements IUserService {
    IUserDao dao = new UserDaoImpl();
    @Override
    public void getUser() {
        dao.getUser();
    }
}

package entity;

/**
 * @Author Joe
 * entity
 * @Date 2021-11-23 23:59
 */
public class User {
    private Integer id;
    private String username;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                '}';
    }
}

测试类

package test;

import service.IUserService;
import service.impl.UserServiceImpl;

/**
 * @Author Joe
 * test
 * @Date 2021-11-24 0:04
 */
public class MyTest {
    public static void main(String[] args) {
        IUserService service = new UserServiceImpl();
        service.getUser();
    }
}

# 运行结果

查询数据库

通常我们在使用的时候，不建议去修改原有的类，比如新建一个业务 查询hdfs数据库，新加类

package dao.impl;

import dao.IUserDao;

/**
 * @Author Joe
 * dao.impl
 * @Date 2021-11-24 0:24
 */
public class UserDaoHdfsImpl implements IUserDao {
    @Override
    public void getUser() {
        System.out.println("查询HDFS数据库");
    }
}

此时如果在测试类中去修改，就需要修改每一个引用的类，这样产生的一个耦合度非常高，此时就可以采用spring的方式
1）引入依赖（此处采用maven的方式引入）

# maven项目中的pom文件引入spring-context
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
    </dependencies>

导入之后，会有如下的几个jar包

2）配置xml文件
通过spring IOC将之前的UserDaoHDFSImpl和UserServiceImpl分离出来，此时会创建两个bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--通过在xml文件中实现控制反转 IOC -->
    <bean class="dao.impl.UserDaoHdfsImpl" id="userDaoHdfs"/>
    <bean class="service.impl.UserServiceImpl" id="userService">
        <!--通过添加property的方式实现依赖注入  DI -->
        <property name="dao" ref="userDaoHdfs"/>
    </bean>
</beans>

上述中就已经实现了两个类由spring去控制了
接下来需要去测试类中去拿到具体的对象值，操作步骤如下：

a. 加载IOC容器
b.通过接口/实现类去拿到对象

package test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.IUserService;

/**
 * @Author Joe
 * test
 * @Date 2021-11-24 0:04
 */
public class MyTest {
    public static void main(String[] args) {
        //加载spring的xml，加载容器
        ApplicationContext ioc = new ClassPathXmlApplicationContext("spring.xml");
        
        //使用接口去拿到具体的实现
        IUserService service = ioc.getBean(IUserService.class);

        service.getUser();
    }
}

运行结果与上述一致。

场景再现
此时如果当在引入新的对象时，我们只需要在目录中创建类，对象的创建交给bean去实现，操作如下
增加新的类

package dao.impl;

import dao.IUserDao;

/**
 * @Author Joe
 * dao.impl
 * @Date 2021-11-24 0:03
 */
public class UserDaoImpl implements IUserDao {
    @Override
    public void getUser() {
        //查询数据库
        System.out.println("查询数据库");
    }
}

修改xml文件去创建具体的对象

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--通过在xml文件中实现控制反转 IOC -->
    <bean class="dao.impl.UserDaoImpl" id="userDaoHdfs"/>
    <bean class="service.impl.UserServiceImpl" id="userService">
        <!--通过添加property的方式实现依赖注入  DI -->
        <property name="dao" ref="userDaoHdfs"/>
    </bean>
</beans>

上述中只修改了一行，即将 <bean class="dao.impl.UserDaoHdfsImpl" id="userDaoHdfs"/> 修改为 <bean class="dao.impl.UserDaoImpl" id="userDaoHdfs"/>

---

本次的小结来自于xushu老师的课程
致敬大师，致敬未来的自己，与君共勉！