spring学习：2、IOC容器

IOC

1、IOC，控制反转（Inversion of Control），是面向对象编程中的一种设计原则，可以用来降低代码之间的耦合度。
2、把对象创建和对象之间的调用过程，交给Spring进行管理。

IOC底层原理

三种技术：xml解析、工厂模式、反射

正常的对象引用：

使用工厂模式的对象引用：

IOC过程：

• xml配置文件，配置创建的对象

<bean id="dao" class=com.atguigu.UserDao></bean>

• 假设有Service类和dao类，创建工厂类

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

IOC接口

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

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

• BeanFactory：Spring内部使用的接口，我们一般不用。特点：加载配置文件的时候不会创建对象，使用时才创建。
• ApplicationContext：BeanFactory的子接口，提供了更强大的功能，一般面向开发人员进行使用。加载配置文件的时候就创建对象了。

3、ApplicationContext有两个实现类：

• FileSystemXmlApplicationContext
• ClassPathXmlApplicationContext

Bean管理（XML方式）

1、什么是Bean管理：

Bean管理指的是两个操作：创建对象和注入属性

2、Bean管理的操作

• 基于XML配置文件的方式实现
• 基于注解方式实现

3、基于XML方式创建对象

• 在spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现创建对象

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

• 在bean标签有很多属性：
  - id：给对象取一个标识，通过这个标识可以从容器中获得相应对象
  - class：类的全路径
  - name：作用跟id一样，但是name里面可以加一下特殊符号，比如/，这个不常用，了解一下就行
• 创建对象的时候，默认也是执行无参的构造函数

4、基于xml方式注入属性

• DI：依赖注入，就是注入属性
• 有两种方式注入属性：
  - set方法注入
  - 有参构造注入

5、使用set方法注入属性

• 为属性编写set方法
• 在spring的配置文件中配置对象的创建和属性的注入

<bean id="book" class="com.atguigu.spring5.Book">
    <!-- 使用property标签完成属性注入 -->
    <property name="bname" value="yibenshu"></property>
    <property name="bauthor" value="chenxin"></property>
</bean>

• 编写代码测试看看

package com.atguigu.spring5.testDemo;

import com.atguigu.spring5.Book;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring5 {
    @Test
    public void testAdd() {
        //加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        //获取创建的对象
        Book book = context.getBean("book", Book.class);
        System.out.println(book.toString());
    }
}

• 注意：property标签里的name属性的值是跟set方法名是对应起来的！

6、使用有参构造注入属性

• 编写一个类，写上有参构造

package com.atguigu.spring5;

public class Order {

    private String oname;
    private String oaddress;

    public Order(String oname, String oadderess) {
        this.oname = oname;
        this.oaddress = oadderess;
    }
}

• 配置文件中使用constructor-arg标签为有参构造注入属性

<bean id="order" class="com.atguigu.spring5.Order">
    <constructor-arg name="oname" value="abc"/>
    <constructor-arg name="oadderess" value="china"/>
</bean>

• 编写测试方法，这次我们使用ApplicationContext的第二个实现类

@Test
public void test() {
    //加载配置文件
    ApplicationContext context = new FileSystemXmlApplicationContext("src/bean1.xml");
    //获取创建的对象
    Order order = context.getBean("order", Order.class);
    System.out.println(order.toString());
}

• 注意：constructor-arg标签的name属性的值是跟有参构造方法的参数对应的！

7、p名称空间注入（了解）

• 添加p名称空间

xmlns:p="http://www.springframework.org/schema/p"

• p方法注入属性

<bean id="book" class="com.atguigu.spring5.Book" p:bname="yibenshu" p:bauthor="chenxin"/>

8、注入其他类型属性

• 空值

<bean id="book" class="com.atguigu.spring5.Book">
    <!-- 使用property标签完成属性注入 -->
    <property name="bname" value="yibenshu"></property>
    <property name="bauthor" value="chenxin"></property>
    <property name="address">
        <null/>
    </property>
</bean>

• 包含左括号或者右括号

<property name="address" value="&lt;南京&gt;"></property>
或者这样写：
<property name="address">
    <value><![CDATA[<南京>]]></value>
</property>

• 外部bean，假设有两个类：Service类和dao类，在service中调用dao里面的方法：

<bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl"></bean>
<!-- 注意：class中只能写类，不能写接口 -->
<bean id="service" class="com.atguigu.spring5.service.UserService">
    <property name="userDao" ref="userDaoImpl"></property>
</bean>

• 内部bean

<bean id="emp" class="com.atguigu.spring5.bean.Emp">
    <property name="ename" value="chenxin"/>
    <property name="gender" value="male"/>
    <property name="dept">
        <bean id="dept" class="com.atguigu.spring5.bean.Dept">
            <property name="dname" value="安保部"></property>
        </bean>
    </property>
</bean>

• 级联赋值

<bean id="dept" class="com.atguigu.spring5.bean.Dept">
    <property name="dname" value="保安部"/>
</bean>

<bean id="emp" class="com.atguigu.spring5.bean.Emp">
    <property name="ename" value="chenxin"/>
    <property name="gender" value="male"/>
    <property name="dept" ref="dept"/>
</bean>

还有第二种写法：这种写法一定要写上dept的get方法

<bean id="dept" class="com.atguigu.spring5.bean.Dept">
</bean>

<bean id="emp" class="com.atguigu.spring5.bean.Emp">
   <property name="ename" value="chenxin"/>
   <property name="gender" value="male"/>
   <property name="dept" ref="dept"/>
   <property name="dept.dname" value="技术部"/>
</bean>

9、注入集合属性

• 注入数组类型的属性
• 注入List集合类型的属性
• 注入Map集合类型的属性

<bean id="stu" class="com.atguigu.spring5.collectionType.Student">

<property name="courses">
    <array>
        <value>Java</value>
        <value>Mysql</value>
        <value>Redis</value>
    </array>
</property>

<property name="list">
    <list>
        <value>张三</value>
        <value>xiaosan</value>
    </list>
</property>

<property name="maps">
    <map>
        <entry key="JAVA" value="java"></entry>
        <entry key="PHP" value="php"></entry>
    </map>
</property>

<property name="set">
    <set>
        <value>MySQL</value>
        <value>Redis</value>
    </set>
</property>

</bean>

• 在集合中设置对象属性

<property name="courseList">
    <list>
        <ref bean="course1"></ref>
        <ref bean="course2"></ref>
    </list>
</property>

<!-- 这些bean对象要提前准备好 -->
<bean id="course1" class="com.atguigu.spring5.collectionType.Course">
    <property name="cname" value="spring5"></property>
</bean>

<bean id="course2" class="com.atguigu.spring5.collectionType.Course">
    <property name="cname" value="mybatis"></property>
</bean>

• 把集合注入部分提取出来给其他bean用

<!-- 引入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/utils/spring-util.xsd">

<!-- 编写bookList集合，并将其注入到book类中 -->
<util:list id="bookList">
    <value>yibenshu</value>
    <value>liangbenshu</value>
    <value>sanbenshu</value>
</util:list>

<bean id="book" class="com.atguigu.spring5.collectionType.Book">
    <property name="list" ref="bookList"></property>
</bean>

10、FactoryBean

Spring有两种bean，一种是普通bean，一种是工厂bean（FactoryBean）

普通bean：在配置文件中定义什么类型，返回的就是什么类型

工厂bean：配置文件中定义的类型和返回的类型可以不一样

创建工厂bean的方法：

• 创建类，让这个类作为工厂bean，实现接口FactoryBean
• 实现接口里面的方法，在实现的方法中定义返回的bean类型

package com.atguigu.spring5.factorybean;

import com.atguigu.spring5.collectionType.Course;
import org.springframework.beans.factory.FactoryBean;

public class MyBean implements FactoryBean<Course> {
    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }

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

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

最后发现，我们在xml配置文件中写的是MyBean对象，对后返回的是Course对象

@Test
public void test3() {
    ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
    Course course = context.getBean("mybean", Course.class);
    System.out.println(course);
}

11、bean的作用域

• 在Spring里面，设置创建bean实例是单实例还是多实例
• Spring默认情况下，bean是单实例对象
• 在bean标签中增加scope属性用于设置单实例还是多实例。

<!-- 这样就设置成了多实例了 -->
<bean id="book" class="com.atguigu.spring5.collectionType.Book" scope="prototype">
    <property name="list" ref="bookList"></property>
</bean>

测试代码和输出：

@Test
public void test1() {
    ApplicationContext context = new FileSystemXmlApplicationContext("src/bean1.xml");
    Book book1 = context.getBean("book", Book.class);
    Book book2 = context.getBean("book", Book.class);
    System.out.println(book1.hashCode());
    System.out.println(book2.hashCode());
}

• 当设置为singleton时，加载配置文件的时候就创建好bean了
• 当设置为prototype时，调用getBean方法时才创建对象，并且每次调用时返回的对象不一样。

12、bean的生命周期

• 什么是生命周期？从对象创建到对象销毁的过程
• bean的生命周期：
  - 第一步 执行构造方法创建bean实例
  - 第二步 调用set方法设置属性值
  - 第三步 执行初始化的方法（需要在bean标签中设置init-method方法）
  - 第四步 获取创建bean的实例对象
  - 第五步 执行销毁的方法（context.close()，然后执行bean标签中设置的destroy-method方法）
• bean的后置处理器，在第三步的前后可以将bean交给后置处理器的方法去执行。后置处理器也是一个类，它实现了BeanPostProcessor接口。
• 如果在配置文件中配置了后置处理器，那么当前配置文件中的所有bean都添加了这个后置处理器

13、自动装配

• 什么是自动装配：根据指定装配规则（属性名称或者属性类型），Spring自动将匹配的属性进行注入，它是对象级的引用。
• bean标签属性autowire，配置自动装配。autowire有两个值：byName、byType。如果是byName，那么类属性名称要与某个bean的id一致；如果是byType，那么类属性类型要与某个bean的类型一致，如果找到多个的话，就会报错。

14、引入外部属性文件

• 编写外部的属性文件jdbc.properties

prop.driverClassName=com.mysql.cj.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDb
prop.username=root
prop.password=123456

• 引入外部属性文件配置数据库连接池（需要context命名空间）

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

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

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${prop.driverClassName}"></property>
        <property name="url" value="${prop.url}"></property>
        <property name="username" value="${prop.username}"></property>
        <property name="password" value="${prop.password}"></property>
    </bean>
</beans>

Bean管理（注解方式）

1、什么是注解？

注解是代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值…）

注解可以作用在类上面，方法上面或者属性上面。

使用注解的目的：简化xml配置

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

• @Component
• @Service
• @Controller
• @Repository

功能是一样的，都可以用来创建bean实例

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

• 第一步 引入依赖spring-aop-x.x.x.RELEASE.jar
• 第二步 开启组件扫描，告诉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">

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

</beans>

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

package com.xiaoxin.spring5.service;

import org.springframework.stereotype.Service;

//如果不写value属性，则默认是类名的首字母小写形式
@Service(value="userService")
public class UserService {
   public void add() {
       System.out.println("add ...");
   }
}

• 第四步 编写测试类检验一下

package com.xiaoxin.spring5.testdemo;

import com.xiaoxin.spring5.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestDemo {

    @Test
    public void test1() {
        ApplicationContext context = new ClassPathXmlApplicationContext("config.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}

4、开启组件扫描时的细节配置

• 设置只扫描哪些标签

<!-- 只扫描对应包下面的Controller标签 -->
<context:component-scan base-package="com.xiaoxin.spring5" use-default-filters="false">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

• 设置不扫描哪些标签

<!-- 不扫描对应包下面的controller标签-->
<context:component-scan base-package="com.xiaoxin.spring5">
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

5、基于注解实现属性的注入

• @AutoWired：根据属性类型进行注入
• @Qualifier：根据属性名称进行注入
  必须和@Autowired注解同时使用。使用场景：有的时候一个接口可能有多个实现类
• @Resource：可以根据类型注入，也可以根据名称注入
• @Value：注入普通类型属性

package com.xiaoxin.spring5.service;

import com.xiaoxin.spring5.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

//如果不写value属性，则默认是类名的首字母小写形式
@Service(value="userService")
public class UserService {

    //定义UserDao属性
    //不需要set方法，因为里面已经封装好了
    @Autowired //根据类型自动注入
    private UserDao userDao;

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

6、完全注解开发

• 创建配置类，替换xml文件

package com.xiaoxin.spring5.config;

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

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

• 测试类这样写

package com.xiaoxin.spring5.testdemo;

import com.xiaoxin.spring5.config.SpringConfig;
import com.xiaoxin.spring5.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestDemo {

    @Test
    public void test1() {
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}