• 初识Spring（一）IOC

    Spring 框架是一个开源的 Java 平台，它最初是由 Rod Johnson 编写的，并且于 2003 年 6 月首次在 Apache 2.0 许可下发布。

    Spring 框架的核心特性是可以用于开发任何 Java 应用程序，但是在 Java EE 平台上构建 web 应用程序是需要扩展的。 Spring 框架的目标是使 J2EE 开发变得更容易使用，通过启用基于 POJO编程模型来促进良好的编程实践。

    Spring Framework

    Spring 基础框架，可以视为 Spring 基础设施，基本上任何其他 Spring 项目都是以 Spring Framework为基础的。

    其五大功能模块

    IOC：Inversion of Control，翻译过来是反转控制。

    反转控制的思想完全颠覆了应用程序组件获取资源的传统方式：反转了资源的获取方向——改由容器主动的将资源推送给需要的组件，开发人员不需要知道容器是如何创建资源对象的，只需要提供接收资源的方式即可，极大的降低了学习成本，提高了开发的效率。这种行为也称为查找的被动形式。

    DI：Dependency Injection，翻译过来是依赖注入。

    DI 是 IOC 的另一种表述方式：即组件以一些预先定义好的方式（例如：setter 方法）接受来自于容器的资源注入。相对于IOC而言，这种表述更直接。

    结论：IOC 就是一种反转控制的思想， 而 DI 是对 IOC 的一种具体实现。

    IOC容器在Spring中的实现

    Spring 的 IOC 容器就是 IOC 思想的一个落地的产品实现。IOC 容器中管理的组件也叫做 bean。在创建bean 之前，首先需要创建 IOC 容器。Spring 提供了 IOC 容器的两种实现方式：

    ①BeanFactory

    这是 IOC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。

    ②ApplicationContext

    BeanFactory 的子接口，提供了更多高级特性。面向 Spring 的使用者，几乎所有场合都使用
    ApplicationContext 而不是底层的 BeanFactory。


    crtl+n,搜索

    ctrl+h，找到BeanFactory，找到ApplicationContext的子类，其相比父类提供刷新容器和关闭容器的方法。

    再往下看，我们需要使用的是FileSystemXML。。。。和下面的Class，，这两个ApplicationContext（IOC容器实现类）实现类。

    二者区别是一个利用文件系统（即当前磁盘中获取文件，如果需要再其它电脑上执行，则也要有相应的路径和文件），一个利用类路径来获取IOC容器。下面的Class，，类用的比较多。

    基于XML管理bean

    入门案例：

    ①创建Maven Module
    ②引入依赖

    在resources下创建配置文件，新建-》xml配置文件-》spring，（改配置文件的起名，这里可以随意，因为现在是自己可以指定xml文件获取IOC容器，在后面ssm的使用中就不能随意取了）

    （最后resources和java文件将会放在加载到一起）

    文件内容：

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.     
    6.    <bean id="helloworld" class="personal.september.hello.pojo.HelloWorld">bean>
    7. beans>

    一个bean表示一个对象（class属性里不能是接口），通过id来区别一个对象，并准确的获取到一个对象。

    1. public class HelloWorld {
    2.     public void hello(){
    3.         System.out.println("spring");
    4.     }
    5. }
    6.  
    7.  
    8.  public void test(){
    9.         //获取IOC容器
    10.         ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
    11.         //获取IOC容器下的bean对象
    12.         HelloWorld helloworld= (HelloWorld) ioc.getBean("helloworld");
    13.         helloworld.hello();
    14.     }

    ioc容器有不同的获取方法，这里使用的是通过id获取，的那因为是通过id获取，这里并不知道它的类型，所以要自己写明生成类型，即会生成

    手动改变类型并强转，获得相应对象，并调取对象有的方法。

    （注意，当你创建一个类，又给它创建有参的构造方法时，记得一定要有无参构造方法，否则不能利用反射+工厂模式创建对象），spring的底层就是根据配置文件的bean标签所设置的class属性具体类型通过反射利用无参构造去创建对象。）

    获取bean的三种方式：（即getBean(参数不一样））

    1、根据id获取，返回值是object。（由于 id 属性指定了 bean 的唯一标识，所以根据 bean 标签的 id 属性可以精确获取到一个组件对象。上个实验中我们使用的就是这种方式。）

    2、根据类型获取

    1.  public void testIOC(){
    2.         ApplicationContext ioc = new ClassPathXmlApplicationContext("spring_ioc.xml");
    3. //        Student student = (Student) ioc.getBean("student1");
    4.         Student student = ioc.getBean(Student.class);
    5.         System.out.println(student);
    6. }

    要求IOC容器中有且只有一个类型匹配的bean。

    但是如果有多个类型相同的对象，

    会有如下报错报错

    如果一个匹配的bean都没有，则是如下

    3、根据id和类型获取

    1.  public void testIOC(){
    2.         ApplicationContext ioc = new ClassPathXmlApplicationContext("spring_ioc.xml");
    3. //        Student student = (Student) ioc.getBean("student1");
    4. //        Student student = ioc.getBean(Student.class);
    5.         Student student = ioc.getBean("student1", Student.class);
    6.         System.out.println(student);
    7.     }

    （一般一个类型就配置一个人bean即可，如果有多个选项，bean标签里还有属性可以设置，可以解决这个问题（设置scope属性等于prototype（多例）即可，默认是singleton（单例）），就不需要配置同种类型的多个bean标签。综上方法，使用最多的还是根据类型获取bean。

     （补充：

    如果组件类实现了接口，可以根据接口类型获取 bean，前提是bean唯一，如下

    Person为接口类，Student类继承Person，重写了父类的say方法。得到如下测试结果。

    但如果一个接口有多个实现类，这些实现类都配置了 bean，不可以根据接口类型获取 bean。

    结论：根据类型来获取bean时，在满足bean唯一性的前提下，其实只是看：『对象 instanceof 指定的类型』的返回结果，只要返回的是true就可以认定为和类型匹配，能够获取到。（即通过bean的类型，bean所继承的类的类型、bean所实现的接口的类型都可以获取bean）

    依赖注入

    1、setter注入（依赖注入即为为依赖的属性进行赋值的过程）

    创建实体类后，配置bean时为属性赋值即可实现的setter方式注入

    在配置文件中：

    1. "student2" class="personal.september.spring.pojo.Student">
    4.         
    5.         "sid"   value="1111">
    6.         "sname" value="大大">
    7.         "age"   value="7">
    8.         "gender" value="女">
    9.

    （记住这里需要设置的不是成员变量的值，而是属性的值，即使是成员变量，但没有对应的set方法，赋值也会报错）

    测试方法下：

    2、构造器注入

    在实体类中添加有参构造

    1. public Student(Integer sid, String sname, Integer age, String gender) {
    2.         this.sid = sid;
    3.         this.sname = sname;
    4.         this.age = age;
    5.         this.gender = gender;
    6.     }

    配置bean（按有参构造中参数的顺序去赋值，有几个constructor-arg标签时则会匹配对应参数个数的构造方法）

    1. "student3" class="personal.september.spring.pojo.Student">
    2.         "1122">
    3.         "紫紫" >
    4.         "6" >
    5.         "女" >
    6.

    （如果有多个参数个数相同的构造方法，则都可能被匹配，这时可以用constructor-arg中的name属性指定赋值属性。）

    注意：
    constructor-arg标签还有两个属性可以进一步描述构造器参数：
    index属性：指定参数所在位置的索引（从0开始）
    name属性：指定参数名

    可以通过value属性赋值，也可以通过value子标签

    如果属性时特殊值我们应该如何赋值呢

    特殊值处理

    ①字面量赋值

    2. <property name="name" value="张三"/>

    ②null值

    1. <property name="name">
    2.     <null />
    3. property>

    单个也可。

    （发现上图不用name属性会报错，上图二者效果相同）

    以下写法，为name所赋的值是字符串null

    <property name="name" value="null">property>

    ③xml实体

    3. <property name="expression" value="a < b"/>

    a < b表示a

    ④CDATA节（只能以标签的方式来写，不能写在属性里，如下就是在value标签中而不是和name一样在后面赋值value属性的方式）

    1. <property name="expression">
    6.     <value>value>
    7. property>

    为类类型属性赋值

    比如现有实体类Clazz，Student，二者大致内容如下

    1. public class Student  {
    2.     private Integer sid;
    3.     private String sname;
    4.     private Integer age;
    5.     private String gender;
    6.     private Clazz clazz;
    7.  
    8.  
    9. public class Clazz {
    10.     private Integer cid;
    11.     private String cname;

    方式一：引用外部已声明的bean

    1. <bean id="student4" class="personal.september.spring.pojo.Student">
    2.         <property name="sid"   value="1111">property>
    3.         <property name="sname" value="大大">property>
    4.         <property name="age"   value="7">property>
    5.         <property name="gender" value="女" >property>
    7.        
    8.         <property name="clazz" ref="clazz1">property>
    9.     bean>
    11.     <bean id="clazz1" class="personal.september.spring.pojo.Clazz">
    12.         <property name="cid" value="1001">property>
    13.         <property name="cname"  value="理科班">property>
    14.     bean>

    (补充：如果错把ref属性写成了value属性，会抛出异常：

    Caused by: java.lang.IllegalStateException:Cannot convert value of type 'java.lang.String' to required type 'com.atguigu.spring.bean.Clazz' for property 'clazz': no matching editors or conversion  strategy found
    意思是不能把String类型转换成我们要的Clazz类型，说明我们使用value属性时，Spring只把这个属性看做一个普通的字符串，不会认为这是一个bean的id，更不会根据它去找到bean来赋值

    方式二：级联属性赋值

    （这里用到了上面的clazz1，相当于改变了已有对象的值，总之用级联方式的前提要先实例化这个对象或者给类的属性赋值之后）

    1.  <bean id="student5" class="personal.september.spring.pojo.Student">
    2.         <property name="sid" value="1004">property>
    3.         <property name="sname" value="小粉">property>
    4.         <property name="age" value="3">property>
    5.         <property name="gender" value="女">property>
    6.         
    7.         <property name="clazz" ref="clazz1">property>
    8.         <property name="clazz.cid" value="1002">property>
    9.         <property name="clazz.cname" value="文科班">property>
    10.     bean>

    如下实例化对象，在Student类中。

    方式三：内部bean

    1. <bean id="student6" class="personal.september.spring.pojo.Student">
    2.         <property name="sid" value="1004">property>
    3.         <property name="sname" value="小粉">property>
    4.         <property name="age" value="3">property>
    5.         <property name="gender" value="女">property>
    6.  
    7.         <property name="clazz" >
    8.             <bean id="clazz2" class="personal.september.spring.pojo.Clazz">
    9.                 <property name="cid" value="1003">property>
    10.                 <property name="cname" value="特长班">property>
    11.             bean>
    12.         property>
    13.     bean>

    但是我们发现内部bean无法通过IOC容器直接获取，只能在当前Bean的内部使用。

    为数组类型属性赋值

    修改Student类，添加一个数组类型的成员变量。

    private String[] hobby;还有它的get和set方法，还有toString方法记得要重写！

    配置bean

    1. <bean id="student6" class="personal.september.spring.pojo.Student">
    2.         <property name="sid" value="1004">property>
    3.         <property name="sname" value="小粉">property>
    4.         <property name="age" value="3">property>
    5.         <property name="gender" value="女">property>
    6.         <property name="clazz" >
    7.             <bean id="clazz2" class="personal.september.spring.pojo.Clazz">
    8.                 <property name="cid" value="1003">property>
    9.                 <property name="cname" value="特长班">property>
    10.             bean>
    11.         property>
    12.         <property name="hobby">
    13.             <array>
    14.                 <value>学习value>
    15.                 <value>打游戏value>
    16.                 <value>听音乐value>
    17.             array>
    18.         property>
    19.     bean>

    （补充：

    如果数组里面存储的数据类型是字符串或字面量类型，则直接用value来设置值，如果是类类型则用ref标签，来引用一些bean标签）

    如下测试了一下类类型

    为集合类型属性赋值

    ①为List集合类型属性赋值

    修改Clazz类，添加一个成员变量：

    private List students;并创建其get和set方法，重写toString方法！

    （班级对学生是一对多的关系）

    配置bean：

    1. <bean id="clazz3" class="personal.september.spring.pojo.Clazz">
    2.         <property name="cid" value="1004">property>
    3.         <property name="cname" value="卓越班">property>
    4.         <property name="students" >
    5.             <list>
    6.                 <ref bean="student4">ref>
    7.                 <ref bean="student5">ref>
    8.                 <ref bean="student6">ref>
    9.             list>
    10.         property>
    11.     bean>

    因为有些student的一些属性没有赋值，所以参数值参差不齐）

    另一种方式：配置一个集合类型的bean实现（需要使用util的约束）

    1.  <bean id="clazz3" class="personal.september.spring.pojo.Clazz">
    2.         <property name="cid" value="1004">property>
    3.         <property name="cname" value="卓越班">property>
    4.         <property name="students" ref="studentList">property>
    5.     bean>
    6.     
    7.     <util:list id="studentList">
    8.         <ref bean="student4">ref>
    9.         <ref bean="student5">ref>
    10.         <ref bean="student6">ref>
    11.     util:list>

    ②为Map集合类型属性赋值

    新建一个类，并且在Student类中添加成员变量。

    1. public class Teacher {
    2.     private Integer tid;
    3.     private String tname;
    4.  
    5.  
    6. 在Student中，记得还有其get和set方法，重写toString
    7. private Map teacherMap;

    配置bean

    1. <bean id="student8" class="personal.september.spring.pojo.Student">
    2.         <property name="sid" value="1004">property>
    3.         <property name="sname" value="小粉">property>
    4.         <property name="age" value="3">property>
    5.         <property name="gender" value="女">property>
    6.         <property name="clazz" >
    7.             <bean id="clazz5" class="personal.september.spring.pojo.Clazz">
    8.                 <property name="cid" value="1005">property>
    9.                 <property name="cname" value="特长班">property>
    10.             bean>
    11.         property>
    12.         <property name="hobby">
    13.             <array>
    14.                 <value>学习value>
    15.                 <value>打游戏value>
    16.                 <value>听音乐value>
    17.             array>
    18.         property>
    19.         <property name="teacherMap">
    20.             <map>
    21.                 <entry key="数学" value-ref="teacher1">entry>
    22.                 <entry key="语文" value-ref="teacher2">entry>
    23.                 <entry key="英语" value-ref="teacher3">entry>
    24.             map>
    25.         property>
    26.     bean>
    27.  
    28.     <bean id="teacher1" class="personal.september.spring.pojo.Teacher">
    29.         <property name="tid" value="001">property>
    30.         <property name="tname" value="张老师">property>
    31.     bean>
    32.     <bean id="teacher2" class="personal.september.spring.pojo.Teacher">
    33.         <property name="tid" value="002">property>
    34.         <property name="tname" value="王老师">property>
    35.     bean>
    36.     <bean id="teacher3" class="personal.september.spring.pojo.Teacher">
    37.         <property name="tid" value="003">property>
    38.         <property name="tname" value="贾老师">property>
    39.     bean>

    （如果键为字面量则用key属性，如果是类类型则用key-ref，同理如果值为字面量则用value属性，如果是类类型则用value-ref）测试结果如下：

    另一种方式：配置一个集合类型的bean实现（需要使用util的约束）

    1. <bean id="student8" class="personal.september.spring.pojo.Student">
    2.         省略和上面相同部分
    3.    。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
    4.         <property name="teacherMap" ref="teachermap">property>
    5.     bean>
    6.  
    7.     <util:map id="teachermap">
    8.         <entry key="数学" value-ref="teacher1">entry>
    9.         <entry key="语文" value-ref="teacher2">entry>
    10.         <entry key="英语" value-ref="teacher3">entry>
    11.     util:map>
    12.     <bean id="teacher1" class="personal.september.spring.pojo.Teacher">
    13.         <property name="tid" value="001">property>
    14.         <property name="tname" value="张老师">property>
    15.     bean>
    16.     <bean id="teacher2" class="personal.september.spring.pojo.Teacher">
    17.         <property name="tid" value="002">property>
    18.         <property name="tname" value="王老师">property>
    19.     bean>
    20.     <bean id="teacher3" class="personal.september.spring.pojo.Teacher">
    21.         <property name="tid" value="003">property>
    22.         <property name="tname" value="贾老师">property>
    23.     bean>

    （也可以使用key和value标签形式，同理value是字面量是使用value标签，如下是ref引用

    1. <property name="teacherMap">
    2.             <map>
    3.                 <entry>
    4.                     <key>
    5.                         <value>数学value>
    6.                     key>
    7.                     <ref bean="teacher1">ref>
    8.                 entry>

    p命名空间方式

    （引入p命名空间后，可以通过以下方式为bean的各个属性赋值

    1. <bean id="student9" class="personal.september.spring.pojo.Student"
    2.            p:sid="1199" p:sname="一号" p:teacherMap-ref="teachermap">bean>

    （上述代码只给sid，name和teachermap属性赋值，所以下面结果大都为null。每个属性都有两种形式，带ref则是为类类型赋值,采用引用的方式。

    引入外部属性文件（将文件交给IOC管理）

    ①加入依赖

    （在上面原有的基础上加入如下依赖

    1.         
    2.         <dependency>
    3.             <groupId>mysqlgroupId>
    4.             <artifactId>mysql-connector-javaartifactId>
    5.             <version>8.0.16version>
    6.         dependency>
    7.         
    8.         <dependency>
    9.             <groupId>com.alibabagroupId>
    10.             <artifactId>druidartifactId>
    11.             <version>1.0.31version>
    12.         dependency>

    ②创建外部属性文件

    1. jdbc.user=root
    2. jdbc.password=1234567
    3. jdbc.url=jdbc:mysql://localhost:3306/spring?serverTimezone=UTC
    4. jdbc.driver=com.mysql.cj.jdbc.Driver

    ③引入属性文件（在xml配置文件中

    2. <context:property-placeholder location="classpath:jdbc.properties"/>

    如下是过时的类，但是可以知道用bean也是可以实现引入

    ④配置bean

    1. <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    2.         <property name="url" value="${jdbc.url}"/>
    3.         <property name="driverClassName" value="${jdbc.driver}"/>
    4.         <property name="username" value="${jdbc.user}"/>
    5.         <property name="password" value="${jdbc.password}"/>
    6.         
    7.     bean>

    ⑤测试

    1. public void testDataSource() throws SQLException {
    2.         ApplicationContext ioc = new ClassPathXmlApplicationContext("spring_datasource.xml");
    3.         DruidDataSource dataSource = ioc.getBean(DruidDataSource.class);
    4.         System.out.println(dataSource.getConnection());
    5.     }

    bean的作用域

    ①概念
    在Spring中可以通过配置bean标签的scope属性来指定bean的作用域范围，各取值含义参加下表：

    （如下测试

    1.  
    3. <bean id="user" class="personal.september.spring.pojo.User">
    4.         <property name="name" value="forget">property>
    5.         <property name="age" value="19">property>
    6.     bean>

    （上图答案为true，说明其实只创建了一个实例对象，永远用的都是一个对象。这和scope默认为singleton（单例）有关，当我们做如下修改

    结果为false，说明每次通过bean获取的不是同一个对象。

    如果是在WebApplicationContext环境下还会有另外两个作用域（但不常用）：

    bean的生命周期

    ①具体的生命周期过程
    bean对象创建（调用无参构造器）
    给bean对象设置属性
    bean对象初始化之前操作（由bean的后置处理器负责）
    bean对象初始化（需在配置bean时指定初始化方法）
    bean对象初始化之后操作（由bean的后置处理器负责）
    bean对象就绪可以使用
    bean对象销毁（需在配置bean时指定销毁方法）
    IOC容器关闭

    ②修改类User

    1. public class User {
    2.     private Integer id;
    3.     private String username;
    4.     private String password;
    5.     private Integer age;
    6.     public User() {
    7.         System.out.println("生命周期：1、创建对象");
    8.     }
    9.     public User(Integer id, String username, String password, Integer age) {
    10.         this.id = id;
    11.         this.username = username;
    12.         this.password = password;
    13.         this.age = age;
    14.     }
    15.     public Integer getId() {
    16.         return id;
    17.     }
    18.     public void setId(Integer id) {
    19.         System.out.println("生命周期：2、依赖注入");
    20.         this.id = id;
    21.     }
    22.     public String getUsername() {
    23.         return username;
    24.     }
    25.     public void setUsername(String username) {
    26.         this.username = username;
    27.     }
    28.     public String getPassword() {
    29.         return password;
    30.     }
    31.     public void setPassword(String password) {
    32.         this.password = password;
    33.     }
    34.     public Integer getAge() {
    35.         return age;
    36.     }
    37.     public void setAge(Integer age) {
    38.         this.age = age;
    39.     }
    40.     public void initMethod(){
    41.         System.out.println("生命周期：3、初始化");
    42.     }
    43.     public void destroyMethod(){
    44.         System.out.println("生命周期：5、销毁");
    45.     }
    46.     @Override
    47.     public String toString() {
    48.         return "User{" +
    49.                 "id=" + id +
    50.                 ", username='" + username + '\'' +
    51.                 ", password='" + password + '\'' +
    52.                 ", age=" + age +
    53.                 '}';
    54.     }
    55. }

    ③配置bean

    1. <bean id="user" class="personal.september.spring.pojo.User">
    2.         <property name="id" value="1">property>
    3.         <property name="username" value="tina">property>
    4.         <property name="password" value="1234567">property>
    5.         <property name="age" value="33">property>
    6.     bean>

    ④测试

    测试后发现，只有两个生命周期，

    因为其中的initMethod()和destroyMethod()，要通过配置bean指定为初始化和销毁的方法

    修改

    当IOC容器关闭时会调用销毁方法

    但是我们知道ApplicationContext类中没有关闭和刷新容器的功能。所以可以用其子接口ConfigurableApplicationContext实现，或者当前实现类也是可以的，如下

    不同作用域对生命周期的影响

    a、bean生命周期的前三个步骤在获取IOC容器时就执行了，而不是获取bean时。（在获取容器时就创建好，这样以后就用这一个对象（默认是单例））

    如果把scope设置成prototype则如下，因为多例情况下每次获取bean都是创建新的对象，所以它并没有像单例一样提前创建，而在多例情况下，前三个生命周期是在获取bean时执行。

    而且在多例情况下，即使关闭资源也没有出现销毁方法，这说明在这个情况下销毁方法不由IOC管理。

    ⑤bean的后置处理器

    bean的后置处理器会在生命周期的初始化前后添加额外的操作，需要实现BeanPostProcessor接口，且配置到IOC容器中，需要注意的是，bean后置处理器不是单独针对某一个bean生效，而是针对IOC容器中所有bean都会执行（即对所有的bean都会执行额外的操作）

    创建bean的后置处理器：

    ctrl+o重写BeanPostProcessor方法

    1. public class MyBeanPostProcessor implements BeanPostProcessor {
    2.  
    3.     @Override
    4.     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    5.         //此方法在bean的生命周期初始化之前执行
    6.         System.out.println("MyBeanPostProcessor-->后置处理器postProcessBeforeInitialization");
    7.         return bean;
    8.  
    9.     }
    10.  
    11.     @Override
    12.     public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    13.         //此方法在bean的生命周期初始化之后执行
    14.         System.out.println("MyBeanPostProcessor-->后置处理器postProcessAfterInitialization");
    15.         return bean;
    16.     }
    17. }

    （如果没有修改直接返回参数bean即可，一开始的返回值写的是

    在IOC容器中配置后置处理器：

    测试

    FactoryBean

    ①简介
    a、FactoryBean是Spring提供的一种整合第三方框架的常用机制。

    和普通的bean不同，配置一个FactoryBean类型的bean，在获取bean的时候得到的并不是b、class属性中配置的这个类的对象，而是getObject()方法的返回值。

    通过这种机制，Spring可以帮我们把复杂组件创建的详细过程和繁琐细节都屏蔽起来，只把最简洁的使用界面展示给我们。

    c、将来整合Mybatis时，Spring就是通过FactoryBean机制来帮我们创建SqlSessionFactory对象的。

    ②创建类UserFactoryBean

    1. public class UserFactoryBean implements FactoryBean {
    2.  
    3.     @Override
    4.     //getObject():通过一个对象交给IOC容器管理
    5.     public User getObject() throws Exception {
    6.         return new User();
    7.     }
    8.  
    9.     @Override
    10.     //getObjectType():设置所提供对象类型
    11.     public Class getObjectType() {
    12.         return User.class;
    13.     }
    14.  
    15.     //isSingleton():所提供的对象是否为单例
    16. //    @Override
    17. //    public boolean isSingleton() {
    18. //        return true;
    19. //    }
    20. }

    (我们重写了这两个方法，一开始的返回值都为null。第三个方法是说明所提供的对象是否为单例，因为默认值为ture就没重写，

    ③配置bean

    <bean class="personal.september.spring.factory.UserFactoryBean">bean>

    ④测试

    上面结果只有生命周期1，因为确实没有注入依赖（为当前属性赋值，我们没有手动获取bean，而是通过UserFactory的bean将对象交给IOC容器）和初始化（要用过bean中的属性进行初始化操作才对）。

    当FactoryBean的实现类配置为bean时，会将当前类中getObject()所返回的对象交给IOC容器管理。

    基于xml的自动装配

    自动装配：
    根据指定的策略，在IOC容器中匹配某一个bean，自动为指定的bean中所依赖的类类型或接口类型属性赋值

    ①场景模拟

    如下创建基本结构，service和dao下接口的实现类在impl包下

    具体内容

    创建类UserController

    1. public class UserController {
    2.     private UserService userService;
    3.     public UserService getUserService() {
    4.         return userService;
    5.     }
    6.     public void setUserService(UserService userService) {
    7.         this.userService = userService;
    8.     }
    9.     public void saveUser(){
    10.         userService.saveUser();
    11.     }
    12. }

    创建接口UserService

    1. public interface UserService {
    2.     void saveUser();
    3. }

    创建类UserServiceImpl实现接口UserService

    1. public class UserServiceImpl implements UserService {
    2.     private UserDao userDao;
    3.     public UserDao getUserDao() {
    4.         return userDao;
    5.     }
    6.     public void setUserDao(UserDao userDao) {
    7.         this.userDao = userDao;
    8.     }
    9.  
    10.     @Override
    11.     public void saveUser() {
    12.         userDao.saveUser();
    13.     }
    14. }

    创建接口UserDao

    1. public interface UserDao {
    2.     void saveUser();
    3. }

    创建类UserDaoImpl实现接口UserDao

    1. public class UserDaoImpl implements UserDao {
    2.  
    3.     @Override
    4.     public void saveUser() {
    5.         System.out.println("保存成功！");
    6.     }
    7. }

    基于注解管理bean

    不用自动装配的情况下进行配置

    1. <bean id="userController" class="personal.september.spring.controller.UserController">
    2.         <property name="userService" ref="userService">property>
    3.     bean>
    4.  
    5.     
    6.     <bean id="userService" class="personal.september.spring.service.impl.UserServiceImpl">
    7.         <property name="userDao" ref="userDao">property>
    8.     bean>
    9.  
    10.     <bean id="userDao" class="personal.september.spring.dao.impl.UserDaoImpl">bean>
    11. beans>

    测试

    自动装配的方式配置bean

    自动装配：根据指定的策略（常用byType，byName），在IOC容器中匹配某个bean，自动为bean中的类类型的属性或接口的属性赋值。（使用bean标签的autowire属性设置自动装配效果。该属性的值有byType、byName、default、no、constructor。default和no的值效果相同，都是不自动装配，即bean中的属性不会自动匹配某个bean为属性赋值，此时睡醒使用默认值）

    自动装配方式：byType
    byType：根据类型匹配IOC容器中的某个兼容类型的bean，为属性自动赋值

    1. <bean id="userController" class="personal.september.spring.controller.UserController" autowire="byType">
    2.         <property name="userService" ref="userService">property>
    3.     bean>
    4.  
    5.     <bean id="userService" class="personal.september.spring.service.impl.UserServiceImpl" autowire="byType">
    6.         <property name="userDao" ref="userDao">property>
    7.     bean>
    8.  
    9.     <bean id="userDao" class="personal.september.spring.dao.impl.UserDaoImpl">bean>
    10. beans>

    使用byType实现自动装配时，IOC容器中有且只有一个类型匹配的bean能够为属性赋值

    自动装配方式：byName
    byName：将自动装配的属性的属性名，作为bean的id在IOC容器中匹配相对应的bean进行赋值（即getid，setid，setter和getter方法后面的就是属性名）

    1. <bean id="userController" class="personal.september.spring.controller.UserController" autowire="byName">bean>
    2.     <bean id="userService" class="personal.september.spring.service.impl.UserServiceImpl" autowire="byName">bean><bean id="service" class="personal.september.spring.service.impl.UserServiceImpl" autowire="byName">bean>
    3.     <bean id="userDao" class="personal.september.spring.dao.impl.UserDaoImpl">bean>
    4.     <bean id="dao" class="personal.september.spring.dao.impl.UserDaoImpl">bean>

    一般使用byType,当类型匹配的bean有多个时，此时可以使用byName实现自动装配。

    （补充：
    若在IOC中，没有任何一个兼容类型的bean能够为属性赋值，则该属性不装配，即值为默认值null。若在IOC中，有多个兼容类型的bean能够为属性赋值，则抛出异常NoUniqueBeanDefinitionException

    基于注解管理bean

    标记与扫描

    ①注解

    和 XML 配置文件一样，注解本身并不能执行，注解本身仅仅只是做一个标记，具体的功能是框架检测到注解标记的位置，然后针对这个位置按照注解标记的功能来执行具体操作。
    本质上：所有一切的操作都是Java代码来完成的，XML和注解只是告诉框架中的Java代码如何执行。

    ②扫描

    Spring 为了知道程序员在哪些地方标记了什么注解，就需要通过扫描的方式，来进行检测。然后根据注解进行后续操作。

    了解基本概念后，新建一个模块来使用注解，如下添加依赖

    1.   <dependencies>
    2.         
    3.         <dependency>
    4.             <groupId>org.springframeworkgroupId>
    5.             <artifactId>spring-contextartifactId>
    6.             <version>5.3.1version>
    7.         dependency>
    8.         
    9.         <dependency>
    10.             <groupId>junitgroupId>
    11.             <artifactId>junitartifactId>
    12.             <version>4.12version>
    13.             <scope>testscope>
    14.         dependency>
    15.     dependencies>

    模块结构如下

    标识组件的常用注解

    1. ⑤标识组件的常用注解
    2. @Component：将类标识为普通组件
    3. @Controller：将类标识为控制层组件
    4. @Service：将类标识为业务层组件 
    5. @Repository：将类标识为持久层组件

    （注解放在类前，且放在接口的实体类上面，不是接口

    1. @Controller
    2. public class UserController {
    3.  
    4. @Service
    5. public class UserServiceImpl implements UserService {
    6.  
    7. @Repository
    8. public class UserDaoImpl implements UserDao {

    注解完要进行扫描

    扫描的方式三种情况

    在spring_ioc_annotation.xml文件中：

    情况一：最基本的扫描方式

    context:component-scan base-package="personal.september.spring">

    情况二：指定要排除的组件

    1. <context:component-scan base-package="personal.september.spring">
    2.         
    3.         
    4.         <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    5.         <context:exclude-filter type="assignable" expression="personal.september.spring.controller.UserController"/>
    6.     context:component-scan>

    情况三：仅扫描指定组件

    1.  <context:component-scan base-package="personal.september.spring" use-default-filters="true">
    2.         
    3.         
    4.         
    5.         
    6.         <context:include-filter type="assignable" expression="personal.september.spring.controller.UserController"/>
    7.     context:component-scan>
    1. <context:component-scan base-package="personal.september.spring">context:component-scan>
    2. 等价于<context:component-scan base-package="personal.september.spring" use-default-filters="true">

    （即如果没有use-default-filters="false"，即使设置了context:include-filter也没有用，还是会全部扫描而不是过滤扫描）

    如图如果设置use-default-filters="false"且只扫描UserController，则如下测试

    1. public void testIOCByAnonotation() {
    2.         ApplicationContext ioc = new ClassPathXmlApplicationContext("spring_ioc_annotation.xml");
    3.         UserController controller = ioc.getBean(UserController.class);
    4.         System.out.println(controller);
    5.         UserService service = ioc.getBean(UserService.class);
    6.         System.out.println(service);
    7.         UserDao dao = ioc.getBean(UserDao.class);
    8.         System.out.println(dao);
    9.     }

    （补充：

    组件所对应的bean的id

    默认情况
    类名首字母小写就是bean的id。（即类的小驼峰）

    例如：UserController类对应的bean的id就userController。
    自定义bean的id


    可通过标识组件的注解的value属性设置自定义的bean的id
    @Service("hello")//默认为userServiceImpl

    public class UserServiceImpl implements  UserService {}

    利用id和类型成功获取bean

    基于注解的自动装配

    利用@Autowired:实现自动装配功能的注释

    该注释能够标识的位置

    1、在成员变量上直接标记@Autowired注解即可完成自动装配，不需要提供setXxx()方法。以后我们在项目中的正式用法就是这样。

    2、标识在set方法上

    3、标识在当前成员变量赋值的有参构造上

    （记得布寺只扫描controller层）

    @Autowired工作流程

    默认通过byType的方式，在IOC容器中通过类型匹配某个bean为属性赋值

    若有多个类型匹配的bean，此时会自动转换为byName方式实现自动装配的效果，即将要赋值的属性的属性名作为bean的id匹配某个bean并为属性赋值。

    若byType和byName的方式都无法实现自动装配，即IOC容器中有多个类型匹配的bean，且这些bean的id和要赋值的属性名不一致（如下），此时抛异常NoUniqueBeanDefinitionException

    1.  "service" class="personal.september.spring.service.impl.UserServiceImpl">
    2.     "dao" class="personal.september.spring.dao.impl.UserDaoImpl">

    解决这个情况，可以添加一个注解@Qualifier，指定bean的id为属性赋值

    指定默认的id（即组件默认标识的bean的id）

    （补充：

    @Autowired中有属性required，默认值为true，因此在自动装配无法找到相应的bean时，会装配失败。可以将属性required的值设置为true，则表示能装就装，装不上就不装，此时自动装配的属性为默认值（如下设置为false后报空指针异常）。

    设置为ture即默认值后的报错如下

    但是实际开发时，基本上所有需要装配组件的地方都是必须装配的，用不上这个属性。

  • 相关阅读:
    shell脚本之sed命令
    数据结构：邻接矩阵与邻接表
    【SA8295P 源码分析】105 - QNX MISC分区读写、切换A/B启动槽、读取开机次数命令 swdl_utils 介绍 及 祼分区读写 代码实现
    双通道PID控制器用于热离子发电器中真空度和温度的同时控制
    一键制作纯文字背景视频，让你轻松制作短视频！
    jvm笔记
    RestCloud ETL解决shell脚本参数化
    公司 CTO：高性能开发，你不会 Netty，怎么好意思拿 20K？
    计算机语言知识点梳理
    分布式事务----seata
  • 原文地址：https://blog.csdn.net/weixin_66196728/article/details/132938853