一、Spring IOC

一、Spring概述

1.Spring是什么？

Spring是分层的Java SE/EE应用的全栈式（full-stack）,轻量级开源框架。

- 全栈式：提供了表现层 SpringMVC和持久层 Spring JDBC Template以及 业务层 事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。
- 轻量级与重量级的划分主要依据是看它使用了多少服务，启动时需要加载的资源多少以及耦合度等等。

两大核心

IOC（Inverse Of Control）控制反转：把对象的创建权交给Spring
AOP（Aspect Oriented Programming）面向切面编程：在不修改源代码的情况下，对方法进行增强

---

2.Spring的优势

- 1.方便解耦，简化开发：Spring就是一个容器，可以将所有对象创建和关系维护交给Spring管理。
		- 什么是耦合度？对象之间的关系，通常说当一个模块(对象)更改时也需要更改其他模块(对象)，这就是耦合，耦合度过高会使代码的维护成本增加。要尽量解耦
- 2.AOP编程的支持：Spring提供面向切面编程，方便实现程序进行权限拦截，运行监控等功能。
- 3.声明式事务的支持：通过配置完成事务的管理，无需手动编程
- 4.方便测试，降低JavaEE API的使用：Spring对Junit4支持，可以使用注解测试
- 5.方便集成各种优秀框架：不排除各种优秀的开源框架，内部提供了对各种优秀框架的直接支持

---

2.Spring的体系结构

---

二、初识IOC

1.概述

**控制反转（Inverse Of Control）**不是什么技术，而是一种设计思想。它的目的是指导我们设计出更多松耦合的程序。

- 控制：在java中指的是对象的控制权限（创建、销毁）
- 反转：指的是对象控制权由原来开发者在类中手动控制反转到由Spring容器控制

举个栗子

* 传统方式
	之前我们需要一个userDao实例，需要开发者自己手动创建 new UserDao();
* IOC方式
	现在我们需要一个userDao实例，直接从spring的IOC容器获得，对象的创建权交给了spring控制

2.自定义IOC容器

需求：实现service层和dao层解耦合

① 项目所需依赖坐标

  <!--导入dom4j依赖，用来解析xml文件-->
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.1</version>
        </dependency>
        <!-- xpath语法解析xml文件 -->
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.2.0</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

② UserDao和UserDaoImpl接口

public interface UserDao {
    /**
     * 模拟保存用户信息
     */
    void save();
}

public class UserDaoImpl implements UserDao {
    /**
     * 模拟保存用户信息
     */
    public void save() {
        System.out.println("dao层save()方法执行了！保存用户成功！");
    }
}

③ UserService和UserServiceImpl接口

public interface UserService {
    /**
     * 调用dao层save方法
     */
    void save();
}

public class UserServiceImpl implements UserService {
    /**
     * 调用dao层方法，完成保存
     */
    public void save() throws Exception{
        // 传统开发方式 编译期依赖，耦合度高
        UserDao userDao = new UserDaoImpl();
    }
}

④ 测试

	@Test
    public void test1() {
        // 创建UserService对象
        UserService userService = new UserServiceImpl();
        userService.save();
    }
}

问题： 当前service对象和dao对象耦合度太高，而且每次new的都是一个新的对象，导致服务器压力过大。

- 解耦合的原则是：编译期不依赖，运行期依赖

⑤ 修改UserServiceImpl实现类

public class UserServiceImpl implements UserService {
    /**
     * 调用dao层方法，完成保存
     */
    public void save() throws Exception{
        // 传统开发方式 编译期依赖，耦合度高
        // UserDao userDao = new UserDaoImpl();

        // 反射动态获取UserDao类型的对象，替换了new关键字
        Class<?> clazz = Class.forName("cn.xuguowen.dao.impl.UserDaoImpl");
        UserDao userDao = (UserDao) clazz.newInstance();
    }
}

问题： 存在硬编码问题

⑥ 编写beans.xml文件

<beans>
    <bean id="userdao" class="cn.xuguowen.dao.impl.UserDaoImpl"></bean>
</beans>

⑦ 编写BeanFactory工具类

public class BeanFactory {
    private static Map<String,Object> iocmap = new HashMap<>();

    // 在这个类加载的时候，我就要获取到xml文件中信息，并且根据信息生成我想要获取的对象
    static {
        try {
            // 1.读取beans.xml配置文件
            InputStream is = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
            // 2.使用dom4j解析xml文件
            SAXReader saxReader = new SAXReader();
            Document document = saxReader.read(is);
            // 3.根据xpath语法获取配置文件中的所有bean标签元素
            String xpath = "//bean";
            List<Element> elements = document.selectNodes(xpath);
            // 4.循环遍历集合中的元素
            for (Element element : elements) {
                // 5.获取每一元素的id属性值和class属性值
                String id = element.attributeValue("id");
                String className = element.attributeValue("class");
                // 6.使用反射生成实例对象
                Object o = Class.forName(className).newInstance();
                // 7.创建map集合，模拟ioc容器
                iocmap.put(id,o);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Object getObject(String id) {
        Object o = iocmap.get(id);
        return o;
    }
}

⑧ 修改UserServiceImpl实现类

public class UserServiceImpl implements UserService {
    /**
     * 调用dao层方法，完成保存
     */
    public void save() throws Exception{

        UserDao userDao = (UserDao) BeanFactory.getObject("userdao");
        userDao.save();
    }
}

⑨ 测试

	@Test
    public void test1() throws Exception {
        // 创建UserService对象
        UserService userService = new UserServiceImpl();
        userService.save();
    }

⑩ 小结

* 其实升级后的BeanFactory就是一个简单的Spring的IOC容器所具备的功能。
* 之前我们需要一个userDao实例，需要开发者自己手动创建 new UserDao();
* 现在我们需要一个userDao实例，直接从spring的IOC容器获得，对象的创建权交给了spring控制
* 最终目标：代码解耦合

---

三、Spring快速入门

需求：借助Spring的IOC实现service层和dao层代码解耦合

1.导入Spring开发基本坐标

   <!-- 导入spring依赖坐标 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

2.编写Dao接口和实现类

public interface UserDao {
    /**
     * 模拟保存用户信息
     */
    void save();
}

public class UserDaoImpl implements UserDao {
    /**
     * 模拟保存用户信息
     */
    public void save() {
        System.out.println("dao层方法调用了！保存用户成功！");
    }
}

3.编写Spring的核心配置文件 applicationContext.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">

    <!--将UserDaoImpl对象的创建交给ioc容器管理-->
    <!--
        1.id 唯一标识
        2.class 想要创建对象实例的全路径
    -->
    <bean id="userDao" class="cn.xuguowen.dao.impl.UserDaoImpl"></bean>
</beans>

4.使用Spring相关API获取Bean实例

	/**
     * 测试spring的快速入门
     */
    @org.junit.Test
    public void testSpringIocQuickStack() {
        // 创建上下文对象，借助上下文对象获取对象实例
        ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 调用api，根据id唯一标识获取实例对象
        UserDao userDao = (UserDao) classPathXmlApplicationContext.getBean("userDao");
        userDao.save();

    }

---

四、Spring相关API

1.API继承体系介绍

Spring的API体系异常庞大，我们现在只关注BeanFactory和ApplicationContext

---

2.BeanFactory:是IOC容器的核心接口，它定义了IOC的基本功能。

- 特点：在第一次调用getBean() 方法时，创建指定对象的实例，并存储到IOC容器中

	 @org.junit.Test
    public void testBeanFactory() {
        // 加载配置文件
        BeanFactory xmlBeanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
        // 调用getBean()方法后，才会去解析xml文件，将bean对象存储到ioc容器中，然后通过id去获取
        UserDao userDao = (UserDao) xmlBeanFactory.getBean("userDao");
        userDao.save();
    }

3.ApplicationContext:代表应用上下文对象，可以获得IOC容器中的Bean对象。

- 特点：在Spring容器启动时，加载并创建所有对象的实例

	@org.junit.Test
    public void testSpringIocQuickStack() {
        // 创建上下文对象，借助上下文对象获取对象实例
        ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 调用api，根据id唯一标识获取实例对象
        UserDao userDao = (UserDao) classPathXmlApplicationContext.getBean("userDao");
        userDao.save();

    }

4.常用实现类

1. ClassPathXmlApplicationContext
它是从类的根路径下加载配置文件 推荐使用这种。
2. FileSystemXmlApplicationContext
它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
3. AnnotationConfigApplicationContext
当使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

	@org.junit.Test
    public void testFileSystemXmlApplicationContext() {
        ApplicationContext fileSystemXmlApplicationContext = new FileSystemXmlApplicationContext("D:\\IdeaProjects\\chapter_six\\spring\\spring_iocquickstack\\src\\main\\resources\\applicationContext.xml");
        UserDao userDao = (UserDao) fileSystemXmlApplicationContext.getBean("userDao");
        userDao.save();
    }

5.常用方法

1. Object getBean(String name);
根据Bean的id从容器中获得Bean实例，返回是Object，需要强转。
2. <T> T getBean(Class<T> requiredType);
根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，则此方法会报错。
3. <T> T getBean(String name,Class<T> requiredType);
根据Bean的id和类型获得Bean实例，解决容器中相同类型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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--将UserDaoImpl对象的创建交给ioc容器管理-->
    <!--
        1.id 唯一标识
        2.class 想要创建对象实例的全路径
    -->
    <bean id="userDao" class="cn.xuguowen.dao.impl.UserDaoImpl"></bean>

    <bean id="userDao2" class="cn.xuguowen.dao.impl.UserDaoImpl"></bean>
</beans>

测试

	/**
     * 测试spring的快速入门
     */
    @org.junit.Test
    public void testSpringIocQuickStack() {
        // 创建上下文对象，借助上下文对象获取对象实例
        ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 调用api，根据id唯一标识获取实例对象
        // UserDao userDao = (UserDao) classPathXmlApplicationContext.getBean("userDao");
        // 方式二：如果核心配置文件中，UserDao类型的实例存在多个就会报错 NoUniqueBeanDefinitionException
        // UserDao userDao = classPathXmlApplicationContext.getBean(UserDao.class);
        // 方式三：解决方式二存在的问题：如果核心配置文件中存在多个相同类型的实例对象，就根据id和类型来确定这个实例对象
        UserDao userDao = classPathXmlApplicationContext.getBean("userDao2", UserDao.class);
        userDao.save();
    }

---

五、Spring配置文件

1.Bean标签基本配置

 	<!--将对象的创建交给ioc容器管理-->
    <!--
        1.id： Bean实例在IOC容器中的唯一标识
        2.class： Bean实例的全限定类名
        3.默认情况下：创建该对象实例是通过无参构造器创建的。如果实例对象所在的类中，不存在无参数构造器，就会报错
    -->
    <bean id="userDao" class="cn.xuguowen.dao.impl.UserDaoImpl"></bean>

---

2.Bean标签范围配置

<bean id="userDao" class="cn.xuguowen.dao.impl.UserDaoImpl" scope=""></bean>

scope属性指对象的作用范围，取值如下：

取值范围	说明
singleton	默认值，单例的
prototype	多例的
request	WEB项目中，Spring创建一个Bean的对象，将对象存入到request域中
session	WEB项目中，Spring创建一个Bean的对象，将对象存入到session域中
global session	WEB项目中，应用在Portlet环境，如果没有Portlet环境那么globalSession 相当于 session

- 1.当scope的值为singleton时，
- 			Bean的实例化个数：1个
- 			Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例
- 			Bean的生命周期：跟随容器的状态
- 						对象创建：当应用加载，创建容器时，对象就被创建了
- 						对象运行：只要容器在，对象一直活着
- 						对象销毁：当应用卸载，销毁容器时，对象就被销毁了
- 2.当scope的值为prototype时，
- 			Bean的实例化个数：多个
- 			Bean的实例化时机：当调用getBean()方法实例化Bean
- 			Bean的生命周期：
- 						对象创建：当使用对象时，创建新的对象实例
- 						对象运行：只要对象在使用中，就一直活着
- 						对象销毁：当对象长时间不用时，就会被Java的垃圾回收器回收了

---

3.Bean生命周期配置

 <!--
        1.id： Bean实例在IOC容器中的唯一标识
        2.class： Bean实例的全限定类名
        3.默认情况下：创建该对象实例是通过无参构造器创建的。如果实例对象所在的类中，不存在无参数构造器，就会报错
        4.scope="singleton":表示创建的实例对象是单例的，默认情况就是这样的
        5.init-method:指定类中的初始化方法名称
        6.destroy-method：指定类中的销毁方法名称
    -->
    <bean id="userDao" class="cn.xuguowen.dao.impl.UserDaoImpl" init-method="" destroy-method=""></bean>

---

4.Bean实例化三种方式

• 无参构造方法实例化
• 工厂静态方法实例化
• 工厂普通方法实例化

①：无参构造方法实例化

根据默认无参构造方法来创建对象，如果bean中没有默认无参构造方法，将会创建失败。

	<!-- 一：实例化Bean的方式：无参构造实例化-->
    <bean id="userDao" class="cn.xuguowen.dao.impl.UserDaoImpl"></bean>

②：工厂静态方法实例化

应用场景： 依赖的jar包中有个A类，A类中有个静态方法createXxx(),这个方法的返回值是一个B类型的对象。如果我们频繁使用这个对象，此时我们可以将这个对象的创建权交给Spring的IOC容器管理，以后我们在使用这个对象时，无需调用A类中的方法，直接从IOC容器中获得。

package cn.xuguowen.factory;

import cn.xuguowen.dao.UserDao;
import cn.xuguowen.dao.impl.UserDaoImpl;

/**
 * @author 徐国文
 * @create 2021-10-06 15:34
 * 静态工厂实例化UserDao类型的对象
 */
public class StatcFactoryBean {

    public static UserDao createUserDao() {
        return new UserDaoImpl();
    }
}

	 <!-- 二：实例化Bean的方式：工厂静态方法实例化-->
    <bean id="userDao" class="cn.xuguowen.factory.StatcFactoryBean" factory-method="createUserDao"></bean>

③：工厂普通方法实例化

应用场景： 依赖的jar包中有个A类，A类中有个普通方法createXxx()，这个方法的返回值是一个B类型的对象。如果我们频繁使用这个对象，此时我们可以将这个对象的创建权交给Spring的IOC容器管理，以后我们在使用这个对象时，无需调用A类中的这个方法，直接从IOC容器获得。

package cn.xuguowen.factory;

import cn.xuguowen.dao.UserDao;
import cn.xuguowen.dao.impl.UserDaoImpl;

/**
 * @author 徐国文
 * @create 2021-10-06 15:37
 * 工厂普通方法实例化UserDao类型的对象
 */
public class DynamicFactoryBean {

    public UserDao createUserDao() {
        return new UserDaoImpl();
    }
}

   <!--三：实例化Bean的方式：工厂普通方法实例化-->
    <bean id="dynamicFactoryBean" class="cn.xuguowen.factory.DynamicFactoryBean"></bean>
    <bean id="userDao" factory-bean="dynamicFactoryBean" factory-method="createUserDao"></bean>

---

5.Bean依赖注入概述

依赖注入 DI （Dependency injection）: 它是Spring框架核心IOC的具体体现。
在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。
那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。简单的说，就是通过框架把持久层对象传入业务层，而不用我们自己去获取。

①：Bean依赖注入方式：构造方法

在UserServiceImpl中创建有参构造方法

	private UserDao userDao;

    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }

配置Spring容器调用有参构造时进行注入

 	<bean id="userDao" class="cn.xuguowen.dao.impl.UserDaoImpl"></bean>
	<bean id="userService" class="cn.xuguowen.service.impl.UserServiceImpl">
        <!--构造方法依赖注入DI方式一-->
        <!--
            1.index="0" :表示Bean对象构造方法中的第一个参数
            2.type="cn.xuguowen.dao.UserDao": 表示要注入Bean对象的类型
            3.ref="userDao" : 指向容器中存在的一个Bean对象
        -->
<!--        <constructor-arg index="0" type="cn.xuguowen.dao.UserDao" ref="userDao"></constructor-arg>-->
        <!--构造方法依赖注入DI方式二-->
        <!--
            1.name:表示Bean对象中构造方法中参数的变量名
            2.ref="userDao":表示要将容器中那个Bean实例对象注入到参数中
        -->
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
    </bean>

---

②：Bean依赖注入方式：set方法

在UserServiceImpl中创建setXxx()方法

	private UserDao userDao;

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

配置Spring容器调用set方法进行注入

	<bean id="userService" class="cn.xuguowen.service.impl.UserServiceImpl">
        <!-- 依赖注入方式二：set方法注入-->
        <!--
            1.name="userDao":值应该是setXxx()方法将set关键字去掉，然后Xxx首字母小写
        -->
        <property name="userDao" ref="userDao"></property>
    </bean>

---

③：Bean依赖注入方式：P命名空间注入

P命名空间注入本质也是set方法注入，但比起上述的set方法注入更加方便，主要体现在配置文件中，如下：
首先：需要引入P命名空间

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

其次，需要修改注入方式：

<bean id="userDao" class="cn.xuguowen.dao.impl.UserDaoImpl"></bean>
<bean id="userService" class="cn.xuguowen.service.impl.UserServiceImpl" p:userDao-ref="userDao">

---

6.Bean依赖注入的数据类型

上面操作，都是注入Bean对象，除了对象的引用可以注入，普通数据类型和集合都可以在容器中进行注入。
注入数据的三种数据类型

• 普通数据类型
• 引用数据类型
• 集合数据类型

其中引用数据类型，此处就不再赘述了，之前的操作都是对UserDao对象的引用进行注入的。下面将以set方法注入为例，演示普通数据类型和集合数据类型的注入。

①：注入普通数据类型

UserDaoImpl.java

public class UserDaoImpl implements UserDao {

    private String username;
    private Integer age;
    // 使用setXxx()方法实现普通数据类型的注入

    public void setUsername(String username) {
        this.username = username;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    /**
     * 模拟保存用户信息
     */
    public void save() {
        System.out.println(username);
        System.out.println(age);
        System.out.println("dao层方法调用了！保存用户成功！");
    }
}

applicationContext.xml

	<bean id="userDao" class="cn.xuguowen.dao.impl.UserDaoImpl">
        <property name="username" value="徐国文"></property>
        <property name="age" value="18"></property>
    </bean>

---

②：注入集合数据类型

集合数据类型包括：List、Set、Array、Map、Properties

a）List集合注入

public class UserDaoImpl implements UserDao {
	private List<Object> list;
	public void setList(List<Object> list) {
        this.list = list;
    }
    public void save() {
        System.out.println("List集合:" + list);
        System.out.println("dao层方法调用了！保存用户成功！");
    }
}

<bean name="user" class="cn.xuguowen.pojo.User">
        <property name="name" value="徐国文"></property>
        <property name="age" value="18"></property>
    </bean>
    <!-- 一：实例化Bean的方式：无参构造实例化-->
    <bean id="userDao" class="cn.xuguowen.dao.impl.UserDaoImpl">
        <!--注入集合数据类型-->
        <property name="list">
            <list>
                <!--注入基本数据类型-->
                <value>aaa</value>
                <!--注入引用数据类型-->
                <ref bean="user"></ref>
            </list>
        </property>
    </bean>

---

b）Set集合注入

public class UserDaoImpl implements UserDao {
    private Set<Object> set;
    // 使用setXxx()方法实现普通数据类型的注入
    public void setSet(Set<Object> set) {
        this.set = set;
    }
    /**
     * 模拟保存用户信息
     */
    public void save() {
        System.out.println("set集合:" + set);
        System.out.println("dao层方法调用了！保存用户成功！");
    }
}

<bean name="user" class="cn.xuguowen.pojo.User">
        <property name="name" value="徐国文"></property>
        <property name="age" value="18"></property>
    </bean>
    <!-- 一：实例化Bean的方式：无参构造实例化-->
    <bean id="userDao" class="cn.xuguowen.dao.impl.UserDaoImpl">
        <!--注入set集合类型-->
        <property name="set">
            <set>
                <value>bbb</value>
                <ref bean="user"></ref>
            </set>
        </property>
    </bean>

---

c）Array数组注入

public class UserDaoImpl implements UserDao {
    private Set<Object> set;
    // 使用setXxx()方法实现普通数据类型的注入
    public void setArray(Object[] array) {
        this.array = array;
    }

    /**
     * 模拟保存用户信息
     */
    public void save() {
        System.out.println("Ayyay数组：" + Arrays.toString(array));
        System.out.println("dao层方法调用了！保存用户成功！");
    }
}

<bean name="user" class="cn.xuguowen.pojo.User">
        <property name="name" value="徐国文"></property>
        <property name="age" value="18"></property>
    </bean>
    <!-- 一：实例化Bean的方式：无参构造实例化-->
    <bean id="userDao" class="cn.xuguowen.dao.impl.UserDaoImpl">
        <!--注入数组类型-->
        <property name="array">
            <array>
                <value>ccc</value>
                <ref bean="user"></ref>
            </array>
        </property>
    </bean>

---

d）Map集合注入

public class UserDaoImpl implements UserDao {
    private Map<String,Object> map;

    // 使用setXxx()方法实现普通数据类型的注入
    public void setMap(Map<String, Object> map) {
        this.map = map;
	}
    /**
     * 模拟保存用户信息
     */
    public void save() {
        System.out.println("Map集合：" + map);
        System.out.println("dao层方法调用了！保存用户成功！");
    }
}

	<bean name="user" class="cn.xuguowen.pojo.User">
        <property name="name" value="徐国文"></property>
        <property name="age" value="18"></property>
    </bean>
    <!-- 一：实例化Bean的方式：无参构造实例化-->
    <bean id="userDao" class="cn.xuguowen.dao.impl.UserDaoImpl">
        <!--注入map集合类型-->
        <property name="map">
            <map>
                <entry key="k1" value="ddd"></entry>
                <entry key="k2" value-ref="user"></entry>
            </map>
        </property>
    </bean>

---

e）Properties集合注入

public class UserDaoImpl implements UserDao {
    private Properties properties;
    // 使用setXxx()方法实现普通数据类型的注入
    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    /**
     * 模拟保存用户信息
     */
    public void save() {
        System.out.println("Properties:" + properties);
        System.out.println("dao层方法调用了！保存用户成功！");
    }
}

	<bean name="user" class="cn.xuguowen.pojo.User">
        <property name="name" value="徐国文"></property>
        <property name="age" value="18"></property>
    </bean>
    <!-- 一：实例化Bean的方式：无参构造实例化-->
    <bean id="userDao" class="cn.xuguowen.dao.impl.UserDaoImpl">
        <!--注入properties集合类型:key和value都是字符串类型的-->        <property name="properties">
            <props>
                <prop key="p1">p1</prop>
                <prop key="p2">p2</prop>
                <prop key="p3">p3</prop>
            </props>
        </property>
    </bean>

---

7.配置文件模块化

在实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分配置拆解到其他配置文件中，也就是所谓的配置文件模块化。
拆解配置文件的原则： 按层拆解或者按业务模块拆解

程序加载配置文件的方式有两种

①：并列的多个配置文件

ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml","applicationContext-service.xml","applicationContext-dao.xml");

②：主从配置文件

<import resource="classpath:applicationContext-user.xml"></import>

---

六、Spring的xml整合DbUtils（IOC实战）

1.DbUtils是什么？

DbUtils是Apache的一款用于简化Dao代码的工具类，它底层封装了JDBC技术。
核心对象

QueryRunner queryRunner = new QueryRunner(DataSource dataSource);

核心方法

int update(); 执行增、删、改语句
T query(); 执行查询语句
ResultSetHandler<T> 这是一个接口，主要作用是将数据库返回的记录封装到实体对象

**举个栗子：**查询所有账户信息

public class DbUtilsTest {
	@Test
	public void findAllTest() throws Exception {
		// 创建DBUtils工具类，传入连接池
		QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());
		// 编写sql
		String sql = "select * from account";
		// 执行sql
		List<Account> list = queryRunner.query(sql, new BeanListHandler<Account>
		(Account.class));
		// 打印结果
		for (Account account : list) {
		System.out.println(account);
		}
	}
}

---

2.基于Spring的xml配置实现账户的CRUD案例

①：准备数据库环境

CREATE DATABASE `spring_db`;
USE `spring_db`;
CREATE TABLE `account` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(32) DEFAULT NULL,
`money` DOUBLE DEFAULT NULL,
PRIMARY KEY (`id`)
) ;
INSERT INTO `account`(`id`,`name`,`money`) VALUES (1,'tom',1000),
(2,'jerry',1000);

---

②：创建Java项目，导入坐标依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.xuguowen</groupId>
    <artifactId>spring_dbutils</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.37</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.9</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
</project>

---

③：编写Account实体类

package cm.xuguowen.pojo;

/**
 * @author 徐国文
 * @create 2021-10-08 13:51
 * 对应数据库中Account表
 */
public class Account {
    private Integer id;
    private String name;
    private Double money;

    public Account(Integer id, String name, Double money) {
        this.id = id;
        this.name = name;
        this.money = money;
    }

    public Account() {
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

---

④：编写AccountDao接口和实现类

package cm.xuguowen.dao;

import cm.xuguowen.pojo.Account;

import java.util.List;

/**
 * @author 徐国文
 * @create 2021-10-08 14:38
 */
public interface AccountDao {
    /**
     * 查询所有账号信息
     * @return
     */
    List<Account> findAll();

    /**
     * 根据id查询账户信息
     * @param id
     * @return
     */
    Account findById(Integer id);

    /**
     * 保存账户信息
     * @param account
     */
    void save(Account account);

    /**
     * 修改账户信息
     * @param account
     */
    void update(Account account);

    /**
     * 根据id删除账户信息
     * @param id
     */
    void delete(Integer id);
}

package cm.xuguowen.dao.impl;

import cm.xuguowen.dao.AccountDao;
import cm.xuguowen.pojo.Account;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import java.sql.SQLException;
import java.util.List;

/**
 * @author 徐国文
 * @create 2021-10-08 14:39
 */
public class AccountDaoImpl implements AccountDao {
    private QueryRunner queryRunner;
    // 使用set方式注入queryRunner对象，代替了new
    public void setQueryRunner(QueryRunner queryRunner) {
        this.queryRunner = queryRunner;
    }

    /**
     * 查询所有账户信息
     * @return
     */
    public List<Account> findAll() {
        try {
            String sql = "select * from account";
            List<Account> accounts = queryRunner.query(sql, new BeanListHandler<Account>(Account.class));
            return accounts;
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }

    /**
     * 根据id查询账户信息
     * @param id
     * @return
     */
    public Account findById(Integer id) {
        try {
            String sql = "select * from account where id = ?";
            Account account = queryRunner.query(sql, new BeanHandler<Account>(Account.class), id);
            return account;
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }

    /**
     * 保存用户信息
     * @param account
     */
    public void save(Account account) {
        try {
            String sql = "insert into account (name,money) values (?,?)";
            queryRunner.update(sql,account.getName(),account.getMoney());
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    /**
     * 根据id修改账户信息
     * @param account
     */
    public void update(Account account) {
        try {
            String sql = "update account set name = ?,money = ? where id = ?";
            queryRunner.update(sql,account.getName(),account.getMoney(),account.getId());
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    /**
     * 根据id删除账户信息
     * @param id
     */
    public void delete(Integer id) {
        try {
            String sql = "delete from account where id = ?";
            queryRunner.update(sql,id);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}

---

⑤：编写AccountService接口和实现类

package cm.xuguowen.service;

import cm.xuguowen.pojo.Account;

import java.util.List;

/**
 * @author 徐国文
 * @create 2021-10-08 14:39
 */
public interface AccountService {
    /**
     * 查询所有账号信息
     * @return
     */
    List<Account> findAll();

    /**
     * 根据id查询账户信息
     * @param id
     * @return
     */
    Account findById(Integer id);

    /**
     * 保存账户信息
     * @param account
     */
    void save(Account account);

    /**
     * 修改账户信息
     * @param account
     */
    void update(Account account);

    /**
     * 根据id删除账户信息
     * @param id
     */
    void delete(Integer id);
}

package cm.xuguowen.service.impl;

import cm.xuguowen.dao.AccountDao;
import cm.xuguowen.pojo.Account;
import cm.xuguowen.service.AccountService;

import java.util.List;

/**
 * @author 徐国文
 * @create 2021-10-08 14:39
 */
public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    /**
     * 保存所有账户信息
     * @return
     */
    public List<Account> findAll() {
        return accountDao.findAll();
    }

    public Account findById(Integer id) {
        return accountDao.findById(id);
    }

    public void save(Account account) {
        accountDao.save(account);
    }

    public void update(Account account) {
        accountDao.update(account);
    }

    public void delete(Integer id) {
        accountDao.delete(id);
    }
}

---

⑥：编写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"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--把数据库连接池交给IOC容器-->
<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/spring_db">
</property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
<!--把QueryRunner交给IOC容器-->
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
<constructor-arg name="ds" ref="dataSource"></constructor-arg>
</bean>
<!--把AccountDao交给IOC容器-->
<bean id="accountDao" class="cn.xuguowen.dao.impl.AccountDaoImpl">
<property name="queryRunner" ref="queryRunner"></property>
</bean>
<!--把AccountService交给IOC容器-->
<bean id="accountService" class="cn.xuguowen.service.impl.AccountServiceImpl">
<property name="accountDao" ref="accountDao"></property>
</bean>
</beans>

---

⑦：测试

package cn.xuguowen.springtest;

import cm.xuguowen.pojo.Account;
import cm.xuguowen.service.AccountService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

/**
 * @author 徐国文
 * @create 2021-10-08 15:28
 */
public class TestSpringDbUtils {

    ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    AccountService accountService = (AccountService) classPathXmlApplicationContext.getBean("accountService");

    // 测试查询所有
    @Test
    public void testFindAll() {

        List<Account> all = accountService.findAll();
        for (Account account : all) {
            System.out.println(account);
        }
    }

    // 测试查询单个
    @Test
    public void testFindById() {
        Account byId = accountService.findById(1);
        System.out.println(byId);
    }

    // 测试保存账户信息
    @Test
    public void testSave() {
        Account account = new Account();
        account.setName("徐国文");
        account.setMoney(888d);
        accountService.save(account);
    }

    // 测试根据id更新账户信息
    @Test
    public void testUpdate() {
        Account account = new Account();
        account.setName("尼古拉斯·冰冰");
        account.setMoney(2000d);
        account.setId(3);
        accountService.update(account);
    }
    // 测试根据id删除数据
    @Test
    public void testDelete() {
        accountService.delete(3);
    }
}

---

⑧：抽取jdbc.properties文件

applicationContext.xml加载jdbc.properties配置文件获得连接信息。
首先，需要引入context命名空间和约束路径：

* 命名空间：
	xmlns:context="http://www.springframework.org/schema/context"
* 约束路径：
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd

---

然后，在核心配置文件中使用SpEL表达式引入jdbc.properties文件中的信息

	<context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    <!--配置DataSource实例：因为queryRunner中有参构造方法需要一个数据源对象-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <!--name="driverClassName"必须这样写，我写成name="dirver"就出错了-->
        <!--
            在配置数据源属性的时候，发现一个问题：将配置信息jdbc的信息写死了，所以将jdbc的配置信息抽取出来
                1.创建jdbc.properties文件
                2.加载spring核心配置文件的同时加载jdbc.properties文件
        -->
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

---

⑨：知识小结

* DataSource的创建权交由Spring容器去完成
* QueryRunner的创建权交由Spring容器去完成，使用构造方法传递DataSource
* Spring容器加载properties文件
		<context:property-placeholder location="xx.properties"/>
		<property name="" value="${key}"/>

---

七、Spring注解开发

Spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml配置文件可以简化配置，提高开发效率。

1.Spring常用注解

Spring常用注解主要是替代<bean>的配置

注解	说明
@Component	使用在类上用于实例化Bean
@Controller	使用在web层类上用于实体化Bean
@Service	使用在service层类上用户实例化Bean
@Repository	使用在dao层类上用于实例化Bean
@Autowired	使用在字段上用于根据类型依赖注入
@Qualifier	集合@Autowired一起使用，根据名称进行依赖注入
@Resource	相当于@Autowired+@Qualifier,根据名称进行注入
@Value	注入普通属性
@Scope	标注Bean的作用范围
@PostConstruct	使用在方法上标注该方法是Bean的初始化方法
@PreDestory	使用在方法上标注该方法是Bean的销毁方法

---

注意：

• JDK11以后完全移除了javax扩展，导致不能使用@Resource注解，需要引入Maven依赖

<dependency>
	<groupId>javax.annotation</groupId>
	<artifactId>javax.annotation-api</artifactId>
	<version>1.3.2</version>
</dependency>

• 使用注解进行开发时，需要在Spring的核心配置文件中配置注解扫描，作用是指定哪个包以及其子包下的Bean需要进行扫描以便识别使用注解配置的类、方法和字段。

<!--注解的扫描-->
<context:component-scan base-package="cn.xuguowen"></context:component-scan>

---

2.实现

①：Bean实例化（IOC）

<bean id="userDao" class="cn.xuguowen.dao.impl.UserDaoImpl"></bean>

使用@Compont或@Repository标识UserDaoImpl需要Spring进行实例化。

// @Component(value = "userDao")
@Repository // 如果没有写value属性值，Bean的id为：类名首字母小写
public class UserDaoImpl implements UserDao {

}

---

②：属性依赖注入

	<bean id="accountService" class="cm.xuguowen.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
    </bean>

	// 1.根据类型注入;如果SpringIOC容器中存在多个AccountDao实例对象，就会根据属性名二次匹配容器中的Bean实例对象
    // 如果属性名和容器中Bean实例对象的id一样，也会实现依赖注入
    // 如果属性名和容器中Bean实例对象的id不一样，就会报错。此时就需要使用到@Qualifier注解了
    @Autowired
    // 2.现在SpringIOC容器中存在两个AccountDao类型的实例对象，我想将Bean id为accountDao2的实例对象注入到属性中
    @Qualifier("accountDao2")
    // 3.上述两个注解可以用@Resource注解替代，但是需要注意的是jdk11不再支持该注解，需要导入依赖坐标
    //@Resource(name = "accountDao")
    private AccountDao aDao;

---

③：@Vlaue

使用@Value进行字符串的注入，结合SpEL表达式获得配置参数

	// 1.使用@Value注解实现普通数据类型的注入
    @Value("普通数据类型的注入！")
    private String str;
    // 2.使用SpEL表达式获取jdbc.properties配置文件中的值（根据key获取值）
    @Value("${jdbc.driverClassName}")
    private String driver;

---

④：@Scope

使用@Scope标注Bean的范围

@Scope("singleton")
public class AccountServiceImpl implements AccountService {
}

---

⑤：Bean生命周期

<bean init-method="init" destroy-method="destory" />

使用@PostConstruct标注初始化方法，使用@PreDestroy标注销毁方法

	@PostConstruct
    public void init() {
        System.out.println("accountServiceImpl初始化了！");
    }

    @PreDestroy
    public void destory() {
        System.out.println("accountServiceImpl销毁了！");
    }

---

3.Spring常用注解整合DbUtils

①：修改AccounDaoImpl实现类

@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private QueryRunner queryRunner;
}

②：修改AccounServiceImpl实现类

@Service("")
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;
}

③：修改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:p="http://www.springframework.org/schema/p"
       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
">
    <!--配置Spring注解扫描-->
    <context:component-scan base-package="cm.xuguowen"></context:component-scan>

    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    <!--配置DataSource实例：因为queryRunner中有参构造方法需要一个数据源对象-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <!--name="driverClassName"必须这样写，我写成name="dirver"就出错了-->
        <!--
            在配置数据源属性的时候，发现一个问题：将配置信息jdbc的信息写死了，所以将jdbc的配置信息抽取出来
                1.创建jdbc.properties文件
                2.加载spring核心配置文件的同时加载jdbc.properties文件
        -->
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!--配置queryRunner实例-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>

</beans>

④：测试

public class TestSpringDbUtils {

    ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    AccountService accountService = (AccountService) classPathXmlApplicationContext.getBean("accountService");

    // 测试查询所有
    @Test
    public void testFindAll() {

        List<Account> all = accountService.findAll();
        for (Account account : all) {
            System.out.println(account);
        }

    }
}

---

4.Spring新注解

1. 非自定义的Bean的配置：<bean>
2. 加载properties文件的位置：<context:property-placeholder>
3. 组件扫描的配置：<context:component-scan>
4. 引入其他文件：<import>

注解	说明
@Configuration	用于指定当前类是一个Spring配置类，当创建容器时会从该类上加载注解
@Bean	使用在方法上，标注将该方法的返回值存储到Spring容器中
@PropertySource	用于加载properties文件
@ComponentScan	用于指定Spring在初始化容器时要扫描的包
@Import	用于导入其他配置类

---

5.Spring纯注解整合DbUtils

①：编写SpringConfig核心配置类

package cm.xuguowen.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

import javax.sql.DataSource;

/**
 * @author 徐国文
 * @create 2021-10-09 22:35
 * 该类表示Spring的核心配置类
 */
@Configuration  // 该注解作用的类表示该类是Spring的核心配置类
@ComponentScan("cm.xuguowen")       // 该注解的作用：表示开启注解扫描
@PropertySource("classpath:jdbc.properties")    // 该注解表示加载外部的配置文件
public class SpringConfig {
    // 使用value注解将配置文件中的信息设置到各个属性上
    @Value("${jdbc.driverClassName}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    // 如果不指定该注解value的属性值，默认是方法名
    // @Bean使用在方法上，标注将该方法的返回值存储到Spring容器中
    @Bean("dataSource")
    public DataSource getDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }

    @Bean("queryRunner")
    public QueryRunner getQueryRunner(@Autowired DataSource dataSource) {
        QueryRunner queryRunner = new QueryRunner(dataSource);
        return queryRunner;
    }
}

---

②：测试

package cn.xuguowen.springtest;

import cm.xuguowen.config.SpringConfig;
import cm.xuguowen.pojo.Account;
import cm.xuguowen.service.AccountService;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

/**
 * @author 徐国文
 * @create 2021-10-08 15:28
 */
public class TestSpringDbUtils {

    // ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    // AccountService accountService = (AccountService) classPathXmlApplicationContext.getBean("accountService");

    // 使用纯注解的方式测试
    AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
    AccountService accountService = (AccountService) annotationConfigApplicationContext.getBean("accountService");

    // 测试查询所有
    @Test
    public void testFindAll() {

        List<Account> all = accountService.findAll();
        for (Account account : all) {
            System.out.println(account);
        }

    }

    // 测试查询单个
    @Test
    public void testFindById() {
        Account byId = accountService.findById(1);
        System.out.println(byId);
    }

    // 测试保存账户信息
    @Test
    public void testSave() {
        Account account = new Account();
        account.setName("徐国文");
        account.setMoney(888d);
        accountService.save(account);
    }

    // 测试根据id更新账户信息
    @Test
    public void testUpdate() {
        Account account = new Account();
        account.setName("尼古拉斯·冰冰");
        account.setMoney(2000d);
        account.setId(3);
        accountService.update(account);
    }
    // 测试根据id删除数据
    @Test
    public void testDelete() {
        accountService.delete(3);
    }
}

---

③：使用@Import注解导入数据库信息配置类

DataSourceConfig

package cm.xuguowen.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;

import javax.sql.DataSource;

/**
 * @author 徐国文
 * @create 2021-10-09 22:56
 */
@PropertySource("classpath:jdbc.properties")
public class DataSourceConfig {

    // 使用value注解将配置文件中的信息设置到各个属性上
    @Value("${jdbc.driverClassName}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    // 如果不指定该注解value的属性值，默认是方法名
    // @Bean使用在方法上，标注将该方法的返回值存储到Spring容器中
    @Bean("dataSource")
    public DataSource getDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }

}

在SpringConfig核心配置类中引入数据库信息配置类

package cm.xuguowen.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.*;

import javax.sql.DataSource;

/**
 * @author 徐国文
 * @create 2021-10-09 22:35
 * 该类表示Spring的核心配置类
 */
@Configuration  // 该注解作用的类表示该类是Spring的核心配置类
@ComponentScan("cm.xuguowen")       // 该注解的作用：表示开启注解扫描
@PropertySource("classpath:jdbc.properties")    // 该注解表示加载外部的配置文件
@Import(DataSourceConfig.class)         // 导入数据库信息配置类
public class SpringConfig {

    @Bean("queryRunner")
    public QueryRunner getQueryRunner(@Autowired DataSource dataSource) {
        QueryRunner queryRunner = new QueryRunner(dataSource);
        return queryRunner;
    }
}

---

八、Spring整合Junit

1.普通Junit测试问题

在普通测试类中，需要开发者者手动加载配置文件并创建Spring容器，然后通过Spring相关API获得Bean实例；如果不这么做，那么无法从容器中获得对象。

 	ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    AccountService accountService = (AccountService) classPathXmlApplicationContext.getBean("accountService");

我们可以让SpringJunit负责创建Spring容器来简化这个操作，开发者可以直接在测试类中注入Bean实例；但是需要将配置文件的名称告诉它。

2.Spring整合Junit

①：导入spring集成Junit的依赖坐标

		<!--此处需要注意的是，spring5 及以上版本要求 junit 的版本必须是 4.12 及以上-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

②：使用@Runwith注解替换原来的运行器

@RunWith(SpringJUnit4ClassRunner.class)
public class TestSpringDbUtils {
}

③：使用@ContextConfiguration注解指定核心配置文件或者核心配置类

@RunWith(SpringJUnit4ClassRunner.class)
// @ContextConfiguration("classpath:applicationContext.xml")
@ContextConfiguration(classes = SpringConfig.class)
public class TestSpringDbUtils {
}

④：使用@Autowired注解注入需要测试的对象

@RunWith(SpringJUnit4ClassRunner.class)
// @ContextConfiguration("classpath:applicationContext.xml")
@ContextConfiguration(classes = SpringConfig.class)
public class TestSpringDbUtils {
    @Autowired
    private AccountService accountService;
}

⑤：创建测试方法进行测试