1、前言

（1）什么是IOC：控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理

（2）使用IOC目的：为了耦合度降低

（3）刚刚的入门案例就是IOC实现

2、IOC底层原理

（1）用到的技术：xml解析、工厂模式、反射

（2）画图详解IOC

a、原始的方式（类之间相互调用）

b、工厂模式

c、IOC解耦过程

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

<bean id="user" class="com.liu.spring5.User"></bean>

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

class UserFactory{
    public static UserDao getDao(){
        String classValue = class属性值 //1.xml解析
        Class class = Class.forName(classValue);
        return (UserDao)class.newInstance();
    }
}

3、IOC接口（BeanFactory）

(1)IOC思想基于IOC容器完成，IOC容器底层就是对象工厂

(2)Spring提供了IOC容器的两种实现方式：（两个接口）

a、BeanFactory：IOC容器基本实现，是Spring内部的使用接口，一般不提供给我们开发人员进行使用

*加载配置文件的时候不会创建对象，只有在使用的时候才会去创建对象。

b、ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员使用

*加载配置文件的时候就会把对象创建（把耗时的过程都在服务器启动过程中完成）

（3）Application接口有实现类

两个主要的实现类：

FileSystem：参数需要在系统的盘中路径 ClassPath：在项目内部的路径

4、IOC操作Bean管理（基于xml）

（1）什么是Bean管理

指的是两个操作 a、Spring创建对象

b、Spring注入属性

（2）Bean管理操作有两种方式

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

（3）基于xml方式创建对象

<bean id="user" class="com.liu.spring5.User"></bean>

a、方法：在spring配置文件中使用bean标签，标签里面添加对应属性，就可以实现对象创建。 b、常用属性：

• id属性：唯一标识
• class属性：类全路径（包类属性）
• name属性：和id属性作用一样，但name属性可以加特殊字符，属于比较早期的属性 c、 创建对象的时候，默认也是执行无参构造方法完成对象的创建

（4）基于xml方式注入属性

a、DI：依赖注入，就是注入属性 -第一种注入方式：采用set方法对属性进行注入 首先在类中写好set方法 在spring配置文件配置对象创建，配置属性注入

<!--    set方法注入属性-->
    <bean id="book" class="com.liu.spring5.User">
        <property name="bname" value="易筋经"></property>
    </bean>
<!--    使用property完成属性注入
        name：类里面的属性名称
        value：向属性中注入的值-->

set注入简化：使用p名称空间注入，可以简化基于xml的配置方式 第一步 添加p名称空间在配置文件中

第二步 进行属性注入，在bean标签里面进行该操作

<bean id="User" class="com.liu.spring5.User p:name="九阳神功"></bean>

-第二种注入方式：采用有参构造注入 首先在类中写好有参构造方法，定义好属性，创建属性对应的有参构造方法 在spring配置文件里配置属性注入

<bean id="user" class="com.liu.spring5.User">
    <constructor-arg name="name" value="liuwei"></constructor-arg>
    <constructor-arg index="1" value="13"></constructor-arg>
</bean>

index代表参数的索引值，1代表第2个参数 b、xml注入其他类型的属性 -字面量 1. null值 属性里面设置空值 <property name="address"> <null></null> </property> 2. 属性值包含特殊符号 <!-- 属性值包含特殊符号 1 把特殊符号进行转义&lt；&gt 2 把带特殊符号的内容写到CDATA--> <bean id="user" class="com.liu.spring5.User"> <property name="address"> <value><![CDATA[<<南京>>]]></value> </property> </bean> c、注入属性-外部bean(即在一个类中引入另外一个类

• 创建两个类service类和dao类
• 在service类中调用dao类的方法
• 在spring的配置文件中进行配置 首先创建UserService类并调用UserDao类的方法

public class UserServiceImpl implements UserService{
    private UserDao userdao;

    public void setUserdao(UserDao userdao) {
        this.userdao = userdao;
    }

    @Override
    public void print() {
        System.out.println("service is serving");
        userdao.print();
    }
}

接着在xml文件中进行配置

<bean id="userService" class="com.liu.spring5.Service.UserServiceImpl">
    <property name="userdao" ref="userDao"></property>
</bean>
<bean id="userDao" class="com.liu.spring5.Dao.UserDapImpl"></bean>

最后在测试文件中调用

public class testDemo6 {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
        UserService test = context.getBean("userService", UserServiceImpl.class);
        test.print();
    }
}

d、注入属性-内部bean

• 一对多关系：部门和员工，一个部门有多个员工，一个员工只有一个部门
• 在实体类中表示一对多关系，员工里面表示所属的部门，用对象形式表示

public class Emp {
    private String ename;
    private String esex;
    private com ecom;

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

    public void setEsex(String esex) {
        this.esex = esex;
    }

    public void setEcom(com ecom) {
        this.ecom = ecom;
    }
    public void add(){
        System.out.println(ename + "::" + esex + "::" + ecom);
    }
}

• 在spring文件中进行配置。

<bean id="emp" class="com.liu.spring5.Emp">
    <property name="ename" value="liuwei"></property>
    <property name="esex" value="男"></property>
    <property name="ecom">
        <bean id="com" class="com.liu.spring5.com">
            <property name="cname" value="技术部"></property>
        </bean>
    </property>
</bean>

e、级联赋值

• 第一种写法

<bean id="emp1" class="com.liu.spring5.Emp">
    <property name="ename" value="liuwei1"></property>
    <property name="esex" value="nan"></property>
    <property name="ecom" ref="com"></property>
</bean>
<bean id="com" class="com.liu.spring5.com">
    <property name="cname" value="安保部"></property>
</bean>

• 第二种写法

<bean id="emp1" class="com.liu.spring5.Emp">
    <property name="ename" value="liuwei1"></property>
    <property name="esex" value="nan"></property>
    <property name="ecom" ref="com"></property>
    <property name="ecom.cname" value="公关部"></property>
</bean>
<bean id="com" class="com.liu.spring5.com">
    <property name="cname" value="安保部"></property>
</bean>

f、注入集合属性

• 注入数组类型属性
• 注入List集合类型属性
• 注入Map集合类型属性 1、创建类、定义数组、list、map、set类型属性，生成对应set方法

public class Stu {
    //1. 数组类型
    private String[] course;

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

    //3. map类型
    private Map<String,String> map;

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

    public void setCourse(String[] course) {
        this.course = course;
    }

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

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

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

    public void test() {
        System.out.println(course.toString());
        System.out.println(list.toString());
        System.out.println(map.toString());
        System.out.println(set.toString());
    }
}

2、在spring文件中进行注入

<bean id="stu" class="com.liu.spring5.SetType.Stu">
    <property name="course">
        <array>
            <value>Java</value>
            <value>C++</value>
            <value>Python</value>
        </array>
    </property>
    <property name="list">
        <list>
            <value>liuwei</value>
            <value>22</value>
            <value>man</value>
        </list>
    </property>

    <property name="map">
        <map>
            <entry key="name" value="liuwei"></entry>
            <entry key="age" value="13"></entry>
            <entry key="address" value="suqian"></entry>
        </map>
    </property>

    <property name="set">
        <set>
            <value>one</value>
            <value>two</value>
        </set>
    </property>
</bean>

g、在集合里面设置对象类型的值 1、创建course类

public class Course {
    private String cname;

    public void setCname(String cname) {
        this.cname = cname;
    }

    @Override
    public String toString() {
        return this.cname;
    }
}

2、在spring文件里配置

  <property name="course1">
        <list>
            <ref bean="course"></ref>
            <ref bean="course1"></ref>
        </list>
    </property>
</bean>

<bean id="course" class="com.liu.spring5.SetType.Course">
    <property name="cname" value="spring框架"></property>
</bean>
<bean id="course1" class="com.liu.spring5.SetType.Course">
    <property name="cname" value="mybatis框架"></property>
</bean>

h、把集合注入部分提取出来 1、在配置文件中引入命名空间util

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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">

2、使用util完成提取list集合类型

<util:list id="bookname">
    <value>易筋经</value>
    <value>降龙十八掌</value>
    <value>丁厶琦</value>
</util:list>

<bean id="book" class="com.liu.spring5.SetType.Book">
    <property name="list" ref="bookname"></property>
</bean>

(5) FactoryBean

a、Spring有两种类型bean，一种是普通bean（即我们创建的bean），另外一种是工厂bean（FactoryBean） b、普通bean：在配置文件中定义的bean类型就是返回的类型 c、工厂bean：在配置文件中定义的bean类型可以和返回的类型不一样 第一步 创建一个类，让这个类作为工厂bean，实现接口FactoryBean 第二部 实现接口里面的方法，在实现的方法中（getObject方法）定义返回的bean类型

public class MyBean implements FactoryBean<Book> {


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

    //控制返回的类型
    @Override
    public Book getObject() throws Exception {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean5.xml");
        Book book = context.getBean("book",Book.class);
        return book;
    }

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

(6) bean的作用域

a、在Spring里面，设置创建的bean实例是单实例还是多实例，这就叫做bean的作用域 b、在Spring里，在默认情况下，创建的bean是一个单实例对象（一直只有一个对象叫做单实例，每次使用都创建一个新的对象叫做多实例） c、如何设置单实例还是多实例

• bean标签里有属性（scope）用于设置单实例还是多实例
• scope属性值： 第一个值 默认值 singleton 表示单实例对象 第二个值 prototype 表示多实例对象 d、singleton和prototype的区别
• 一个表示单实例，一个表示多实例
• 设置scope值是singleton时候，当加载spring配置文件的时候就会创建单实例对象
• 设置scope值是prototype的时候，不是在加载spring配置文件的时候创建对象，只有在getbean获取对象的时候才会创建多实例对象。 第三个值 request 第四个值 session（仅作了解）

（7）bean的生命周期

a、生命周期

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

public class Orders {
    private String oname;

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步，调用set方法赋值");
    }

    public Orders() {
        System.out.println("第一步，调用构造器创建实例");
    }
    public void initMethod(){
        System.out.println("第三步，调用初始化方法");
    }
    private void destroyMethod() {
        System.out.println("第五步 调用销毁方法");
    }
}

ApplicationContext context = new ClassPathXmlApplicationContext("bean5.xml");
Orders order = context.getBean("order",Orders.class);
System.out.println("第四步，bean对象成功获取到");

((ClassPathXmlApplicationContext)context).close();

<bean id="order" class="com.liu.spring5.FactoryBean.Orders" init-method="initMethod" destroy-method="destroyMethod">
    <property name="oname" value="test"></property>
</bean>

d、bean的后置处理器，加入后置处理器后，会有7步的生命周期

• 通过构造器创建bean的实例（无参数构造）
• 为bean的属性设置值和对其他bean引用（调用set方法）
• 把bean实例传递bean后置处理器的方法
• 调用bean的初始化方法（需要进行配置初始化的方法）
• 把bean实例传递bean后置处理器的方法
• bean可以使用了（对象获取到了）
• 当容器关闭的时候，调用bean的销毁方法（需要进行配置销毁方法） e、演示添加后置处理器效果
• 创建类，实现接口BeanPostProcesor，创建后置处理器

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化前后置处理器的方法");
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean,beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化后处理器方法");
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

(8) XML自动装配

a、什么是自动装配

• 根据指定装配规则（属性名称或者属性类型），Spring将自动匹配的属性值进行注入（配置name、value属于手动装配） b、演示自动装配过程
• 根据属性名称自动装配

<bean id="emp" class="com.liu.spring5.AutoWire.Emp" autowire="byName"></bean>
<bean id="dept" class="com.liu.spring5.AutoWire.Dept">
    <property name="dname" value="厦大部"></property>
</bean>

• 根据属性类型进行自动装配

<bean id="emp" class="com.liu.spring5.AutoWire.Emp" autowire="byType"></bean>
<bean id="dept" class="com.liu.spring5.AutoWire.Dept">
    <property name="dname" value="厦大部"></property>
</bean>

(9) 引入外部属性文件

a、直接配置数据库信息

• 配置德鲁伊连接池
• 引入德鲁伊连接池的jar文件

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

• 创建外部属性文件，properties文件

• 把外部properties属性文件引入到spring配置文件中 *引入context名称空间，把util所有东西改成context

• 在spring配置文件中引入外部属性文件

5、IOC操作Bean管理（基于注解）

（1）什么事注解

a、注解事代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值。。。。） b、使用注解，注解可以作用在类上面、方法上面、属性上面。 c、使用注解的目的：为了简化xml的配置

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

a、@Component b、@Service c、@Controller d、@Repository *上面四个注解功能是一样的，都可以用来创建bean实例

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

a、第一步引入依赖，引入aop依赖 b、第二步 开启组件扫描 扫描指定的包，遇见注解则创建对象

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

    <bean id="emp" class="com.liu.spring5.AutoWire.Emp" autowire="byType"></bean>
    <bean id="dept" class="com.liu.spring5.AutoWire.Dept">
        <property name="dname" value="厦大部"></property>
    </bean>

<!--    开启组件扫描
        1、如果扫描多个包，多个包之间用逗号隔开
        2、扫描包的上层目录-->
    <context:component-scan base-package="com.liu.spring5.Service,com.liu.spring5.Dao"></context:component-scan>

</beans>

c、第三步 创建类，在类上面创建对象注释

//value可以不写，默认为类的名称首字母小写
@Component(value = "userService")   //<bean id="userService" class="">
public class UserService {

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

}

（4）基于注解的方式实现属性注入

a、@AutoWired：表示根据属性类型进行自动装配 第一步：把service和dao对象进行创建，在service和dao类上添加注解 第二步：在service里注入dao对象，在service类添加dao类型属性（不需要set方法），在属性上面写上注解 b、@Qualifier：表示根据属性名称进行自动装配 要和@Autowired一起使用，当有多个子类不知道使用哪个的时候，就按照名字指定

@Component
public class Service {

    @Autowired
    @Qualifier("service")
    private Dao dao;
    public void add(){
        System.out.println("service add..");
        dao.add();
    }
}

@Component
public class Dao {
    public void add(){
        System.out.println("dao add..");
    }
}

c、@Resource：可以根据类型注入，也可以根据名称注入（设置name属性即可） d、@Value：注入普通类型属性

（5）完全注解开发（不用xml)

a、创建一个配置类，完全替代xml文件

@Configuration
@ComponentScan(basePackages = {"com.liu.spring5"})
public class SpringConfig {
}

b、测试方法有点区别

@Test
public void testallzj(){
    ApplicationContext context = new AnnotationConfigApplicationContext("SpringConfig.class");
    Service service = context.getBean("service", Service.class);
    service.add();