参考bilibili尚硅谷-Spring5框架最新版教程（idea版）学习总结

1.IOC容器

IOC（概念和原理）

控制反转，把对象创建爱你和对象之间的调用过程，交给Spring进行管理
使用IOC目的：为了耦合度降低
做的入门案例就是IOC实现

1. IOC底层原理

xml解析、工厂模式、反射
- 使用工厂模式可以降低耦合度
- 通过xml+反射+工厂模式可以将耦合度降低最低限制

IOC过程

第一步：xml配置文件，配置创建的对象

<bean id = "dao" class="com.atguigu.UserDao"></bean>
id为创建后对象的名字
class为对象的路径

第二步：有service类和dao类，创建工程类

class UserFactory{
    public static UserDao getDao(){
        String classValue = xml对象的class属性值;//1.xml解析
    	Class clazz = Class.forName(classValue);//2. 通过反射创建对象
        return(UserDao)clazz.newInstance();
        
    }
}

通过这2步，如果对象的xml路径发生变化，只要修改class值即可；

如果仅仅使用工厂模式，需要修改xml对象的路径和工程模式类的路径

2. IOC接口（beanfactory、ApplicationContext）

IOC思想基于IOC容器完成，IOC容器底层就是对象工厂
Spring提供IOC容器实现两种方式：（两个接口）
1. beanfactory接口：IOC容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用
  1. 加载配置文件的时候不会创建对象，只有当获取（使用）的时候才会开始创建
2. ApplicationContext接口：beanfactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用
  1. 加配置文件的时候就会把配置文件对象进行创建
  2. 考虑到在Web上使用，像这种耗时、耗资源的操作都在项目启动的时候进行处理更合适。所以一般使用这种方式
ApplicationContext接口实现类
1. FileSystemXmlApplicationContext
  1. 需要写的内容为绝对路径
2. ClasspathXmlApplicationContext
  1. 需要写的内容为编译后的类路径

2.IOC操作Bean管理（基于xml）

什么是Bean管理

Bean管理指的是两个操作

Spring创建对象
Spring注入属性

Bean管理操作有两种方式

基于xml配置文件方式实现
基于注解方式实现

1. IOC操作Bean管理（基于xml）

在Spring的配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建
在bean标签里面有很多属性，介绍常见属性
- id：唯一标识
- class：类全路径（包类路径）
- name(了解)：和id类似，但是可以加特殊符号，比如 /
创建对象时候，默认也是执行无参数构造方法完成对象创建（重点）
- 即必须要有无参构造方法

2. IOC操作Bean管理（基于注解）

IOC和DI的区别

DI是IOC中的一种具体实现，表示依赖注入（注入属性），注入属性需要在创建对象的基础上完成

DI：依赖注入，就是注入属性

使用set方式注入

package com.atguigu.Spring5;

/**
 * 演示使用set方式进行注入属性
 */
public class Book {

    private String bname;
    private String bauthor;

    public void setBname(String bname) {
        this.bname = bname;
    }

    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }

    @Override
    public String toString() {
        return "Book{" +
                "bname='" + bname + '\'' +
                ", bauthor='" + bauthor + '\'' +
                '}';
    }

}

必须要有set方法,设置好set方法后去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">

    <!--配置User对象创建-->
<!--    <bean id="user" class="com.atguigu.Spring5.User"></bean>-->

    <!--使用property完成属性注入-->
    <!--name:类里面属性名称
        value:向属性注入的值
        -->
    <bean id="book" class="com.atguigu.Spring5.Book">
        <property name="bname" value="易筋经"></property>
        <property name="bauthor" value="达摩老祖"></property>
    </bean>
</beans>

这样就可以通过set方法完成属性注入
注意是在bean标签内部嵌入property标签，设置好name、value属性值

有参数构造(方法)注入

package com.atguigu.Spring5;

public class Orders {

    private String oname;
    private String address;

    /**
     * 创建有参数的构造
     * @param oname
     * @param address
     */
    public Orders(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }
}

<?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">

    <!--配置User对象创建-->
<!--    <bean id="user" class="com.atguigu.Spring5.User"></bean>-->

    <!--使用property完成属性注入-->
    <!--name:类里面属性名称
        value:向属性注入的值
        -->
<!--    <bean id="book" class="com.atguigu.Spring5.Book">-->
<!--        <property name="bname" value="易筋经"></property>-->
<!--        <property name="bauthor" value="达摩老祖"></property>-->
<!--    </bean>-->


    <bean id="orders" class="com.atguigu.Spring5.Orders">
        <constructor-arg name="oname" value="abc"></constructor-arg>
        <constructor-arg name="address" value="China"></constructor-arg>
    </bean>
</beans>

此外还可以通过constructor-arg标签的index来注入属性，只不过index是通过有参构造的下标，
- 从0开始，index=0表示第一个有参构造的值，后面跟的value不变
- 不推荐使用，可读性差

3. p名称空间注入(了解)

使用p名称空间注入，可以简化基于xml配置方式

添加p名称空间在配置文件中

添加
xmlns:p="http://www.springframework.org/sch
ema/p"

其中xmlns已经存在，需要起别名，为了可读性选择在后面加:p，
值的部分：将xmlns的值复制下来，将最后的一个路径beans改为p即可

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--配置User对象创建-->
<!--    <bean id="user" class="com.atguigu.Spring5.User"></bean>-->

    <!--使用property完成属性注入-->
    <!--name:类里面属性名称
        value:向属性注入的值
        -->
<!--    <bean id="book" class="com.atguigu.Spring5.Book">-->
<!--        <property name="bname" value="易筋经"></property>-->
<!--        <property name="bauthor" value="达摩老祖"></property>-->
<!--    </bean>-->


<!--    <bean id="orders" class="com.atguigu.Spring5.Orders">-->
<!--        <constructor-arg name="oname" value="abc"></constructor-arg>-->
<!--        <constructor-arg name="address" value="China"></constructor-arg>-->
<!--    </bean>-->


        <bean id="book" class="com.atguigu.Spring5.Book" p:bname="九阳神功" p:bauthor="无名氏">
        </bean>
</beans>

可以看出，比set方式少了内部的property标签

4. IOC操作Bean管理(xml注入其他类型属性)

null值

通过在POJO类配置属性和对应的set方法后，在xml配置文件中保留name属性，并将value属性删除，在内部嵌入null标签即可


    <bean id="book" class="com.atguigu.Spring5.Book">
        <property name="bname" value="易筋经"></property>
        <property name="bauthor" value="达摩老祖"></property>
        <--下面这部分就是赋值null值-->
        <property name="address">
            <null></null>
        </property>
    </bean>

包含特殊符号

如果需要设置的属性值中包含特殊符号，可以对有以下几种方式

对特殊符号进行转译，比如<>:&lt &gt
把特殊符号的内容写到CDATA中
1. 此外还需要注意在value中的空格也会成为String类型被编译进去，也就是说在value标签后，如果换行了，在输出的时候也会进行换行操作，没有特殊情况请将value标签写在同一行，并保证无空格
2. 格式：<![CDATA[具体内容]]>

<property name="address">
            <!-- 给value赋值<<南京>> 如果直接使用正常的方式会被识别成标签，无法通过编译 -->
            <value><![CDATA[<<南京>>]]></value>
        </property>

注入外部bean

创建2个类service、dao
在service调用dao里面的方法
在spring配置文件中进行配置

package com.atguigu.Spring5.service;

import com.atguigu.Spring5.dao.UserDao;

public class UserService {

    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }


    public void add(){
        System.out.println("service add............");
        userDao.update();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

   <!-- service 和 dao 对象创建 -->
    <bean id="userService" class="com.atguigu.Spring5.service.UserService">
        <!-- 注入UserDao对象
            name属性  类里面属性名称
            ref属性   创建userDao对象bean标签ID值
            -->
        <property name="userDao" ref="userDaoImpl"></property>
    </bean>

    <!-- ps：这里id值和上面的ref值保持一致 -->
    <bean id="userDaoImpl" class="com.atguigu.Spring5.dao.UserDaoImpl"></bean>


</beans>

注入内部bean

package com.atguigu.Spring5.bean;

//员工类

public class Emp {

    private String ename;
    private String gender;

    private Dept dept;

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
}


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 内部bean -->
    <bean id="emp" class="com.atguigu.Spring5.bean.Emp">

        <!-- 先设置两个普通属性 -->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="女"></property>
        <!-- 设置对象类型属性 -->
        <property name="dept">
            <bean id="dept" class="com.atguigu.Spring5.bean.Dept">
                <property name="dname" value="安保部"></property>
            </bean>
        </property>
    </bean>


</beans>

在bean的内部创建property标签的内部再次嵌入一个bean，这就是内部bean

级联赋值

方法1

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 级联赋值 -->
    <bean id="emp" class="com.atguigu.Spring5.bean.Emp">

        <!-- 先设置两个普通属性 -->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="女"></property>
        <!-- 级联赋值 -->
        <property name="dept" ref="dept"></property>
    </bean>

    <bean id="dept" class="com.atguigu.Spring5.bean.Dept">
        <property name="dname" value="财务部"></property>
    </bean>

</beans>

！！！注意级联赋值方法1和外部bean的区别

级联赋值和外部bean存在一定差异

注入外部bean是在外部创建一个bean后在注入另一个bean的内部
级联赋值喝注入外部bean的区别在于
- 在外部bean中可以设置属性
- 引入外部bean的同时，属性值也会覆盖
- 也可以理解成内部bean的property标签在在外的bean中定义属性值后，通过外部bean的方式注入

方法2

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 级联赋值 -->
    <bean id="emp" class="com.atguigu.Spring5.bean.Emp">

        <!-- 先设置两个普通属性 -->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="女"></property>
        <!-- 级联赋值 方法1 -->
        <property name="dept" ref="dept"></property >
        <!--级联赋值 方法2
        这里name的意义是为dept对象中的dname属性赋值 “技术部”
        但是需要获得其中的dname值就需要有get方法，所以需要在emp中为dept对象添加get方法
        -->
        <property name="dept.dname" value="技术部"></property>
    </bean>

    <!-- 级联赋值 方法1 -->
    <bean id="dept" class="com.atguigu.Spring5.bean.Dept">
        <property name="dname" value="财务部"></property>
    </bean>

</beans>

集合类型属性注入

数组、list、map、set

package com.atguigu.Spring5.collectiontype;

import java.util.List;
import java.util.Map;
import java.util.Set;

public class Stu {
    // 1. 数组类型属性
    private String courses;

    // 2. list类型属性
    private List<String> list;

    // 3. Map类型属性
    private Map<String,String> maps;

    // 4. set类型属性
    private Set<String> sets;

    public void setSet(Set<String> sets) {
        this.sets = sets;
    }

    public void setMap(Map<String, String> maps) {
        this.maps = maps;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setCourses(String courses) {
        this.courses = courses;
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 集合类型属性注入 -->
    <bean id="stu" class="com.atguigu.Spring5.collectiontype.Stu">
        <!-- 数组类型属性注入 -->
        <property name="courses">
            <array>
                <value>java课程</value>
                <value>数据库课程</value>
            </array>
        </property>

        <!-- list类型属性注入 -->
        <property name="list">
            <list>
                <value>张三</value>
                <value>小三</value>
            </list>
        </property>

        <!-- map类型属性注入 -->
        <property name="map">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="PHP" value="PHP"></entry>
            </map>
        </property>

        <!-- set类型属性注入 -->
        <property name="set">
            <set>
                <value>MysqL</value>
                <value>Redis</value>
            </set>
        </property>
    </bean>

</beans>

测试

@Test
public void testCollection(){
    ApplicationContext context = new ClasspathXmlApplicationContext("bean1.xml");

    Stu stu = context.getBean("stu", Stu.class);

    stu.test();

}

list集合中注入对象

 <!-- 注入list集合类型，值是对象 -->
    <property name="coursList">
        <list>
            <ref bean="course1"></ref>
            <ref bean="course2"></ref>
        </list>
    </property>

</bean>

<!--创建多个course对象-->
<bean id="course1" class="com.atguigu.Spring5.collectiontype.Cours">
    <property name="cname" value="Spring5框架"></property>
</bean>

<!--创建多个course对象-->
<bean id="course2" class="com.atguigu.Spring5.collectiontype.Cours">
    <property name="cname" value="MyBatis框架"></property>
</bean>

通过级联赋值的方式创建多个bean对象，在通过list中的ref标签选择对应bean对象的id值，完成赋值
在测试的Stu类的test方法中添加输出语句，运行测试类即可看到效果，为了更容易看到效果，可以在Cours类中添加toString方法

将集合抽取出来，作为公共部分

在Spring的配置文件中声明后才能空间util

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

 <!-- 集合类型属性注入 -->
    <util:list id="booklist">

        <value>易经经</value>
        <value>九阴真经</value>
        <value>九阳神功</value>

    </util:list>

    <!-- 提取list集合类型属性注入使用 -->

    <bean id="book" class="com.atguigu.Spring5.collectiontype.Book">
        <property name="list" ref="booklist"></property>
    </bean>
</beans>

xmlns:util可以复制上一行代码，需要更改2个p为util
xsi:schemaLocation：可以复制上一行代码，需要更改3个beans为util

测试

@Test
public void testCollection2(){
    ApplicationContext context = new ClasspathXmlApplicationContext("bean2.xml");

    Book book = context.getBean("book", Book.class);

    book.test();


}

factorybean（工厂Bean）

Spring有两种类型bean，一种普通bean，另外一种工厂bean（factorybean）
普通bean：配置文件中定义bean类型就是返回类型
- 例如上面的代码，在xml配置文件中定义的为Book类的bean（Class路径为Book类）
- 在测试文件中通过Book.class返回Book类进行测试
工厂bean：在配置文件中定义bean类型可以和返回类型不一样
1. 创建类，让这个类作为工厂bean，实现接口factorybean
2. 实现接口里面的方法，在实现的方法中定义返回的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"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

    <bean id="myBean" class="com.atguigu.Spring5.factorybean.MyBean"></bean>
</beans>

package com.atguigu.Spring5.factorybean;

import com.atguigu.Spring5.collectiontype.Cours;
import org.springframework.beans.factory.factorybean;

public class MyBean implements factorybean<Cours> {

    //getobejct方法可以定义返回bean类型
    //这里定义了返回的类型为Cours对象，而不是myBean对象
    @Override
    public Cours getobject() throws Exception {

        Cours cours = new Cours();
        cours.setCname("测试");
        return cours;
    }

    @Override
    public Class<?> getobjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
}

@Test
public void testCollection3(){
    ApplicationContext context = new ClasspathXmlApplicationContext("bean3.xml");

    Cours cours = context.getBean("myBean", Cours.class);

    System.out.println(cours);

}

在测试的时候就需要用Cours类进行反射得到Cours对象，因为用的是bean3.xml的配置，使用的为myBean字符串作为id标识

bean的作用域

在Spring中，设置创建bean实例是单实例还是多实例

在Spring默认情况下，bean是单实例

    @Test
    public void testCollection2(){
        ApplicationContext context = new ClasspathXmlApplicationContext("bean2.xml");

        Book book1 = context.getBean("book", Book.class);
        Book book2 = context.getBean("book", Book.class);

        System.out.println(book1);
        System.out.println(book2);
    }

可以根据创建2个对象后输出地址值进行比较，结果地址值是一样的

如何设置单实例还是多实例

在Spring配置文件中bean标签里有属性（scope）用于设置单实例还是多实例
scope属性
1. 第一个值默认值 singleton，表示是单实例对象
2. 第二个值 prototype ，表示是多实例对象

<bean id="book" class="com.atguigu.Spring5.collectiontype.Book" scope="prototype">
    <property name="list" ref="booklist"></property>
</bean>

在对应xml配置文件中配置完成多实例的scope属性后，回到测试类进行测试，这时候能看到地址值不一样

singleton 和 prototype的区别

singleton是单实例，prototype是多实例
设置scope属性是singleton时候，加载spring配置文件时候就会创建单例实例对象；
设置scope属性是prototype时候，加载spring配置文件的时候不会创建实例对象，而是在调用getBean方法时候创建多实例对象

bean的生命周期

生命周期：从对象创建到对象销毁的过程

bean的一般生命周期，bean生命周期有五步

通过构造器创建bean实例（无参数构造）
为bean的属性设置值和其他bean引用（调用set方法）
调用bean的初始化方法（需要进行配置初始化的方法）
bean可以使用了（对象获取到了）
当容器关闭时候，调用bean的销毁的方法（需要进行配置销毁的方法）

演示bean生命周期

配置文件
- init-method为初始化的方法，需要自行添加
- destroy为销毁的方法，需要自行添加，在自行手动关闭

<bean id="orders" class="com.atguigu.Spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
    <property name="oname" value="手机"></property>
</bean>

第1、2、3、5步的方法，初始化方法和销毁方法在这设置

package com.atguigu.Spring5.bean;

public class Orders {

    private String oname;

    public Orders() {
        System.out.println("第一步 执行无参构造方法创建bean实例");
    }

    public void setoname(String oname) {
        this.oname = oname;
        System.out.println("第二部 调用set方法设置属性值");
    }


    //创建执行的初始化的方法
    public void  initMethod(){
        System.out.println("第三步 执行初始化的方法");
    }

    //创建销毁的方法
    public void  destroyMethod(){
        System.out.println("第五步 执行销毁的方法");
    }
}

测试类和第四步
- 需要注意，如果使用ApplicationContext类创建的实例，销毁的时候会调用他的子类的close（）方法，
- 如果使用ClasspathXmlApplicationContext类创建的实例，可以直接调用close（）方法。
- 运行测试类即可看到效果

@Test
    public void testBean1(){
//        ApplicationContext context = new ClasspathXmlApplicationContext("bean4.xml");
        ClasspathXmlApplicationContext context = new ClasspathXmlApplicationContext("bean4.xml");

        Orders orders = context.getBean("orders", Orders.class);

        System.out.println("第四步 获取创建bean实例对象");
        System.out.println(orders);

        //手动让bean实例销毁
        context.close();
        
//        //使用ApplicationContext类需要强转，因为这个类中没有close方法，方法在他的子类中。
//        ((ClasspathXmlApplicationContext)context).close();

bean的后置处理器，bean生命周期有七步

通过构造器创建bean实例（无参数构造）
为bean的属性设置值和其他bean引用（调用set方法）
把bean实例传递bean后置处理器的postProcessBeforeInitialization（）方法
调用bean的初始化方法（需要进行配置初始化的方法）
把bean实例传递bean后置处理器的postProcessAfterInitialization（）方法
bean可以使用了（对象获取到了）
当容器关闭时候，调用bean的销毁的方法（需要进行配置销毁的方法）

演示添加后置处理器效果

创建类，实现接口BeanPostProcessor，创建后置处理器

package com.atguigu.Spring5.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.lang.Nullable;

public class MyBeanPost implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之后执行的方法");
        return bean;
    }

}

在配置文件中配置后置处理器bean
- 在配置文件中配置的后置处理器会适用于当前xml配置文件的所有bean
- 即如果有一个bean的id为book，同样也会为book的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"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

    <bean id="orders" class="com.atguigu.Spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="oname" value="手机"></property>
    </bean>

    <!-- 配置后置处理器 -->
    <bean id="myBeanPost" class="com.atguigu.Spring5.bean.MyBeanPost"></bean>
</beans>

xml自动装配

什么是自动装配
1. 根据指定装配规则(属性名称或者属性类型),Spring自动将匹配属性值进行注入
演示自动装配过程
- 根据byName进行配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

    <!--实现自动装备
        bean标签属性autowire，配置自动装配
        autowire属性常用两个值：
            byName根据属性名称注入，注入值bean的id值和 类属性名称一样
            byType根据属性类型注入
    -->
    <bean id="emp" class="com.atguigu.Spring5.autowire.Emp" autowire="byName">
        <!--<property name="dept" ref="dept"></property>-->
    </bean>

    <bean id="dept" class="com.atguigu.Spring5.autowire.Dept"></bean>
</beans>

根据byType进行配置

  <?xml version="1.0" encoding="UTF-8"?>
  <beans xmlns="http://www.springframework.org/schema/beans"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:p="http://www.springframework.org/schema/p"
         xmlns:util="http://www.springframework.org/schema/util"
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                             http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
  
      <!--实现自动装备
          bean标签属性autowire，配置自动装配
          autowire属性常用两个值：
              byName根据属性名称注入，注入值bean的id值和 类属性名称一样
              byType根据属性类型注入
      -->
      <bean id="emp" class="com.atguigu.Spring5.autowire.Emp" autowire="byType">
          <!--<property name="dept" ref="dept"></property>-->
      </bean>
  
      <bean id="dept" class="com.atguigu.Spring5.autowire.Dept"></bean>
  </beans>

两种方法的结果一样
注意:如果根据ByType进行注入,不能配置两个相同的bean,不然会报错

IOC操作Bean管理（外部属性 文件）

直接配置数据库信息

配置德鲁伊连接池

引入德鲁伊连接池依赖jar包

maven

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>
  <version>1.1.19</version>
</dependency>

引入外部属性文件配置数据库连接池

引入druid依赖

创建配置文件

prop.driverClass=com.MysqL.jdbc.Driver
prop.url=jdbc:MysqL://localhost:3306/userDb
prop.userName=root
prop.password=123456

在Spring配置文件中引入Context名称空间

配置连接池，value值根据配置文件的key动态获取

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--直接配置连接池-->
<!--   <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">-->
<!--       <property name="driverClassName" value="com.MysqL.jdbc.Driver"></property>-->
<!--       <property name="url" value="jdbc:MysqL://localhost:3306/userDb"></property>-->
<!--       <property name="username" value="root"></property>-->
<!--       <property name="password" value="123456"></property>-->
<!--   </bean>-->

    <!-- 引入外部属性文件 -->
    <context:property-placeholder location="classpath:jdbc.properties" />

    <!--配置连接池-->
       <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
           <property name="driverClassName" value="${driverClass}"></property>
           <property name="url" value="${prop.url}"></property>
           <property name="username" value="${prop.userName}"></property>
           <property name="password" value="${prop.password}"></property>
       </bean>

</beans>

3.IOC操作Bean管理（基于注解方式）

什么是注解？

注解是代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值…）
使用注解，注解作用在类上面，方法上面，属性上面
使用注解的目的：简化xml配置

Spring 针对Bean 管理中创建对象提供注解

@Component
@Service
@Controller
@Repository

上面四个注解功能是一样的，都可以用来创建bean实例，并没有严格分层
固定注解使用在某一层：主要目的是为了让代码更容易看懂

基于注解方式实现对象创建

1. 引入依赖（maven引入Spring5的5.2.6版本的时候已经引入完成，引入的为aop的jar包）

2. 开启组件扫描

引入名称空间context
如果扫描多个包，多个包使用逗号隔开
扫描包上层目录

<!-- 开启组件扫描 -->
<context:component-scan base-package="com.atguigu.Spring5"></context:component-scan>

3. 创建类，在类上面添加创建对象注解

package com.atguigu.Spring5.service;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

//在注解里面value属性值可以省略不写，
//默认值是类名称，首字母小结
//UserService -- userService
//即单纯只写 @Component 和 @Component(value = "userService")效果一样
//@Component(value = "userService") //<bean id = "userService" class="..">
@Service
public class UserService {

    public void add(){
        System.out.println("Service.........add");
    }
}

package com.atguigu.Spring5.testdemo;

import com.atguigu.Spring5.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClasspathXmlApplicationContext;

public class TestSpring5Demo1 {

    @Test
    public void  teseService(){
        ApplicationContext context = new ClasspathXmlApplicationContext("bean1.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}

4. 开启组件扫描细节配置

<!-- 开启组件扫描 -->
<context:component-scan base-package="com.atguigu.Spring5"></context:component-scan>


<!-- 实例1
    use-default-filters="false"     表示现在不适用默认filter，自己配置filter
    context:include-filter，设置扫描那些内容
-->
<context:component-scan base-package="com.atguigu" use-default-filters="false">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/>

</context:component-scan>


<!-- 实例2
    下面配置扫描包所有内容
    context:exclude-filter：     设置那些内容不进行扫描
-->
<context:component-scan base-package="com.atguigu" >
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

5. 基于注解方式实现属性注入

@AutoWired

根据属性类型进行自动装配（注入）

把service和dao对象创建，在service和dao类添加创建对象注解
在service注入dao对象，在service类添加dao类型属性，在属性上面使用注解

@Service
public class UserService {

    //定义dao类型属性
    //不需要添加set方法
    //添加注入属性解
    @Autowired 
    private UserDao userDao;

    public void add(){
        System.out.println("Service.........add");
    }
}

@Qualifier

根据属性名称进行注入

    //定义dao类型属性
    //不需要添加set方法
    //添加注入属性解
    @Autowired //根据类型进行注入
	//@Qualifier需要配合@Autowired使用
    @Qualifier(value = "userDaoImpl")
    private UserDao userDao;

@Resources
- 可以根据类型注入，也可以根据名称注入
```
//    @Resource //根据类型进行注入
    @Resource(name="userDao")//根据名称进行注入
    private UserDao userDao;
```
- 需要注意的是@Resources注解是javax包，即java扩展包的内容
- @AutoWired和@Qualifier注解都是org包的
- 更推荐使用org包的注解

@Value

注入普通类型属性

//@Value 注入普通类型属性
@Value(value = "abc")
private String name;

6.完全注解开发

创建配置类，替代xml配置文件

package com.atguigu.Spring5.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration //作为配置类，替代xml配置文件
@ComponentScan(basePackages={"com.atguigu"})
public class SpringConfig {


}

编写测试方法

@Test
public void  teseService2(){
    //加载配置类发生了变化
    // ApplicationContext context = new ClasspathXmlApplicationContext("bean1.xml");
    // ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
    ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
    UserService userService = context.getBean("userService", UserService.class);
    userService.add();
}

Spring5-IOC容器笔记