Spring学习条记：Spring的基于注解的XML的详细设置

按照刘Java的次序，应该是从基于XML的DI开始接着上面的关于IoC容器装配。重要介绍学习Spring的XML基于注解的详细设置。
第一步是搭建一个Spring的基础工程（maven管理），通过IoC机制获取IoC容器的对象。
创建maven工程并在pom文件并添加依靠：

1. <?xml version="1.0" encoding="UTF-8"?>
2. <project xmlns="http://maven.apache.org/POM/4.0.0"
3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5.     <modelVersion>4.0.0</modelVersion>
7.     <groupId>liujavaspringioc</groupId>
8.     <artifactId>com.zp.liu</artifactId>
9.     <version>1.0-SNAPSHOT</version>
12.     <properties>
13.         <spring-framework.version>5.2.8.RELEASE</spring-framework.version>
14.     </properties>
16.     <dependencies>
17.         <!--spring 核心组件所需依赖-->
18.         <dependency>
19.             <groupId>org.springframework</groupId>
20.             <artifactId>spring-context</artifactId>
21.             <version>${spring-framework.version}</version>
22.             <scope>compile</scope>
23.         </dependency>
24.     </dependencies>
26. </project>

复制代码

添加这一个依靠就可以了，这个spring-context是spring framework的坐标依靠，引入它其他的framework的焦点依靠就会引入进来。
添加设置文件

在resource下创建一个设置文件，命名发起spring-context.xml或者applicationContext.xml.(这个resource目录是maven工程自带的，在src下面，不要自己建，这也是maven工程的一个特点，规范了工程的目录布局。)
IoC容器

Spring的焦点机制是IoC（Inversion of Control），控制反转。
就是将对象的创建和属性设置set的方式反转，不再是人来直接创建。
以前是开发人员创建对象，为对象赋值。如今有了Spring，就把对象和属性的创建和管理由Spring来管理，Spring来处置处罚对象生命周期，属性控制以及其他对象之间的关系，这样类和类之间就结耦，这些类实例还能做到复用。‘’
IoC也是DI的意思，dependcy injection 依靠注入，就是对象获取它需要依靠的对象的方式，不是主动去找，而是被动通过IoC容器来找到对应的依靠，给这些被依靠的注入进来。
Spring中管理的对象的容器称为IoC容器，IoC容器负责实例化，设置和装配Bean。
（org.Springframework.beans和orgSpringframework.context包是Spring IoC容器的基础）
IoC容器是一个抽象的概念，具体代码的实现，最顶层是BeanFactory接口和他的实现类，对应就是他的IoC容器的实现。
BeanFactory仅作为IoC容器的超级接口，真正可用的容器不会用它，真正的容器的实现是对应的一系列的实现类，BeanFactory最重要的两个容器的实现，DefaultListableBeanFactory和ApplicationContext。
DefaultListableBeanFactory

DefaultListableBeanFactory是IoC容器的真正实现，也是原始的默认的IoC容器实现，通常作为自定义的BeanFactory的父类的。通过Resource来加载Spring的xml文件，Bean信息回加载到IoC容器，启动IoC容器就可以使用getBean方法从IoC容器中获取Bean对象。
DefalutListableBeanFactory加载Bean的方式称为‘懒加载’，懒加载就是只有容器启动才会把设置文件的设置信息加载到容器，但是不会创建对象，getBean才会创建所需要的对象。
（懒加载就是容器启动只读取设置信息，getBean的时候才去创建对象。）
XMLBeanFactory容器，继续了DefaulyListableBeanFzctory，是集自己就是对DefaultListableBeanFactory和XMLBeanDefintionReader的封装调用。
Spring中还有一个XMLBeanFactory，继续了DefaultBeanListableBeanFactory，实际上XMLBeanfactory是XMLBeanDefinitionReader和XMLBeanFactory的封装，但是在Spring3.1以后就被弃用。
DefaultBeanListableFactory和BeanXMLFactory都只适合单体应用IoC容器。（如今根本都是分布式，这种单体应用就不实用了。）
ApplicationContext接口

这时候ApplicationContext这个现在用的最多的IoC容器，ApplicationContext时BeanFactory的子接口，继续了BeanFactory全部的功能，实例化Bean组装和设置。他自己又有单独的AOP集成，消息资源处置处罚（i18n，国际化），事件发布以及应用层的context的上下文。
Spring保举我们用ApplicationContext做容器
ApplicationContext是非消极加载的，就是在容器一启动，就把设置全部的默认对象创建起来，并放在容器里。
（一启动就加载就是饿加载。getBean的时候才加载就是懒加载。对比饿汉模式和懒汉模式）
Bean
我们经常说Bean，意思就是交给容器管理的对象就是Bean。或者换个说法，Bean是SpringIoC容器实例化，管理，组装和设置的对象。
还有一个我们经常说的元数据，也有说设置元数据。就是我们定义的Bean的信息以及他的依靠关系，这个设置元数据，可以XML，可以是注释，也可以是Java代码（构造器）来表示。
（1）基于XML的设置，如今在被替换
（2）基于注解的设置，从Spring2.5开始，对应的注解@Autowired，@PostConstruct，@PreDestory等
（3）基于Java的设置，从Spring3开始，可以用Java文件替换XML设置Bean，比如@Configuration，@Bean，@import和@dependOn注解
定义的设置元数据，加载到Spring容器里，会被转换成BeanDefinition，BeanDefinition会记录全部分析道Bean的定义。这种的好处就是没须要，没须要用到设置信息分析一遍设置数据。用到设置数据就不消再去分析一遍设置数据。
三者关系是这个链条：
设置元数据 （xml <bean …> ,注解，Java设置文件） -----》
BeanDefinition（指导容器的Bean实例化对象）-----》
Bean（容器天生管理的对象）
BeanDefinition包含以下信息：
（1）包限定类名，通常定义Bean的实现类
（2）Bean所限定的包的全限定类名，表示Bean的实际类型
（3）Bean行为的设置元素，用于说明Bean在容器中的作用范围，生命周期限定函数
（4）对Bean所需要其他依靠的Bean类的引用，这些引用也被叫做依靠项和协作者。
（5）在新创建的对象设置其他属性，连接池中Bean的线程数
（6）其他属性
设置元数据被加载成BeanDefinition被容器加载，然后在容器启动中，IoC容器启动中来完成依靠注入。
基于XML的Bean装配

XML是设置元数据的最基础的设置，Spring为bean的设置提供多个标签和多个属性。
标签作为和其他标签的容器，作为文档中的根元素。
多个XML的设置文件

可以用多个设置文件，区分不同的模块。
（1）在使用ApplicationContext的时候，在构造函数中通报多个XM文件设置文件位置参数
（2）除了构造函数，还可以在XML设置文件，使用一个或者多个标签将其他的XML设置文件导入到一个设置文件中。
构造器加载设置文件方式：

1. @Test
2. public void constructor() {
3.     //构造函数传递多个参数
4.     ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml","spring-config2.xml");
5.     System.out.println(Arrays.toString(ac.getBeanDefinitionNames()));
6. }

复制代码

import引入文件：

1. <import resource="spring-config2.xml"/>

复制代码

命名Bean

在IoC容器中，name和id属性可以为Bean命名，id是全局唯一，name可以有多个。

1. <bean id="helloSpring" name="helloSpring helloSpring3" class="com.spring.core.HelloSpring"/>

复制代码

实例化Bean
XML文件，bena标签他不是对象，只是一个形貌创建一个Bean的方式。
IoC容器在帮我们实例化bean对象的方法包括构造器、静态工厂、实例工厂三种，我们可以指定实例化方式。
（1）构造函数实例化
到多数情况下，IoC容器使用构造器来创建Bean的实例，底层是基于反射的机制，使用无参构造器或者对应的参数的构造器。
内部类的实例化，在XML设置一个类的内部类，只需要在class中指明内部类的全路径类名。
也可以使用$将内部类名与外部类名分开（如果嵌套超过两层的内部类，那么就必须使用 $。另外，对于type属性，则同样需要使用 $）。
在HelloSpring类创建两个内部类

1. public static class StaticInnerClass {
2.     public StaticInnerClass() {
3.         System.out.println("静态内部类初始化");
4.     }
5. }
7. public class InnerClass {
8.     public InnerClass() {
9.         System.out.println("内部类初始化");
10.     }
11. }

复制代码

XML设置文件设置内部类

1. <!--静态内部类的初始化，和外部类一样的。 使用.或者$将内部类名与外部类名分开都行-->
2. <bean class="com.spring.core.HelloSpring.StaticInnerClass"/>
3. <bean class="com.spring.core.HelloSpring.StaticInnerClass"/>
5. <bean class="com.spring.core.HelloSpring$StaticInnerClass"/>
6. <bean class="com.spring.core.HelloSpring$StaticInnerClass"/>
9. <!--非静态内部类的初始化需要依赖外部类对象-->
10. <bean name="helloSpring " class="com.spring.core.HelloSpring"/>
12. <bean class="com.spring.core.HelloSpring.InnerClass">
13.     <!--属性依赖注入，后面会讲-->
14.     <constructor-arg ref="helloSpring"/>
15. </bean>
16. <bean class="com.spring.core.HelloSpring$InnerClass">
17.     <!--属性依赖注入，后面会讲-->
18.     <constructor-arg ref="helloSpring"/>
19. </bean>

复制代码

（2）静态工厂方法实例化
工厂模式的应用，我们创建对象让Spring去调用，通过Spring标签嵌入。调用一次创建方式，将创建的对象放入容器中去管理。既然是静态工厂，这个对象不会实例化。
静态工厂，bean标签中的class属性不再是获取bean，使用factory-bean属性指定获取Bean的对象的工厂方法名称。
静态方法类

1. /**
2. * @author lx
3. */
4. public class HelloSpringStaticFactory {
6.     private static HelloSpring helloSpring = new HelloSpring();
8.     /**
9.      * 静态工厂方法
10.      *
11.      * @return 返回HelloSpring实例
12.      */
13.     public static HelloSpring getHelloSpring() {
14.         System.out.println("静态工厂方法");
15.         return helloSpring;
16.     }
18.     public HelloSpringStaticFactory() {
19.         System.out.println("静态工厂不会初始化");
20.     }
21. }

复制代码

XML设置文件设置静态工厂

1. <!--class表示静态工厂的全路径类名-->
2. <!--factory-method表示静态工厂方法-->
3. <bean name="helloSpring" class="com.spring.core.HelloSpringStaticFactory" factory-method="getHelloSpring"/>

复制代码

静态工厂方法违反了Spring的初志，由于我们还是要编写代码new对象，但是实用于那种需要对一个集合进行实例化的情况，由于集合的实例化如果使用设置文件编写的话，那也挺麻烦的。
（3）实例工厂方法实例化
实例工厂自己要实例化工厂类，随后从工厂实例的非静态方法中调用方法获取所需的bean。
使用factory-bean属性指定实例工厂的方式的名字（对比静态工厂是指定方法，实例化工厂指定名字。），factory bean固然代表一个工厂，但是其实例仍旧交给Spring管理，另外Spring中还有一个FactoryBean，这只是一个类不是一个东西。
实例工厂类

1. /**
2. * @author lx
3. */
4. public class HelloSpringInstanceFactory {
6.     private static HelloSpring helloSpring = new HelloSpring();
8.     /**
9.      * 静态工厂方法
10.      *
11.      * @return 返回HelloSpring实例
12.      */
13.     public  HelloSpring getHelloSpring() {
14.         System.out.println("实例工厂方法");
15.         return helloSpring;
16.     }
18.     public HelloSpringInstanceFactory() {
19.         System.out.println("实例工厂会初始化");
20.     }
21. }

复制代码

XML设置文件

1. <!--实例化工厂-->
2. <bean id="helloSpringInstanceFactory" class="com.spring.core.HelloSpringInstanceFactory"/>
3. <!--factory-bean表示实例工厂的名字-->
4. <!--factory-method表示实例工厂方法-->
5. <bean name="helloSpring" factory-bean="helloSpringInstanceFactory" factory-method="getHelloSpring"/>

复制代码

基于XML的依靠装配

依靠项注入，是指对象通过仅仅通过构造函数参数，工厂方法的参数或工厂方法构造返回对象实例后，在其上设置属性来定义其依靠的其他对象。
随后，在IoC容器创建Bean，会主动注入这个Bean的依靠项。这个过程和之前那种创建Bean，主动通过构造器和setter方法设置依靠项是相反的。（意思就是之前主动注入，和之前谁人自己构造器和setter来注入依靠。一个是无感知的被动，一个是要自己主动注入。这就是控制反转，控制就是谁来注入，反转就是这个控制转给别的人。）
IoC就是把Bean交给容器来管理，另一方面有些Bean没有被设置元信息，但是他却被别的要管理的Bean依靠，也就是有依靠关系存在。我不想手动去设置这个Bean的设置信息，怎么办？
这就需要DI，依靠注入来帮助注入依靠项。不再需要主动去查找这些Bean的，直接交给DI来完成。
和前面的IoC的Bean的实例化不同（xml，注解，或者Java代码 另一方面 构造器，静态工厂方法，工厂方法类），DI的实例化构造方式只有两种，一个是构造器另一个是setter方法。
（1）构造器依靠注入
构造器的依靠注入，实际上就是依靠构造函数参数来完成，每一个参数都是一个依靠项，你可以把这个构造器明白成一个静态工厂方法来实例化依靠项。
Ioc的实例化Bean的构造器代码

1. /**
2. * @author lx
3. * 构造器依赖注入
4. */
5. public class SimpleConstructorBased {
6.     /**
7.      * 依赖的两个属性
8.      */
9.     private String property1;
10.     private String property2;
12.     /**
13.      * 测试构造器依赖注入
14.      */
15.     public SimpleConstructorBased(String property1, String property2) {
16.         this.property1 = property1;
17.         this.property2 = property2;
18.         System.out.println("构造器依赖注入");
19.     }
21.     @Override
22.     public String toString() {
23.         return "SimpleConstructorBased{" +
24.                 "property1='" + property1 + '\'' +
25.                 ", property2='" + property2 + '\'' +
26.                 '}';
27.     }
28. }

复制代码

XML的设置

1. <!--构造函数属性注入-->
2. <bean id="simpleConstructorBased" class="com.spring.core.SimpleConstructorBased">
3.     <!--一个constructor-arg表示一个属性-->
4.     <constructor-arg value="v1"/>
5.     <constructor-arg value="v2"/>
6. </bean>

复制代码

要注意要用到子标签<construct - arg>,一个标签就是一个依靠注入的依靠项。
指定参数名
想一下有一个这样的场景，一个是同样参数个数的构造器而且参数是根本类型的两个构造器，Spring能不能区分出来呢？
实际上不能，在项目开发中也会发现Spring涉及到的根本类型的都是包装类，Spring是有一点区分不了根本类型，由于这些根本类型都不是Object的子类，又在中间处置处罚成String，你怎么做反射这些。再加上参数个数又一样，Spring就会随便第一个，这个第一个可能不是我们想要的。
这时候我们怎么办，就需要在在这个子标签里，设置name属性来订定实例化用哪个。

1. <bean id="simpleConstructorBased2"
2. class="com.spring.core.SimpleConstructorBased2">
3.     <constructor-arg value="1" name="property1"/>
4.     <constructor-arg value="true" name="property3"/>
5. </bean>

复制代码

测试Java代码

1. /**
2. * @author lx
3. * 构造器依赖注入
4. */
5. public class SimpleConstructorBased2 {
6.     /**
7.      * 依赖的两个属性
8.      */
9.     private int property1;
10.     private String property2;
11.     private boolean property3;
13.     /**
14.      * 测试构造器依赖注入1
15.      */
16.     public SimpleConstructorBased2(int property1, String property2) {
17.         this.property1 = property1;
18.         this.property2 = property2;
19.         System.out.println("构造器依赖注入1");
20.     }
22.     /**
23.      * 测试构造器依赖注入2
24.      */
25.     public SimpleConstructorBased2(int property1, boolean property3) {
26.         this.property1 = property1;
27.         this.property3 = property3;
28.         System.out.println("构造器依赖注入2");
29.     }
31.     @Override
32.     public String toString() {
33.         return "SimpleConstructorBased2{" +
34.                 "property1=" + property1 +
35.                 ", property2='" + property2 + '\'' +
36.                 ", property3=" + property3 +
37.                 '}';
38.     }
39. }

复制代码

指定参数类型
有可能存在这样一种情况：多个构造器，具有雷同的参数名和数量，但是参数类型不同等的情况，这样的情况下，仍旧不能确定到底使用哪一个构造器。
（前面参数数量雷同和根本类型，这面是雷同数量和雷同的参数名）

1. /**
2. * @author lx
3. * 构造器依赖注入
4. */
5. public class SimpleConstructorBasedx {
6.     /**
7.      * 依赖的四个属性
8.      */
9.     private String property1;
10.     private String property2;
11.     private int property3;
12.     private boolean property4;
15.     /**
16.      * 测试构造器依赖注入1
17.      */
18.     public SimpleConstructorBasedx(String property1, boolean property2) {
19.         this.property1 = property1;
20.         this.property4 = property2;
21.         System.out.println("构造器依赖注入1");
22.     }
24.     /**
25.      * 测试构造器依赖注入2
26.      */
27.     public SimpleConstructorBasedx(int property1, boolean property2) {
28.         this.property3 = property1;
29.         this.property4 = property2;
30.         System.out.println("构造器依赖注入2");
31.     }
34.     /**
35.      * 测试构造器依赖注入3
36.      */
37.     public SimpleConstructorBasedx(String property1, String property2) {
38.         this.property1 = property1;
39.         this.property2 = property2;
40.         System.out.println("构造器依赖注入3");
41.     }
45.     /**
46.      * 测试构造器依赖注入4
47.      */
48.     public SimpleConstructorBasedx(String property1, int property3, String property2) {
49.         this.property1 = property1;
50.         this.property2 = property2;
51.         this.property3 = property3;
52.         System.out.println("构造器依赖注入4");
53.     }
55.     /**
56.      * 测试构造器依赖注入5
57.      */
58.     public SimpleConstructorBasedx(String property1, String property2, int property3) {
59.         this.property1 = property1;
60.         this.property2 = property2;
61.         this.property3 = property3;
62.         System.out.println("构造器依赖注入5");
63.     }
65.     @Override
66.     public String toString() {
67.         return "SimpleConstructorBasedx{" +
68.                 "property1='" + property1 + '\'' +
69.                 ", property2='" + property2 + '\'' +
70.                 ", property3=" + property3 +
71.                 ", property4=" + property4 +
72.                 '}';
73.     }
74. }

复制代码

前三个构造器，构造器的形参列表参数名字完全同等，这种情况可以用指定type，

1. <bean id="simpleConstructorBasedx"
2. class="com.spring.core.SimpleConstructorBasedx">
3.     <constructor-arg name="property1" value="1" type="int"/>
4.     <constructor-arg name="property2" value="true"  type="boolean"/>
5. </bean>

复制代码

指定参数次序，使用index属性

1. <bean id="simpleConstructorBasedx"
2. class="com.spring.core.SimpleConstructorBasedx">
3.     <!--一个constructor-arg表示一个属性-->
4.     <constructor-arg name="property1" value="xx" type="java.lang.String"/>
5.     <constructor-arg name="property3" value="1" type="int" index="1"/>
6.     <constructor-arg name="property2" value="yy" type="java.lang.String"/>
7. </bean>

复制代码

（2）setter参数注入
setter依靠注入通过IoC容器调用参数的setter方法，他实行的次序是在构造器实例化后再实例setter方法来实例化。
ApplicationContext对于他所管理Bean的支持同时基于构造器和基于setter方法的依靠注入，依靠注入的属性开始都是value的bean字符串保存起来，随后通过PropertiyEditor（属性编译器，Spring内部扩展Java原生的PropertyEditor）转换为实际类型。转换过程是IoC容器主动转换，固然这个编辑器也是可以自定义的。
和前面的标签对比，setter方法对应的子标签是，name属性表示属性名 value 属性表示属性值。

1. /**
2. * @author lx
3. */
4. public class SimpleSetterBased {
5.     /**
6.      * 依赖的5个属性
7.      */
8.     private String property1;
9.     private String property2;
10.     private int property3;
11.     private boolean property4;
12.     private int property5;
15.     /**
16.      * 构造器依赖注入
17.      */
18.     public SimpleSetterBased(String property1, String property2) {
19.         this.property1 = property1;
20.         this.property2 = property2;
21.         System.out.println("构造器依赖注入");
22.     }
24.     //setter方法依赖注入，idea生成stter方法
26.     public void setProperty3(int property3) {
27.         System.out.println("setter注入property3");
28.         this.property3 = property3;
29.     }
30.     public void setPr11operty5(int property5) {
31.         System.out.println("setter注入property5");
32.         this.property5 = property5;
33.     }
35.     public void setProperty4(boolean property4) {
36.         System.out.println("setter注入property4");
37.         this.property4 = property4;
38.     }
41.     @Override
42.     public String toString() {
43.         return "SimpleSetterBased{" +
44.                 "property1='" + property1 + '\'' +
45.                 ", property2='" + property2 + '\'' +
46.                 ", property3=" + property3 +
47.                 ", property4=" + property4 +
48.                 ", property5=" + property5 +
49.                 '}';
50.     }
51. }

复制代码

xml设置文件

1. <!--setter and constructor-->
2. <bean id="simpleSetterBased" class="com.spring.core.SimpleSetterBased">
3.     <!--构造器参数 name表示参数名 value 表示参数值-->
4.     <constructor-arg name="property1" value="xxx"/>
5.     <constructor-arg name="property2" value="yyy"/>
6.     <!--setter方法 name表示属性名 value 表示属性值-->
7.     <property name="property3" value="123"/>
8.     <property name="property4" value="true"/>
9.     <!--name还可以表示方法名除了set后面的部分，不一定是属性名-->
10.     <property name="Pr11operty5" value="321"/>
11. </bean>

复制代码

工厂方法的依靠注入（区别之前的依靠注入）

使用静态工厂方法或者实例工厂方式实例bean时，同样可以注入依靠，方法上的参数可视为bean的依靠项，用于构造器注入，同样使用< constructor-arg >标签，而setter注入则不受影响。
依靠注入的分析流程

容器实行Bean的分析流程
1 ApplicationContext容器被实例化，包含全部Bean的全部设置元信息
2 对于每一个bean，其依靠项以属性set方法，构造函数参数或静态工厂方法的参数形式表示。创建bean，这些依靠项通报依靠给bean。
3 每个需要注入的依靠项，要实际设置value的值，或对Bean的另一个ref引用，最开始统一为一个字符串格式。
4 属性值在字符串形貌转换为实际属性的类型。
循环依靠

bean的依靠项和依靠项的依靠项会在bean创建之前创建（也就是A依靠B，B会在A创建前就创建成功。）
这种依靠关系创建的情况，构造器注入就会出现循环依靠，A依靠B，B依靠A。
一种解决方式就是使用setter注入，当两个互相依靠的bean都创建完毕之后，才会调用set方法进行依靠注入。
构造器和setter注入的选择

我们怎么选择依靠注入的方式，看情况分心：
对于逼迫依靠使用构造器
对于可选的依靠项选择setter方法（在setter方法上加@required，使这个属性为必填属性）

1. public class MyBean {
2.     private String requiredProperty;
3.    
4.     @Required  // 标记此属性必须注入
5.     public void setRequiredProperty(String requiredProperty) {
6.         this.requiredProperty = requiredProperty;
7.     }
8. }

复制代码

实用于非显式主动装配的场景（如早期XML设置），或需明确标记某些属性为必须依靠的情况。
标记在Setter方法上，表示该属性必须在Bean初始化时被显式赋值（通过XML设置、Java Config或主动装配）
Spring团队如今保举使用构造器注入，构造器注入可以大概包管注入的组件不可变，而且确保需要的依靠不为null。此外，构造器注入的依靠总是可以大概在返回客户端（组件）代码的时候包管完全初始化的状态，还能检测循环依靠。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。