Spring5框架一：IOC实现的两种方式和底层原理

1、概念（先了解，原理后面再写）

1、spring是一个轻量级的开源的JavaEE框架（引入jar包的数量以及体积都比较小）
2、spring框架可以解决企业应用开发的复杂性
3、spring里面有很多组成部分，IOC和AOP两个核心部分
①IOC：Inversion of Control控制反转，把创建对象的过程交给spring管理，不需要手动new对象
②AOP：Aspect Oriented Programming面向切面编程，再不修改源代码的情况下给功能进行添加，对功能进行增强
4、spring框架的特点
①方便解耦，简化开发
②支持AOP编程，不改变源代码给项目加功能
③junit方便程序测试
④方便和其他框架进行整合
⑤方便进行事务操作
⑥降低API开发难度，对很多多西提供了封装如jdbc

2、入门案例

导入jar包，只需要导入基本jar包

导入4个基本的核心包以及一个log包


创建一个普通的类，在这个类中创建一个普通方法，创建Spring配置文件，在配置文件中配置要创建的对象
①spring的配置文件时xml文件，clas为包的全限定名称

<?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.wchao.User"/>
</beans>

public class TestSpring5 {
    @Test
    public void testAdd(){
        // 1.加载spring配置文件 ,当配置文件和src在同一级目录之下时就使用这个可以
        ApplicationContext context=new ClassPathXmlApplicationContext("bean01.xml");
        // 当配置文件和src不在同一级目录之下就用这个
        ApplicationContext context1=new FileSystemXmlApplicationContext("bean01.xml");
        // 2.获取配置创建的对象
        User user = context.getBean("user", User.class);
        // User user = context1.getBean("user", User.class);
        System.out.println(user);
        user.add();
    }
}

3、IOC容器

什么是IOC：其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），把对象的创建以及对象之间的调用过程，交给spring进行管理
使用ioc的目的，为了降低耦合度

3.1 IOC底层原理

底层原理：xml解析、工厂模式、反射

3.2 IOC接口(BeanFactory)

ioc思想基于ioc容器完成，ioc容器底层就是对象工厂，spring提供了ioc容器实现的两种方式，两个接口BeanFactory和ApplicationContext
BeanFactory：ioc容器基本的实现方式，一般开发中不使用spring内部使用的接口，一般不提供开发人员使用
特点是加载配置文件的时候不会创建对象，在获取对象，使用对象的时候才会去加载对象
ApplicationContext：BeanFactory的子接口，提供了更多更强大的功能，一般是面向开发人员使用的
在加载配置文件的时候，就会把在配置文件中的对象进行创建

3.3 IOC操作Bean管理（基于xml）

Bean管理：2个操作，第一由spring创建对象，第二由spring注入属性
Bean管理操作有两种方式，1.xml配置文件方式实现，2基于注解方式实现
①基于xml方式创建对象
在spring的配置文件中使用bean标签，标签里面添加对应的属性，在bean标签有很多属性，id：给对象起个别名，唯一标识，通过getBean可以找到他，class：出创建对象所在的全路径（包类路径），name跟id属性一样，id不能加特殊符号name可以加比如/，创建对象的时候，默认是无参构造的
②基于xml方式注入属性
DI：依赖注入，注入属性，DI是ioc中的一种具体实现，需要在创建对象的基础之上完成，
第一种注入方式使用set方式进行注入（创建一个类，里面定义属性和对应的set方法，第二步在spring配置文件中，先配置对象创建，在配置属性注入），第二种注入方式使用有参构造注入（创建一个类，定义属性，创建属性对应的有参构造方法，在spring额配置文件中进行配置）,底层用的set方法

<?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">
    <!-- 1. bean配置User对象创建-->
    <bean id="user" class="com.wchao.User"/>
    <!-- 2. set方法注入属性-->
    <bean id="book" class="com.wchao.BookInjection">
        <!-- 在bean标签里面使用property完成属性注入
            name:类里面的属性名称
            value:向属性里面注入的值-->
        <property name="bname" value="易筋经"/>
        <property name="bauthor" value="达摩老祖"/>
    </bean>
    <!-- 3. 有参构造注入属性-->
    <bean id="order" class="com.wchao.Order">
        <!-- 在bean标签里面使用constructor-arg完成属性注入
            name:类里面的属性名称
            index:有参构造的形参位置
            value:向属性里面注入的值
        -->
        <constructor-arg name="oname" value="abc"/>
        <constructor-arg index="1" value="China"/>
    </bean>
    <!-- 4. 使用p名称空间注入，可以简化基于xml配置方式
            ① 添加p名称空间在配置文件中
            ② 进行属性的注入,在bean里面进行操作，目的就是为了简化操作
    -->
    <bean id="book1" class="com.wchao.BookInjection" p:bname="九阳神功" p:bauthor="无名"/>
</beans>

IOC容器-Bean管理XML方式(注入空值和特殊符号)
字面量：属性的估计值，设置值的时候可以设置null值，当属性值包含特殊符号

 <!-- 设置null属性:如下所示就表示向属性中设置一个null-->
<!--        <property name="address" >-->
<!--            <null/>-->
<!--        </property>-->
        <!-- 属性值中有特殊符号 <> 就会报错
            1. 可以使用转义解决 &lt; &gt;
            2. 把带特殊符号的内容写道CDATA中去
        -->
        <property name="address" >
            <value><![CDATA[<<南京>>]]>
            </value>
        </property>
    </bean>

注入属性
外部bean：1创建两个类service和dao类2在service中调用dao里面的方法3在spring的配置文件中配置ref
bean.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">
    <!-- 先把service和dao对象进行创建-->
    <bean id="userService" class="service.UserService">
        <!-- 在userService中注入userDao对象
            name属性值：类里面的属性名称
            ref：代表你想引入的值，在bean中注入的对象值
        -->
        <property name="userDao" ref="userDaoImpl"/>
    </bean>
    <bean id="userDaoImpl" class="dao.UserDaoImpl"/>
</beans>

service层

public class UserService {

    // 1. 创建UserDao类型的属性，生成set方法
    private UserDao userDao;

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

    public void add(){
        System.out.println("service add...");
//        userDao.update();
        // 先创建UserDao对象 原始方式
//         UserDao userDao=new UserDaoImpl();
         userDao.update();
    }
}

内部bean和级联赋值
①一对多关系：部门和员工，一个部门有多个员工，一个员工属于一个部门
部门是一，员工是多
②在实体类之间表示一对多关系，员工表示所属的部门，使用对象类型属性进行表示
③在spring的配置文件进行配置
内部bean的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">
        <!-- 内部bean的操作-->
    <bean id="emp" class="com.bean.Emp">
        <!-- 先设置两个普通的属性-->
        <property name="ename" value="lucy"/>
        <property name="gender" value="female"/>
        <!-- 设置对象类型属性 这个就叫做内部bean，也可以通过ref外部bean-->
        <property name="dept">
            <bean class="com.bean.Dept">
                <property name="dname" value="安保部"/>
            </bean>
        </property>
    </bean>
</beans>

员工类

package com.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;
    }
    public void add(){
        System.out.println(ename+""+gender+""+dept);
    }
}

注入属性-级联赋值
第一种写法

<?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">
    <!-- 级联赋值-->
    <bean id="emp" class="com.bean.Emp">
        <!-- 先设置两个普通的属性-->
        <property name="ename" value="lucy"/>
        <property name="gender" value="female"/>
        <!--级联赋值 跟注入外部bean差不多，只不过加了属性-->
        <property name="dept" ref="dept"/>
    </bean>
    <bean id="dept" class="com.bean.Dept">
        <property name="dname" value="财务部"/>
    </bean>
</beans>

第二种写法get通过对象.属性取出一定要有get方法

<?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">
    <!-- 级联赋值-->
    <bean id="emp" class="com.bean.Emp">
        <!-- 先设置两个普通的属性-->
        <property name="ename" value="lucy"/>
        <property name="gender" value="female"/>
        <!--级联赋值 这种方法选哟有对应的dept的get方法-->
        <property name="dept.dname" value="技术部"/>
    </bean>
    <bean id="dept" class="com.bean.Dept"/>
</beans>

XML注入集合属性
1.注入数组类型属性
2.注入List集合类型属性
3.注入Map集合类型属性
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"
       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">
    <!-- 1. bean配置User对象创建-->
    <bean id="student" class="byue.collectionType.Student">
        <!-- 数组类型的属性注入用array标签或者list标签都可以-->
        <property name="courses">
            <array>
                <value>java课程</value>
                <value>mysql课程</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>张三</value>
                <value>李四</value>
            </list>
        </property>
        <property name="map">
            <map>
                <entry key="JAVA" value="java"/>
                <entry key="PYTHON" value="python"/>
            </map>
        </property>
        <property name="set">
            <set>
                <value>mysql</value>
                <value>redis</value>
            </set>
        </property>
    </bean>
</beans>

Student类

package byue.collectionType;

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

public class Student {
    // 数组类型属性
    private String[] courses;
    // list集合类型属性
    private List<String> list;
    // Map集合类型属性
    private Map<String,String> map;
    // set集合类型属性
    private Set<String> set;

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

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

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

    public void setCourses(String[] courses) {
        this.courses = courses;
    }
    public void test(){
        System.out.println(Arrays.toString(courses));
        System.out.println(list);
        System.out.println(map);
        System.out.println(set);
    }
}

在Spring里面有两种类型的bean，一种是自己创建的普通bean，还有一种就是工厂bean，FactoryBean
普通bean：在spring的xml配置文件中定义什么类型返回的就是什么类型

FactroyBean：在配置文件中定义bean类型可以和返回类型不一样
第一步：创建一个类，让这个类作为工厂bean，实现接口FactoryBean
第二步：实现接口里面的方法，在实现的方法中定义返回的bean类型
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"
       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="byue.factoryBean.MyBean"></bean>
</beans>

FactoryBean

package byue.factoryBean;


import byue.collectionType.Course;
import org.springframework.beans.factory.FactoryBean;

public class MyBean implements FactoryBean<Course> {

    // 定义返回的bean
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("adc");
        return course;
    }

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

    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}

bean的作用域：在spring里面，设置bean实例是单实例还是多实例
在spring里面，默认情况下，bean是单实例对象

如何设置bean是单实例还是多实例对象，bean标签有scope属性值
第一个 默认值 singleton，表示单实例对象
第二个 prototype，表示多实例对象

singleton和prototype的区别
第一：singleton表示单实例，prototype表示多实例
第二：设置scope的值是singleton的时候，不设置默认就是他，加载Spring配置文件的时候就会创建单实例对象，设置prototype的时候，不是在加载spring配置文件的时候创建对象，是在调用getBean的时候创建多实例对象

3.3.1Bean的声明周期

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

3.3.2添加后置处理器（七状态模型）

完整的操作其实还有2步叫做bean的后置处理器：bean初始化之前和之后分别调用的方法，总共7步
①创建Bean实例，通过构造器创建bean实例（无参构造）
②为bean里面的属性设置值和对其他bean的引用（调用set方法）
后置处理器：把bean的实例传递给bean的后置处理器执行postProcessBeforeInitialization这个方法
③调用bean的初始化方法（需要进行配置初始化的方法 ）
后置处理器：把bean的实例传递给bean的后置处理器执行postProcessAfterInitialization这个方法
④bean可以使用了（对象获取到了）
⑤当容器关闭的时候，调用bean的销毁的方法（需要进行配置销毁的方法）
（1）创建类，实现接口BeanPostProcessor，创建后置处理器
（2）在xml文件中配置bean实例，他会对所有的bean实例都进行装配

3.4 Bean管理xml方式（自动装配）

手动装配：自己在xml文件中给bean实例实例化，以及给实例的属性赋值
自动装配：根据指定装配规则（属性名称或者属性类型），Spring自动讲匹配的属性值进行注入
自动装配的过程

3.5 Bean管理xml方式（外部属性文件）

xml文件引入properties文件中的固定属性进行使用，以数据库配置为例
1、直接配置数据库信息
①配置德鲁伊连接池
②引入德鲁伊连接池依赖jar包
③手动进行配置连接信息
2、引入外部属性文件配置数据库连接池
①创建外部属性文件，properties格式文件，数据库信息
②把外部properties属性文件引入到spring配置文件中
第一步引入context名称空间
第二步在spring配置文件中使用标签引入外部属性文件

4、基于注解实现创建对象以及属性

注解：是代码的特殊标记@注解名称(属性名=属性值，…)，注解可以作用在类、方法、属性上
使用目的：让xml配置更加简洁，更加优雅

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

①@Component：普通组件
②@Service：一般用在业务逻辑层
③@Controller：一般用在web层上
④@Repository：一般用在dao层上
上面的四个注解功能是一样的，都是用来创建bean的实例，并没有区分哪个注解非要用在哪个层上面，只是为了开发更加的清晰当前组件所代表的角色

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

第一步：引入依赖，spring的lib目录中可以找到
第二步：开启组件扫描，指定扫描的位置
第三步：创建类，在类上面添加创建对象注解
第四步：测试调用，单例bean

第二步：开启组件扫描，指定扫描的位置
告诉spring这个容器我现在要在哪个类上面加上注解

<?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: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/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 1. 如上述所示加入context空间，
            ①开启组件扫描 如果想扫描多个包，中间加上逗号就可以
            ②写扫描包的上层目录,一定要注意不多项目的时候包的路径一定不能一样
    -->
    <context:component-scan base-package="com.wchao"/>
</beans>

第三步：创建类，在类上面添加创建对象注解

第四步：测试调用，单例bean

4.2.1开启组件扫描细节配置

如果不写use-default-filters则默认为true他会扫描包中的所有东西

<context:component-scan base-package="com.wchao" use-default-filters="false"/>

4.2基于注解方式实现属性注入

①@Autowired：根据属性类型进行自动装配
②@Qualifier：根据属性名称进行注入
③@Resource：可以根据类型注入，也可以根据名称注入（它本身是javax扩展包中的注解，spring更建议用别的注解，应为不是他自己的注解）
④@Value：注入普通类型属性
第一步：把service和dao的对象都进行创建，都给类加上创建对象的注解
第二步：在service注入dao，autowired提供了set方法，不用写set方法

Qualifier这个注解的使用要和Autowired这个注解一起使用
Resource不写里面的属性就是根据属性注入，加上里面的name属性就是根据id注入

5、纯注解开发

以上配置文件中只有一行代码就是开启组件扫描
1创建配置类，替代xml配置文件，在实际开发中一般用Spring-Boot进行开发，它简化了Spring