Spring(万字详解版)

Spring

• 1.Spring是什么
• • 1）什么是容器？
  • 2）什么是IoC？
  • 3）spring的主要作用
  • 4）DI（Dependence Injection）依赖注入
  • 5）扩展：
  • • a.IoC和DI有什么区别？
    • b.spring是什么？spring的作用是什么？
• 2.Spring的创建和使用
• • 1）spring的创建
  • 2）将Bean存储（注册）到spring中（3步/2步）
  • 3）使用容器中的Bean（对象）
  • • 1.得到spring的上下文对象
    • 2.获取spring中的bean
    • 3.调用获取到的对象的方法
    • 4.扩展
    • • 1）ApplicationContext 和 BeanFactory 的异同:
      • 2）target文件夹
• 3.使用Spring更简单的注册对象（使用注解）
• • 1）使用五大类注解
  • • 1.五大类注解的区别和联系
    • 2.spring使用五大类注解生成的beanName问题
  • 2）使用方法注解@Bean
• 4.使用Spring更简单的装配对象（对象注入）
• • 1）属性注入（字段注入）
  • 2）构造方法注入（官方推荐）
  • 3）Setter注入
  • 拓展
  • • 1.属性注入，构造方法注入和Setter注入的区别？（三种注入方式的区别）
    • 2.@Autowired 和 @Resource 的区别（两种注入方法的区别）
    • 3.解决@Bean注入多个对象的问题
• 5.Bean的作用域
• • 1）案例
  • 2）作用域类型
  • • 1.singleton（单例模式）（默认模式）
    • 2.prototype 原型模式（多例模式）
    • 3.request 请求作用域 （Spring MVC）
    • 4.session 会话作用域（Spring MVC）
    • 5.application 全局作用域（Spring MVC）
  • 3）作用域设置
• 6.Spring的执行流程
• 7.Bean的生命周期

1.Spring是什么

Spring就是一个包含众多工具方法的IoC容器

1）什么是容器？

容器就是存储某种东西的基本装置，在Java的学习过程中，我们曾接触过很多容器，例如数据结构中的List，Map等是数据存储的容器，Tomcat就是web程序的容器

2）什么是IoC？

IoC（Inversion of Control）也就是控制反转的意思 那么也就是说spring是个控制反转的容器，但是这样说还是有点不好理解，我们可以理解为控制权转换了的对象的容器，那什么是控制转换，我们为什么要使用控制转换呢？举个例子，比方说我们要实现一个Car类，那么我们需要实现车身，车底盘，车轮胎，由上而下是一个层层递进，层层依赖的关系

按照上图的逻辑我们写出的代码是

class Car{
    public void init(){
        Body body = new Body();
        body.init();
    }
}

class Body{
    public void init(){
        Bottom bottom = new Bottom();
        bottom.init();
    }
}

class Bottom{
    public void init(){
        Tires tires = new Tires();
        tires.setSize(??);
    }
}

class Tires{
    private int size;
    public void setSize(int size){
        this.size = size;
    }
}

public class traditionalMethod {
    public static void main(String[] args) {
        Car car = new Car();
        car.init();
    }
}

当我们的业务需求是需要涉及不同尺寸的轮胎时，我们就需要层层调用直到底层的setSize，也就是我们需要在Bottom类中调用时需要传入??参数，但是由于我们每一个类都是在类自己内部new出自己的所需依赖，那么这个所需的依赖的控制权就相当于在我们手中，所有类中需要的参数都需要我们自己层层传输，我们在想要修改size时，就需要从顶层的car类中开始传入参数，一步一步的传到底层，这时我们需要修改涉及的代码就太多了，而且当代码的依赖逻辑更复杂时，或者需要给最底层的轮胎增删一些参数（例如增加颜色属性），我们需要更容易凌乱，出现这个问题的原因是上述代码耦合性太高了，我们不妨想，将new依赖对象这个操作交到外部，也就是将依赖对象的控制权交出去，当我们需要的时候直接拿对象来使用即可（也就是采用注入所需依赖对象的方法），那么这个时候就直接将依赖的对象当成了一个方法，当我们对所以来对象想要进行一些修改时，我们只需要在外部类创建时进行修改，然后在调用类中增删改参数即可，这时就完美的实现了程序的解耦合，用代码来实现就是

class Car2{
    private Body2 body2;
    public Car2(Body2 body2){
        this.body2 = body2;
    }
    public void run(){
        body2.init();
    }
}

class Body2{
    private Bottom2 bottom2;
    public Body2(Bottom2 bottom2){
        this.bottom2 = bottom2;
    }
    public void init(){
        bottom2.init();
    }
}

class Bottom2{
    private Tires2 tires2;
    public Bottom2(Tires2 tires2){
        this.tires2 = tires2;
    }
    public void init(){
        tires2.init();
    }
}

class Tires2{
    private int size;
    public Tires2(int size){
        this.size = size;
    }
    public void init(){
        System.out.println("Size = " + size);;
    }
}
public class IoCMethod {
    public static void main(String[] args) {
        Tires2 tires2 = new Tires2(20);
        Bottom2 bottom2 = new Bottom2(tires2);
        Body2 body2 = new Body2(bottom2);
        Car2 car2 = new Car2(body2);
        car2.run();
    }
}

可以看到，在IoC方法中，我们将所有的依赖对象创建为上级类的属性，在构造方法中将在外边创建好的依赖对象当作参数传入，这时，如果我们仍然要修改最底层Tires的属性，我们只需要在Tires类中增删改参数，然后在main方法中将new Tires的参数增删改即可，剩下的几层代码是不需要改动的，因为我们将控制权发生了反转，这时new对象的顺序也是由下而上的，这样将依赖对象由自身new改为注入的方式，下级的控制权不是上级的了，那么无论下级如何改变上级都不需要改动，就很好的完成了解耦合

3）spring的主要作用

我们了解了容器和IoC之后，spring是什么就迎刃而解了，spring就是储存对象的容器，spring有着创建对象和销毁对象的权利，那么他的主要的作用就是：
1.可以将Bean（对象）存储到Spring容器当中
2.可以将Bean（对象）从Spring容器当中取出来

4）DI（Dependence Injection）依赖注入

所谓的“依赖注入”，就是指IoC容器在运行时将所需的依赖注入到类中，其实DI就是换了一个角度和IoC描述同样的一件事情

5）扩展： a.IoC和DI有什么区别？

IoC是一种思想，DI是基于IoC这个思想的具体实现，我们代码耦合性高的解决思想是IoC，通过DI对象注入来事项IoC，类似于乐观锁和CAS的关系，乐观锁是一种思想，CAS是乐观锁的具体实现

b.spring是什么？spring的作用是什么？

spring就是包含有众多工具和方法的IoC容器，其主要作用是存储Bean和从其中取出Bean

2.Spring的创建和使用 1）spring的创建

1）先创建一个maven项目
2）添加spring框架支持（spring-context/spring-beans）
3）创建一个启动类并添加main，作为测试类看是否引入正常

2）将Bean存储（注册）到spring中（3步/2步）

如果是第一次添加对象，则需要先创建spring的配置文件（一般命名为spring-config.xml，在resources目录下），在spring-config.xml文件中创建bean标签，设置标签的id属性（默认命名格式为小驼峰）和class属性，id属性就是我们将对象注册入spring后在spring容器中的名字，class属性就是我们要注入的对象的路径，最终spring会以Map 来存储数据 也就是键值对的形式 id对应的是key，class对应的是value

3）使用容器中的Bean（对象） 1.得到spring的上下文对象

我们使用ApplicationContext类来取到spring的上下文对象，实例化其子类的ClassPathXmlApplicationContext，传入参数为刚刚创建的配置文件名（推荐是spring-config.xml），这样我们的进程就会扫描配置文件以及其中的bean标签，将bean注入到容器中

在这里我们也可以使用另一个类BeanFactory来获取上下文对象，这里需要new的是其子类xmlbeanfactory 同时xml对象中需要一个类资源文件ClassPathrResource其需要的参数也是配置文件名

2.获取spring中的bean

我们通过上边创建的（两个皆可）上下文对象提供的getBean()方法来获取到容器中的bean，传入的参数是注册bean时传入的id属性内容（beanName）
，需要注意的是getBean返回的对象类型是Object类，我们需要将其强转为bean本身的类型，但是这种方法有一个缺点，因为我们是直接传入字符串进去，那么如果我们所传入的beanName写错了等等，就会返回空的对象，我们在进行强制类型转换时就会报空指针异常
我们也可以通过getBean的重载方法来取到bean

第二个是传入对象的类型（类对象）

但是这种方法有一个缺点，就是如果我们将User这个类的实例化对象注册了两次的话，这种方法就会报错

Exception in thread “main” org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type ‘beans.User’ available: expected single matching bean but found 2: user,user2
上述是编译器提示的异常信息，可以看到它提示我们user并不是single bean
那么我们就可以用第三种getBean，这一种将上述两种结合，是我们最推荐的方法

这种方法既可以防止第一种情况种出现的空指针异常（不涉及强转），也可以防止第二种方式非唯一的bean异常，因此我们一般推荐使用第三种

3.调用获取到的对象的方法

4.扩展 1）ApplicationContext 和 BeanFactory 的异同:

同：两种方法都可以获取到spring的上下文对象，也提供了getBean方法从而具体的获取到bean对象
异：
1.ApplicationContext 属于BeanFactory的子类，那么我们都知道，子类是继承了父类的所有非私有方法和属性的，但是父类并没有子类的属性方法，因此App类比BeanFact类要提供了更多的操作bean的方法，而不仅仅是简单的getBean，比如国际化的支持，资源访问的支持以及事件和传播等方面的支持
2.从性能方面二者并不相同 App类是在扫描spring-config时，一口气将所有的对象全部创建加载出来了的，属于饿汉模式，而BeanFact是按需加载bean的，下边代码中有使用bean的方法时，才会创建bean，我们以代码来观察

我们首先为User类加入了构造方法，当创建对象时就会提示


可以看到，我们都没有使用user对象，但是使用A方法直接会出现创建对象，B对象则什么都没有，那么我们加入user的方法再来看

可以发现，这时A,B类都调用了构造方法，也就是说B类更轻量

2）target文件夹

当我们修改了错误代码再次运行程序，可能源代码没有问题了，但是程序还是报错，我们这时不妨检查一下target文件夹下的内容，因为target文件夹下储存的是JVM真正运行的.class二进制文件，有时可能因为缓存问题，导致target目录下的.class文件没有及时更新，因此程序仍旧报错

3.使用Spring更简单的注册对象（使用注解）

前置工作：我们在使用更简单的方式时，需要在spring-config.xml（配置文件）中加入扫描对象的根路径
我们的base-package属性就是扫描bean对象的根路径，spring会自动扫描beans目录及其所有子目录，根据条件注入对象

1）使用五大类注解

我们的五大类注解有
1）@Controller【控制器】
2）@Service【服务】
3）@Repository【仓库】
4）@Configuration【配置】
5）@Component【组件】
我们在使用时只需要将注解加到要注册的目标类上边即可

加了五大类注解之后，spring在获取上下文对象时就会扫描刚刚设置的扫描根路径中的所有类，当类设置了五大类注解时，就会注册此类

1.五大类注解的区别和联系

区别：
在软件工程中，我们的代码分为四大层级
1.配置层（Configuration）
我们将程序运行所需的配置文件归属在该层，例如刚刚的spring-config.xml文件
2.控制层（Controller）
这一层负责检验前端所传过来的参数是否合法，像是安检一样，前端所传的参数会率先经过该层，如果参数有问题则会被返回并且提示异常
3.服务层（Service）
这一层负责数据组装和接口调用，例如我们需要使用哪些接口来处理前端传过来的参数，该返回怎样的数据给前端等
4.数据持久层（Repository/DAO）
这一层负责直接操作数据库，和数据库进行交互
仔细观察就会发现，我们的五大类注解和这几层的名字很相似，因此涉及五大类注解，每一类注解都对应了其中一层，第五大类@Component（组件）
则对应了一些不属于上述四大层级的其他类，作为程序的组件，我们在使用不同注解标记代码，就使得代码的可读性更强了，程序员可以直接判断当前类的作用
联系：

我们通过查看源码可以发现，前四个注解都是基于第五个注解实现的，也就是说前四个注解都是基于@Component，都是@Component的子类，所有的注解都属于程序的“组件”

2.spring使用五大类注解生成的beanName问题

在之前在spring-config.xml中添加bean标签实现对象注册时，我们的id属性对应了被注册对象的beanName，我们可以通过其访问到唯一的bean，但是使用五大类注解时我们没有显式的指定bean的beanName，那么我们如何访问非唯一的对象呢，我们这里可以查看spring的源码

查看该方法，发现“创建beanName方法（generateBeanName）”

可以发现其返回中调用了buildDefaultBeanName方法，查看该方法可以发现

其最后调用了decapitalize方法，那么这个方法就是最终答案了

可以发现，这个方法先执行了一个参数合法性的判断，之后第二个if中判断了传入的name长度是否大于一个字符，如果大于的话先查看这个name的第二个字符，看是否第二个字符是大写的，如果是，再检查name的第一个字符，如果第一个和第二个字符全是大写，那么返回的默认beanName就是这个类的name本身（传入的name），如果上述三个条件有一个不符合，那么就会将类名的首字母改为小写，作为beanName返回回去，因此我们上边才会说，beanName的默认命名方式为小驼峰，但是特殊情况就是前两个字符都是大写时beanName就是原类名

可以直接调用这个方法来查看结果，符合我们上述的分析

2）使用方法注解@Bean

@Bean方法只可以标记在类中的方法上，而不可以直接标记在类上，此注释表示将被标记方法返回的对象注册在spring当中，同时，使用方法注解时需要搭配一个五大类注解在方法所在的类上方，这样的目的是为了优化性能，因为我们的扫描路径下可能有的方法是非常多的，这时如果spring去扫描所有的方法看是否方法上查看了@Bean注解，这样效率会非常低，我们不妨为有方法注解的类添加五大类注解，达到缩小扫描范围的目的，优化性能，这个行为和添加扫描路径是一样的，不添加扫描路径的话扫描的就是整个java源代码目录，添加了扫描路径的话就只扫描目标路径及其子目录

根据分析我们可以得到一个name属性为zhangsan的user对象

可以发现确实如此
当然，我们想要访问@Bean方法注册的对象，也不一定非要使用方法名来访问，我们可以通过设置@Bean的属性来对beanName重命名（可以设置多个重命名，用{}包裹起来即可），但是当我们设置了这个属性后，我们便无法通过方法名的方式访问bean了

@Controller
public class setUser {
    @Bean(name = {"user1","user2"})
    public User getUser(){
        User user = new User();
        user.name = "zhangsan";
        return user;
    }
    
}

我们通过重命名的user1或者user2都可以获取到user对象了

4.使用Spring更简单的装配对象（对象注入）

顾名思义，就是使用spring更容易的将对象从spring中读取出来，之前我们要读取容器中的对象，需要先获取上下文对象，然后调用getBean方法才可以，现在我们只需要用注释的方法就可以轻松获取到了，我们可以用@Autowired注释和@Resource注释

1）属性注入（字段注入）

定义当前类的一个属性，属性类型就是要注入的对象类型，属性名采用小驼峰的方式，之后在该属性上添加@Autowired注释或者@Resource注释都可

@Controller
public class setUser2 {
    @Autowired
    private User user;
    public void getName(){
        System.out.println(user.name);
    }
}

可以发现我们可以提取到setUser2中的user的name属性，注入成功

2）构造方法注入（官方推荐）

定义一个属性，属性类型是要注入的对象，对象名为小驼峰，定义构造方法，像构造方法传入参数（要注入的对象），将属性对象的引用设置为传入的对象，在构造方法上添加@Autowired注解，而这里不能使用@Resource注解

@Controller
public class setUser3 {
    private User user;
    @Autowired
    public setUser3(User user){
        this.user = user;
    }
    public void getName(){
        System.out.println(user.name);
    }
}

可以发现，我们仍然可以访问到向setUser3中注入的user对象的name属性
通过构造方法注入时，如果只写了一个构造方法，我们可以省略@Autowired注释，但是如果有多个构造方法，我们则不可以省略

3）Setter注入

定义私有属性，属性类型为要注入对象类型，属性名以小驼峰方式，通过设置私有属性的set方法来将对象注入到属性中，可以通过在set方法上添加@Autowired注解或@Resource注解

@Controller
public class setUser4 {
    private User user;
    @Autowired
    public void setUser(User user){
        this.user = user;
    }
    public void getName(){
        System.out.println(user.name);
    }
}

拓展 1.属性注入，构造方法注入和Setter注入的区别？（三种注入方式的区别）

1）属性注入的写法最为简单，但是只用于IoC容器中，如果程序运行在非IoC容器环境下，很容易注入失败，通用性不强，引发问题
2）setter注入是曾经spring最推荐的注入方式，但是不同语言的set方法可能不同，甚至可能没有set方法，因此这种方法的通用性并不高
3）构造方法注入的通用性是最强的，因为几乎所有的语言的构造方法格式都是相同的，同时，构造方法会在构造类是率先调用，那么采用构造方法注入，可以第一时间将所需依赖注入到当前类当中完成初始化，再使用当前类时不会引发空指针异常，但是使用构造方法注入需要程序员自己检查代码不要有过多的参数，必须要符合单一设计原则

2.@Autowired 和 @Resource 的区别（两种注入方法的区别）

1）出身不同：@Resource来自于JDK官方 @Autowired来自于Spring
2）用法不同：@Resource不支持构造方法注入，仅支持其他两种，@Autowired支持三种注入方式
3）支持的参数不同：@Resource支持更多的参数设置，例如name，type等，而@Autowired仅支持require参数

3.解决@Bean注入多个对象的问题

@Controller
public class setUser {
    @Bean(name = {"user1")
    public User getUser(){
        User user = new User();
        user.name = "zhangsan";
        return user;
    }
    @Bean(name = "user2")
    public User getUser2(){
        User user = new User();
        user.name = "wangwu";
        return user;
    }
}

在上述代码中，我们写了两个getUser方法，都通过方法注解@Bean将两个方法返回的对象注册到了容器中

@Controller
public class NotSingle {
    @Autowired
    private User user;
    public void getName(){
        System.out.println(user.name);
    }
}

我们在NotSingle类中注入user对象，再在main方法中创建这个实例调用getName方法看是否可以访问到user对象的name属性

可以发现触发了不是唯一对象的异常，这是因为我们之前注入了两个user对象，这时我们再注入user类到其他类中就不知道到底该注入user1，还是user2了，我们解决这个方法有三种方式
1.精确的描述要注入的bean的名称
例如上述代码，我们可以将属性名修改为user1或者user2，这样达到精确注入的目的

@Controller
public class NotSingle {
    @Autowired
    private User user1;
    public void getName(){
        System.out.println(user1.name);
    }
}

运行后发现name为wangwu，符合user1的属性
2.通过设置@Resource注释的name属性来精确锁定某一对象
将@Resouce设置了name属性后，该类的私有属性（要注入的对象）的属性名可以达到给bean重命名的效果

@Controller
public class NotSingle {
    @Resource(name = "user1")
    private User user;
    public void getName(){
        System.out.println(user.name);
    }
}

我们通过设置@Resource的name属性，锁定了要注入对象为user1，同时下边创建的user可以将user1对象在当前类中重命名，user和user1引用指向同一个user的地址，这时我们访问的结果仍然是zhangsan

3.使用 @Autowired注释和 @Qualifier搭配锁定某一对象

@Controller
public class NotSingle {
    @Autowired
    @Qualifier("user2") //也可以是@Qualifier(value = "user2")
    private User user;
    public void getName(){
        System.out.println(user.name);
    }
}

这时我们达到的效果和方法2相同，都锁定了user2对象并且将其重命名为user，执行效果为输出wangwu

5.Bean的作用域 1）案例

我们先来看一个案例
首先，创建一个Users类，设置属性name初始值为”暗裔剑魔“

@Controller
public class Users {
    public String name = "暗裔剑魔";
    public void getName(){
        System.out.println(this.name);
    }
}

创建一个类BeanLife，注入一个users对象，并且在自己的方法中新建一个users对象使其指向刚注入进来的users属性所指的对象，在方法中修改其名称为”时间刺客“

public class BeanLife {
    @Autowired
    private Users users;

    public void getNewName(){
        Users users_1 = users;
        System.out.println("修改前原name" + user2.name);
        users_1.name = "时间刺客";
    }
}

再创建一个新的类，再注入users对象，打印users对象的名字

@Controller
public class BeanLife2 {
    @Autowired
    private Users users;

    public void getName(){
        System.out.println(users.name);
    }
}

按照我们一直以来的了解，注入的对象应该是在堆中开辟了新的空间，其作用域在类范围内，那么我们在类中再新建一个指向它的引用并且修改其属性，应该不会影响原本注册在spring中的users对象，也就是说新的类BeanLife2中读取道德users对象的name属性应该是”暗裔剑魔“，那么我们来看一下运行结果

我们可以发现，beanLife2得到的users对象的name属性竟然是”时间刺客“，
这是为什么呢？
这是因为Bean在spring中默认是单例模式的，也就是说无论在哪里创建新的对象，只要和bean对象类型beanName相同，那么这个新创建的对象也指向同一个内存地址

2）作用域类型 1.singleton（单例模式）（默认模式）

通常无状态的bean可以设置作用域为单例模式（无状态指后续代码没有改变bean的属性）

2.prototype 原型模式（多例模式）

即使后边修改，从另一个类中拿到的还是原本的spring bean：通常有状态的bean使用此模式，每一次请求都会创建新的实例，例如使用getBean方法获取时或者使用@Autowired注入时都会创建新的对象
当我们将案例中users的作用域设置为prototype时可以观察到


beanLife2取到的仍是原beans对象，没有被beanLife1修改

3.request 请求作用域 （Spring MVC）

每一次发送请求都会得到一个对象

4.session 会话作用域（Spring MVC）

每同一个session共用一个对象

5.application 全局作用域（Spring MVC）

所有用户共用一个对象，3，4，5是一个逐渐升级的过程 和singleton的应用场景不同 application应用于Spring Web作用域 singleton是Spring Core作用域 singleton作用于IoC的容器 而application作用于servlet容器

3）作用域设置

1.可以通过@Scope(“”)来设置，例如上边使用的

2.通过@Scope(ConfigurableBeanFactory.)的方式来设置，这样可以有效的避免我们用1方法传字符串时将单词拼错

6.Spring的执行流程

1.启动容器，通过main方法中ApplicationContext获取上下文对象同时启动容器
2.根据配置文件，通过xml中加入的bean对象，或者扫描目录，将带五大类注解或bean方法注解的对象注册入spring当中，注册时如果有类需要依赖别的类，例如A依赖B，那么在注册A类时会先将B类注入A的属性中，完成初始化 防止空指针异常，然后再注册A类

7.Bean的生命周期

1.实例化Bean：为Bean对象分配内存空间
2.设置属性：为Bean对象注入所需依赖
3.初始化：
1）执行各种通知
2）执行初始化的前置方法
3）执行Bean的构造方法：一种是执行@PostConstruct 另一种是执行init-method，一个是注解方式的初始化，一个是xml时代的，两个方法的优先级中，注解优先级要比init高
4）执行初始化的后置方法
4.使用bean
5.销毁bean
可以使用@PreDestroy 也可以重写DisposableBean接口方法 也可以执行 destroy-method 一个是注释产物，一个是方法，一个是xml产物
我们用代码来观察一下各个方法的执行顺序是否如上述所说一般

public class BeanLifeTest {
    @Autowired
    private TestBean testBean;
    @PostConstruct
    public void PostConstruct(){
        System.out.println("执行了@PostConstruct方法！");
    }
    public void initMethod(){
        System.out.println("执行了init-Method方法！");
    }
    @PreDestroy
    public void PreDestroy(){
        System.out.println("执行了PreDestroy方法！");
    }
    public void destroyMethod(){
        System.out.println("执行了destroy-method方法！");
    }
}

我们给其依赖TestBean类写了构造方法，当构造了之后会提示

可以发现执行顺序确实如上述介绍一般