Spring 概述

　Spring 是分层的 Java SE/EE 应用 full-stack(全栈式) 轻量级开源框架。
　提供了表现层 SpringMVC 和持久层 Spring JDBC Template 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的 Java EE 企业应用开源框架。
　两大核心：以 IoC（Inverse Of Control：控制反转）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。

发展历程

 1* EJB
 2  	1997 年，IBM提出了EJB 的思想
 3  	1998 年，SUN制定开发标准规范 EJB1.0
 4  	1999 年，EJB1.1 发布
 5  	2001 年，EJB2.0 发布
 6  	2003 年，EJB2.1 发布
 7  	2006 年，EJB3.0 发布
 8
 9* Spring
10  	Rod Johnson（ Spring 之父），改变Java世界的大师级人物
11  	2002年编著《Expert one on one J2EE design and development》
12		指出了JavaEE和EJB组件框架中的存在的一些主要缺陷；提出普通java类依赖注入更为简单的解
13  决方案。
14  	2004年编著《Expert one-on-one J2EE Development without EJB》
15		阐述了JavaEE开发时不使用EJB的解决方式（Spring 雏形），同年4月spring1.0诞生
16  	2006年10月，发布 Spring2.0
17  	2009年12月，发布 Spring3.0
18  	2013年12月，发布 Spring4.0
19  	2017年9月， 发布最新 Spring5.0 通用版（GA）

优势

体系结构

IoC

　控制反转（Inverse Of Control）不是什么技术，而是一种设计思想。它的目的是指导我们设计出更加松耦合的程序。
　　控制：在 Java 中指的是对象的控制权限（创建、销毁）
　　反转：指的是对象控制权由原来由开发者在类中手动控制反转到由 Spring 容器控制

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

传统开发方式 service 层调用 dao 层

1. 创建 Java 项目，导入自定义 IoC 相关坐标

 1<dependency>
 2            <groupId>dom4j</groupId>
 3            <artifactId>dom4j</artifactId>
 4            <version>1.6.1</version>
 5        </dependency>
 6
 7        <dependency>
 8            <groupId>jaxen</groupId>
 9            <artifactId>jaxen</artifactId>
10            <version>1.1.6</version>
11        </dependency>
12
13        <dependency>
14            <groupId>junit</groupId>
15            <artifactId>junit</artifactId>
16            <version>4.12</version>
17        </dependency>

2. 编写 Dao 接口和实现类
   IUserDao

1public interface IUserDao {
2    public void save();
3}

　UserDaoImpl

1public class UserDaoImpl implements IUserDao {
2    @Override
3    public void save() {
4        System.out.println("UserDaoImpl save successfully!");
5    }
6}

3. 编写 Service 接口和实现类
   IUserService

1public interface IUserService {
2    public void save();
3}

　IUserServiceImpl

1public class IUserServiceImpl implements IUserService {
2
3    @Override
4    public void save() {
5        //调用Dao层方法: 传统方式
6        IUserDao userDao = new UserDaoImpl();
7        userDao.save();
8    }
9}

4. 编写测试代码

 1package com.soulboy.test;
 2
 3import com.soulboy.service.IUserService;
 4import com.soulboy.service.impl.IUserServiceImpl;
 5import org.junit.Test;
 6
 7public class SpringTest {
 8    @Test
 9    public void test1(){
10        //获取业务层对象
11        IUserService userService = new IUserServiceImpl();
12
13        //调用save方法
14        userService.save();  //UserDaoImpl save successfully!
15    }
16}

自定义 IoC 容器

问题
　当前 service 对象和 dao 对象耦合度太高，而且每次 new 的都是一个新的对象，导致服务器压力过大。
　解耦合的原则是编译期不依赖，而运行期依赖就行了。

　
5. 编写 beans.xml
　src/main/resources/beans.xml，把所有需要创建对象的信息定义在配置文件中

1<?xml version="1.0" encoding="UTF-8" ?>
2<beans>
3    <bean id="userDao" class="com.soulboy.dao.impl.UserDaoImpl"></bean>
4</beans>

6. BeanFactory 工具类

 1package com.soulboy.utils;
 2
 3import org.dom4j.Document;
 4import org.dom4j.DocumentException;
 5import org.dom4j.Element;
 6import org.dom4j.io.SAXReader;
 7import java.io.InputStream;
 8import java.util.HashMap;
 9import java.util.List;
10import java.util.Map;
11
12public class BeanFactory {
13    private static Map<String, Object> iocmap = new HashMap<>();
14
15    //程序启动时,初始化对象实例
16    static{
17        //1.读取配置文件
18        InputStream resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
19
20        //2.解析xml(dom4j)
21        SAXReader saxReader = new SAXReader();
22        try {
23            Document document = saxReader.read(resourceAsStream);
24            //3.编写xpath表达式
25            String xpath = "//bean";
26            
27            //4.获取到所有的bean标签
28            List<Element> list = document.selectNodes(xpath);
29
30            //5.遍历并使用反射对象实例，存储到map集合(ioc容器)中
31            for (Element element : list) {
32                String id = element.attributeValue("id");
33                //className: "com.soulboy.dao.impl.UserDaoImpl"
34                String className = element.attributeValue("class");
35                //使用反射生成实力对象
36                Object o = Class.forName(className).newInstance();
37                //存到map中  key(id):value(object)
38                iocmap.put(id,o);
39            }
40        } catch (DocumentException e) {
41            throw new RuntimeException(e);
42        } catch (ClassNotFoundException e) {
43            throw new RuntimeException(e);
44        } catch (InstantiationException e) {
45            throw new RuntimeException(e);
46        } catch (IllegalAccessException e) {
47            throw new RuntimeException(e);
48        }
49    }
50
51    public static Object getBean(String beanId) {
52       Object o =  iocmap.get(beanId);
53        return o;
54    }
55}

7. 测试类

 1package com.soulboy.test;
 2
 3import com.soulboy.service.IUserService;
 4import com.soulboy.service.impl.IUserServiceImpl;
 5import org.junit.Test;
 6
 7public class SpringTest {
 8    @Test
 9    public void test1() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
10        //获取业务层对象
11        IUserService userService = new IUserServiceImpl();
12
13        //调用save方法
14        userService.save();
15    }
16}

最终效果

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

快速上手

1. 创建 Java 项目，导入 Spring 开发基本坐标

 1<dependency>
 2            <groupId>org.springframework</groupId>
 3            <artifactId>spring-context</artifactId>
 4            <version>5.1.5.RELEASE</version>
 5        </dependency>
 6        <dependency>
 7            <groupId>junit</groupId>
 8            <artifactId>junit</artifactId>
 9            <version>4.12</version>
10        </dependency>

2. 编写 Dao 接口和实现类
   IUserDao

1public interface IUserDao {
2    public void save();
3}

UserDaoImpl

1public class UserDaoImpl implements IUserDao {
2    @Override
3    public void save() {
4        System.out.println("UserDaoImpl save successfully!");
5    }
6}

3. 创建 Spring 核心配置文件，在 Spring 配置文件中配置 UserDaoImpl
   src/main/resources/applicationContext.xml

 1<?xml version="1.0" encoding="UTF-8"?>
 2<beans xmlns="http://www.springframework.org/schema/beans"
 3       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4       xsi:schemaLocation="http://www.springframework.org/schema/beans
 5http://www.springframework.org/schema/beans/spring-beans.xsd">
 6    <!-- 在spring配置文件中配置 UserDaoImpl
 7        id: 唯一标识
 8        class: 类全路径
 9    -->
10    <bean id="userDao" class="com.soulboy.dao.impl.UserDaoImpl"></bean>
11</beans>

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

 1package com.soulboy.test;
 2
 3import com.soulboy.dao.IUserDao;
 4import org.junit.Test;
 5import org.springframework.context.ApplicationContext;
 6import org.springframework.context.support.ClassPathXmlApplicationContext;
 7
 8public class SpringTest {
 9    @Test
10    public void test1() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
11        //获取到了spring上下文对象，借助上下文对象可以获取IOC容器中的bean对象
12        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
13        //使用上下文对象从IOC容器中获取到了bean对象
14        IUserDao userDao = (IUserDao) applicationContext.getBean("userDao");
15        //调用方法
16        userDao.save();
17    }
18}

Spring 相关 API

API 继承体系结构

BeanFactory

　BeanFactory 是 IoC 容器的核心接口，它定义了 IoC 的基本功能，在第一次调用 getBean()方法时，创建指定对象的实例。

1@Test
2    public void test2() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
3        //获取到了spring上下文对象，借助上下文对象可以获取IOC容器中的bean对象
4        BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
5        //使用上下文对象从IOC容器中获取到了bean对象
6        IUserDao userDao = (IUserDao) beanFactory.getBean("userDao");
7        //调用方法
8        userDao.save();
9    }

ApplicationContext

　代表应用上下文对象，可以获得 Spring 中 IoC 容器的 Bean 对象。特点：在 Spring 容器启动时，加载并创建所有对象的实例
　常用实现类

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

getBean()方法

11. Object getBean(String name);
2	根据Bean的id从容器中获得Bean实例，返回是Object，需要强转。
3
42. <T> T getBean(Class<T> requiredType);
5	根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，则此方法会报错。****
6
73. <T> T getBean(String name,Class<T> requiredType);
8	根据Bean的id和类型获得Bean实例，解决容器中相同类型Bean有多个情况。

Spring 配置文件

bean 标签基本配置

基本属性

1<bean id="" class=""></bean>
2* 用于配置对象交由Spring来创建。
3* 基本属性：
4	id：Bean实例在Spring容器中的唯一标识
5	class：Bean的全限定名
6* 默认情况下它调用的是类中的 无参构造函数，如果没有无参构造函数则不能创建成功

作用域配置

1<bean id="" class="" scope=""></bean>

 11. 当scope的取值为singleton时
 2	Bean的实例化个数：1个
 3	Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例
 4	Bean的生命周期：
 5		对象创建：当应用加载，创建容器时，对象就被创建了
 6		对象运行：只要容器在，对象一直活着
 7		对象销毁：当应用卸载，销毁容器时，对象就被销毁了
 8
 92. 当scope的取值为prototype时
10	Bean的实例化个数：多个
11	Bean的实例化时机：当调用getBean()方法时实例化Bea
12	Bean的生命周期：
13		对象创建：当使用对象时，创建新的对象实例
14		对象运行：只要对象在使用中，就一直活着
15		对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了

测试多例 prototype

 1@Test
 2    public void test3() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
 3        //获取到了spring上下文对象，借助上下文对象可以获取IOC容器中的bean对象
 4        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
 5        //使用上下文对象从IOC容器中获取到了bean对象
 6        IUserDao userDao1 = (IUserDao) applicationContext.getBean("userDao");
 7        IUserDao userDao2 = (IUserDao) applicationContext.getBean("userDao");
 8        //对比对象的地址值
 9        System.out.println(userDao1);//com.soulboy.dao.impl.UserDaoImpl@6f43c82
10        System.out.println(userDao2);com.soulboy.dao.impl.UserDaoImpl@5db6b9cd
11    }

生命周期

配置

1<bean id="userDao" class="com.soulboy.dao.impl.UserDaoImpl" scope="singleton" init-method="init" destroy-method="destory"> </bean>

测试类

 1@Test
 2    public void test3() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
 3        //获取到了spring上下文对象，借助上下文对象可以获取IOC容器中的bean对象
 4        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
 5
 6        //使用上下文对象从IOC容器中获取到了bean对象
 7        IUserDao userDao1 = (IUserDao) applicationContext.getBean("userDao");
 8        IUserDao userDao2 = (IUserDao) applicationContext.getBean("userDao");
 9
10
11        //对比对象的地址值
12        System.out.println(userDao1);//com.soulboy.dao.impl.UserDaoImpl@6f43c82
13        System.out.println(userDao2);//com.soulboy.dao.impl.UserDaoImpl@5db6b9cd
14        
15        //关闭容器
16        applicationContext.close();
17    }

输出

1初始化方法执行了……
2com.soulboy.dao.impl.UserDaoImpl@342c38f8
3com.soulboy.dao.impl.UserDaoImpl@342c38f8
4销毁方法执行了……

bean 实例化的三种方式

无参构造方法实例化
　它会根据默认无参构造方法来创建类对象，如果 bean 中没有默认无参构造函数，将会创建失败

<bean id="userDao" class="com.soulboy.dao.impl.UserDaoImpl"/>

工厂静态方法实例化
　应用场景：依赖的 jar 包中有个 A 类，A 类中有个静态方法 m1，m1 方法的返回值是一个 B 对象。如果我们频繁使用 B 对象，此时我们可以将 B 对象的创建权交给 Spring 的 IoC 容器，以后我们在使用 B 对象时，无需调用 A 类中的 m1 方法，直接从 IoC 容器获得。

StaticFactoryBean

1public class StaticFactoryBean {
2	public static UserDao createUserDao(){
3		return new UserDaoImpl();
4	}
5}

applicationContext.xml

1<bean id="userDao" class="com.lagou.factory.StaticFactoryBean" factory-method="createUserDao" />

工厂普通方法实例化
　应用场景：依赖的 jar 包中有个 A 类，A 类中有个普通方法 m1，m1 方法的返回值是一个 B 对象。如果我们频繁使用
B 对象，此时我们可以将 B 对象的创建权交给 Spring 的 IoC 容器，以后我们在使用 B 对象时，无需调用 A 类中的 m1 方法，直接从 IoC 容器获得。

DynamicFactoryBean

1public class DynamicFactoryBean {
2	public UserDao createUserDao(){
3		return new UserDaoImpl();
4	}
5}

applicationContext.xml

1<bean id="dynamicFactoryBean" class="com.lagou.factory.DynamicFactoryBean"/>
2<bean id="userDao" factory-bean="dynamicFactoryBean" factory-method="createUserDao"/>

依赖注入

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

依赖注入的方式

构造方法注入

applicationContext.xml

1<bean id="userDao" class="com.soulboy.dao.impl.UserDaoImpl"> </bean>
2    <bean id="userService" class="com.soulboy.service.impl.UserServiceImpl">
3       <!-- <constructor-arg index="0" type="com.soulboy.dao.IUserDao" ref="userDao"/>-->
4        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
5    </bean>

UserDaoImpl

1public class UserDaoImpl implements IUserDao {
2    @Override
3    public void save() {
4        System.out.println("UserDaoImpl save successfully!");
5    }
6}

UserServiceImpl

 1public class UserServiceImpl implements IUserService {
 2    private IUserDao userDao;
 3
 4    public UserServiceImpl(IUserDao userDao) {
 5        this.userDao = userDao;
 6    }
 7
 8    @Override
 9    public void save() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
10        //调用目标方法
11        userDao.save();
12    }
13}

测试类

 1/**
 2     * DI:构造方法注入
 3     */
 4    @Test
 5    public void test4() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
 6        //获取到了spring上下文对象，借助上下文对象可以获取IOC容器中的bean对象
 7        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
 8        //使用上下文对象从IOC容器中获取到了bean对象
 9        IUserService userService = (IUserService) applicationContext.getBean("userService");
10        //调用方法
11        userService.save();
12    }

set 方法注入

applicationContext.xml

1<bean id="userDao" class="com.soulboy.dao.impl.UserDaoImpl"> </bean>
2    <bean id="userService" class="com.soulboy.service.impl.UserServiceImpl">
3        <!-- <constructor-arg index="0" type="com.soulboy.dao.IUserDao" ref="userDao"/>-->
4        <!-- <constructor-arg name="userDao" ref="userDao"></constructor-arg> -->
5        <!-- set方法完成依赖注入 -->
6        <property name="userDao" ref="userDao"></property>
7    </bean>

UserDaoImpl

1public class UserDaoImpl implements IUserDao {
2    @Override
3    public void save() {
4        System.out.println("UserDaoImpl save successfully!");
5    }
6}

UserServiceImpl

 1public class UserServiceImpl implements IUserService {
 2    private IUserDao userDao;
 3
 4    public IUserDao getUserDao() {
 5        return userDao;
 6    }
 7
 8    public void setUserDao(IUserDao userDao) {
 9        this.userDao = userDao;
10    }
11
12    @Override
13    public void save() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
14        //调用目标方法
15        userDao.save();
16    }
17}

测试类

 1/**
 2     * DI:set方法注入
 3     */
 4    @Test
 5    public void test4() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
 6        //获取到了spring上下文对象，借助上下文对象可以获取IOC容器中的bean对象
 7        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
 8        //使用上下文对象从IOC容器中获取到了bean对象
 9        IUserService userService = (IUserService) applicationContext.getBean("userService");
10        //调用方法
11        userService.save();
12    }

P 命名空间注入

　命名空间注入本质也是 set 方法注入，但比起上述的 set 方法注入更加方便，主要体现在配置文件中，如下：
　首先，需要引入 P 命名空间：
　xmlns:p="http://www.springframework.org/schema/p"
　其次，需要修改注入方式：

1<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/>
2<bean id="userService" class="com.lagou.service.impl.UserServiceImpl" p:userDao-ref="userDao"/>

依赖注入的数据类型

注入普通数据类型

applicationContext.xml

1<bean id="student" class="com.soulboy.domain.Student">
2        <!-- value普通数据类型的注入, ref引用数据类型的注入 -->
3        <property name="age" value="18"/>
4        <property name="username" value="高中美"/>
5    </bean>

student

 1public class Student {
 2    private String username;
 3    private Integer age;
 4
 5    public void setUsername(String username) {
 6        this.username = username;
 7    }
 8
 9    public void setAge(Integer age) {
10        this.age = age;
11    }
12
13    @Override
14    public String toString() {
15        return "Student{" +
16                "username='" + username + '\'' +
17                ", age=" + age +
18                '}';
19    }
20}

测试类

 1/**
 2     * DI:注入普通数据类型
 3     */
 4    @Test
 5    public void test5() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
 6        //获取到了spring上下文对象，借助上下文对象可以获取IOC容器中的bean对象
 7        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
 8        //使用上下文对象从IOC容器中获取到了bean对象
 9        Student student = applicationContext.getBean("student", Student.class);
10        System.out.println(student);//Student{username='高中美', age=18}
11    }

List 集合注入

applicationContext.xml

 1<bean id="user" class="com.soulboy.domain.User">
 2        <property name="name" value="妞妞"></property>
 3        <property name="age" value="28"></property>
 4    </bean>
 5    <bean id="student" class="com.soulboy.domain.Student">
 6        <!-- value普通数据类型的注入, ref引用数据类型的注入 -->
 7        <property name="age" value="18"/>
 8        <property name="username" value="高中美"/>
 9        <!-- List集合数据类型注入-->
10        <property name="list">
11            <list>
12                <value>aaa</value><!-- 注入普通数据类型字符串 -->
13                <ref bean="user"></ref>
14            </list>
15        </property>
16    </bean>

Student

1private List<Object> list;

Set 集合注入

applicationContext.xml

 1<bean id="user" class="com.soulboy.domain.User">
 2        <property name="name" value="妞妞"></property>
 3        <property name="age" value="28"></property>
 4    </bean>
 5    <bean id="student" class="com.soulboy.domain.Student">
 6        <!-- value普通数据类型的注入, ref引用数据类型的注入 -->
 7        <property name="age" value="18"/>
 8        <property name="username" value="高中美"/>
 9        <!-- Set集合数据类型注入-->
10        <property name="set">
11             <set>
12                 <value>aaa</value><!-- 注入普通数据类型字符串 -->
13                 <ref bean="user"></ref>
14             </set>
15        </property>
16    </bean>

Student

1private Set<Object> set;

Array 数组类型注入

applicationContext.xml

 1<bean id="user" class="com.soulboy.domain.User">
 2        <property name="name" value="妞妞"></property>
 3        <property name="age" value="28"></property>
 4    </bean>
 5    <bean id="student" class="com.soulboy.domain.Student">
 6        <!-- value普通数据类型的注入, ref引用数据类型的注入 -->
 7        <property name="age" value="18"/>
 8        <property name="username" value="高中美"/>
 9        <!-- Array数组数据类型注入-->
10        <property name="array">
11            <array>
12                <value>aaa</value><!-- 注入普通数据类型字符串 -->
13                <ref bean="user"></ref>
14            </array>
15        </property>
16    </bean>

Student

1private Object[] array;

Map 类型注入

applicationContext.xml

 1<bean id="user" class="com.soulboy.domain.User">
 2        <property name="name" value="妞妞"></property>
 3        <property name="age" value="28"></property>
 4    </bean>
 5    <bean id="student" class="com.soulboy.domain.Student">
 6        <!-- value普通数据类型的注入, ref引用数据类型的注入 -->
 7        <property name="age" value="18"/>
 8        <property name="username" value="高中美"/>
 9        <!-- Map类型注入-->
10        <property name="map">
11            <map>
12                <entry key="k1" value="ddd"></entry>
13                <entry key="k2" value-ref="user"></entry>
14            </map>
15        </property>
16    </bean>

Student

1private Map<String, Object> map;

Properties 类型注入

properties.xml

 1<bean id="user" class="com.soulboy.domain.User">
 2        <property name="name" value="妞妞"></property>
 3        <property name="age" value="28"></property>
 4    </bean>
 5    <bean id="student" class="com.soulboy.domain.Student">
 6        <!-- value普通数据类型的注入, ref引用数据类型的注入 -->
 7        <property name="age" value="18"/>
 8        <property name="username" value="高中美"/>
 9        <!-- Properties类型注入-->
10        <property name="properties">
11            <props>
12              <prop key="k1">v1</prop>
13              <prop key="k2">v2</prop>
14              <prop key="k3">v3</prop>
15            </props>
16        </property>
17    </bean>

student

1private Properties properties;

配置文件模块化

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

并列的多个配置文件
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("beans1.xml","beans2.xml","...");

主从配置文件
<import resource="applicationContext-xxx.xml"/>
注意：

• 同一个 XML 中不能出现相同名称的 bean,如果出现会报错
• 多个 XML 如果出现相同名称的 bean，不会报错，但是后加载的会覆盖前加载的 bean

Spring 的 XML 整合 DbUtils

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

核心对象
QueryRunner queryRunner = new QueryRunner(DataSource dataSource);

核心方法

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

举例
　查询数据库所有账户信息到 Account 实体中

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

基于 Spring 的 XML 配置实现账户的 CRUD 案例

　步骤分析：

11. 准备数据库环境
22. 创建java项目，导入坐标
33. 编写Account实体类
44. 编写AccountDao接口和实现类
55. 编写AccountService接口和实现类
66. 编写spring核心配置文件
77. 编写测试代码

准备数据库环境

 1CREATE DATABASE `spring_db`;
 2USE `spring_db`;
 3CREATE TABLE `account` (
 4`id` int(11) NOT NULL AUTO_INCREMENT,
 5`name` varchar(32) DEFAULT NULL,
 6`money` double DEFAULT NULL,
 7PRIMARY KEY (`id`)
 8) ;
 9insert into `account`(`id`,`name`,`money`) values (1,'tom',1000),
10(2,'jerry',1000);

创建 Java 项目，导入坐标

 1<!--指定编码及版本-->
 2    <properties>
 3        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 4        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
 5        <java.version>11</java.version>
 6        <maven.compiler.source>11</maven.compiler.source>
 7        <maven.compiler.target>11</maven.compiler.target>
 8    </properties>
 9
10    <dependencies>
11        <dependency>
12            <groupId>mysql</groupId>
13            <artifactId>mysql-connector-java</artifactId>
14            <version>5.1.47</version>
15        </dependency>
16        <dependency>
17            <groupId>com.alibaba</groupId>
18            <artifactId>druid</artifactId>
19            <version>1.1.9</version>
20        </dependency>
21        <dependency>
22            <groupId>commons-dbutils</groupId>
23            <artifactId>commons-dbutils</artifactId>
24            <version>1.6</version>
25        </dependency>
26        <dependency>
27            <groupId>org.springframework</groupId>
28            <artifactId>spring-context</artifactId>
29            <version>5.1.5.RELEASE</version>
30        </dependency>
31        <dependency>
32            <groupId>junit</groupId>
33            <artifactId>junit</artifactId>
34            <version>4.12</version>
35        </dependency>
36    </dependencies>

Account 实体类

 1public class Account {
 2    private Integer id;
 3    private String name;
 4    private Double money;
 5
 6    public Integer getId() {
 7        return id;
 8    }
 9
10    public void setId(Integer id) {
11        this.id = id;
12    }
13
14    public String getName() {
15        return name;
16    }
17
18    public void setName(String name) {
19        this.name = name;
20    }
21
22    public Double getMoney() {
23        return money;
24    }
25
26    public void setMoney(Double money) {
27        this.money = money;
28    }
29
30    @Override
31    public String toString() {
32        return "Account{" +
33                "id=" + id +
34                ", name='" + name + '\'' +
35                ", money=" + money +
36                '}';
37    }
38}

编写 AccountDao 接口和实现类

AccountDao

1public interface AccountDao {
2    public List<Account> findAll();
3    public Account findById(Integer id);
4    public void save(Account account);
5    public void update(Account account);
6    public void delete(Integer id);
7}

AccountDaoImpl

 1public class AccountDaoImpl implements AccountDao {
 2
 3    private QueryRunner queryRunner;
 4
 5    public void setQueryRunner(QueryRunner queryRunner) {
 6        this.queryRunner = queryRunner;
 7    }
 8
 9    /**
10     * 查询所有记录
11     * @return List<Account>
12     */
13    @Override
14    public List<Account> findAll() {
15        List<Account> list = null;
16        //编写sql
17        String sql = "select * from account";
18        try{
19            //执行sql
20            list = queryRunner.query(sql, new BeanListHandler<Account>(Account.class));
21        } catch (SQLException e) {
22            throw new RuntimeException(e);
23        }
24        return list;
25    }
26
27    /**
28     * 通过id查询
29     * @return Account
30     */
31    @Override
32    public Account findById(Integer id) {
33        Account account = null;
34        String sql = "select * from account where id = ?";
35        try {
36            account = queryRunner.query(sql, new BeanHandler<Account>(Account.class),id);
37        } catch (SQLException e) {
38            e.printStackTrace();
39        }
40        return account;
41    }
42
43    /**
44     * 添加记录
45     * @return
46     */
47    @Override
48    public void save(Account account) {
49        String sql = "insert into account values(null,?,?)";
50        try {
51            queryRunner.update(sql, account.getName(), account.getMoney());
52        } catch (SQLException e) {
53            e.printStackTrace();
54        }
55    }
56
57    /**
58     * 更新记录
59     * @return
60     */
61    @Override
62    public void update(Account account) {
63        String sql = "update account set name = ?,money = ? where id = ?";
64        try {
65            queryRunner.update(sql, account.getName(), account.getMoney(), account.getId());
66        } catch (SQLException e) {
67            e.printStackTrace();
68        }
69    }
70
71    /**
72     * 删除记录
73     * @return
74     */
75    @Override
76    public void delete(Integer id) {
77        String sql = "delete from account where id = ?";
78        try {
79            queryRunner.update(sql, id);
80        } catch (SQLException e) {
81            e.printStackTrace();
82        }
83    }
84}

编写 AccountService 接口和实现类
AccountService

1public interface AccountService {
2    public List<Account> findAll();
3    public Account findById(Integer id);
4    public void save(Account account);
5    public void update(Account account);
6    public void delete(Integer id);
7}

AccountServiceImpl

 1public class AccountServiceImpl implements AccountService {
 2
 3    private AccountDao accountDao;
 4
 5    public void setAccountDao(AccountDao accountDao) {
 6        this.accountDao = accountDao;
 7    }
 8
 9    @Override
10    public List<Account> findAll() {
11        return accountDao.findAll();
12    }
13
14    @Override
15    public Account findById(Integer id) {
16        return accountDao.findById(id);
17    }
18
19    @Override
20    public void save(Account account) {
21        accountDao.save(account);
22    }
23
24    @Override
25    public void update(Account account) {
26        accountDao.update(account);
27    }
28
29    @Override
30    public void delete(Integer id) {
31        accountDao.delete(id);
32    }
33}

编写 Spring 核心配置文件
applicationContext.xml

 1<?xml version="1.0" encoding="UTF-8"?>
 2<beans xmlns="http://www.springframework.org/schema/beans"
 3       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4       xmlns:context="http://www.springframework.org/schema/context"
 5       xsi:schemaLocation="
 6                http://www.springframework.org/schema/beans
 7                http://www.springframework.org/schema/beans/spring-beans.xsd
 8                http://www.springframework.org/schema/context
 9                http://www.springframework.org/schema/context/spring-context.xsd
10">
11    <!--加载jdbc.properties文件-->
12    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
13    <!--在DruidDataSource连接池中设置dataSource-->
14    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
15        <property name="driverClassName" value="${jdbc.driverClassName}"></property>
16        <property name="url" value="${jdbc.url}"></property>
17        <property name="username" value="${jdbc.username}"></property>
18        <property name="password" value="${jdbc.password}"></property>
19    </bean>
20    <!--把数据库连接池交给IOC容器-->
21    <!--<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
22        <property name="driverClassName" value="com.mysql.jdbc.Driver">
23        </property>
24        <property name="url" value="jdbc:mysql://localhost:50000/spring_db">
25        </property>
26        <property name="username" value="root"></property>
27        <property name="password" value="123456"></property>
28    </bean>-->
29    <!-- QueryRunner: 利用有参构造函数注入dataSource -->
30    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
31        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
32    </bean>
33    <!--AccountDao: AccountDaoImpl的queryRunner属性需要注入-->
34    <bean id="accountDao" class="com.soulboy.dao.impl.AccountDaoImpl">
35        <property name="queryRunner" ref="queryRunner"></property>
36    </bean>
37    <!--AccountService: AccountServiceImpl的accountDao属性需要注入-->
38    <bean id="accountService" class="com.soulboy.service.impl.AccountServiceImpl">
39        <property name="accountDao" ref="accountDao"></property>
40    </bean>
41</beans>

编写 properties 文件
src/main/resources/jdbc.properties

1jdbc.driverClassName=com.mysql.jdbc.Driver
2jdbc.url=jdbc:mysql://localhost:50000/spring_db
3jdbc.username=root
4jdbc.password=123456

编写测试代码
AccountServiceTest

 1package com.soulboy.test;
 2
 3import com.soulboy.domain.Account;
 4import com.soulboy.service.AccountService;
 5import org.junit.Test;
 6import org.springframework.context.ApplicationContext;
 7import org.springframework.context.support.ClassPathXmlApplicationContext;
 8import java.util.List;
 9
10public class AccountServiceTest {
11    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
12    AccountService accountService = applicationContext.getBean(AccountService.class);
13
14    /**
15     * 测试保存
16     */
17    @Test
18    public void testSave(){
19        Account account = new Account();
20        account.setName("高中美");
21        account.setMoney(100d);
22        accountService.save(account);
23    }
24
25    /**
26     * 测试基于id查询
27     */
28    @Test
29    public void testFindById(){
30        Account account = accountService.findById(3);
31        System.out.println(account);
32    }
33
34    /**
35     * 测试查询所有
36     */
37    @Test
38    public void testFindAll(){
39        List<Account> accounts = accountService.findAll();
40        for (Account account : accounts) {
41            System.out.println(account);
42        }
43    }
44
45    /**
46     * 测试更新记录
47     */
48    @Test
49    public void testUpdateById(){
50        Account account = new Account();
51        account.setId(1);
52        account.setName("妞妞");
53        account.setMoney(20000D);
54        accountService.update(account);
55    }
56
57    /**
58     * 测试删除(基于id)
59     */
60    @Test
61    public void testDeleteById(){
62        accountService.delete(2);
63    }
64}

总结

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

注解开发

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

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

1<dependency>
2	<groupId>javax.annotation</groupId>
3	<artifactId>javax.annotation-api</artifactId>
4	<version>1.3.2</version>
5</dependency>

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

applicationContext.xml

1<!--注解的组件扫描-->
2    <context:component-scan base-package="com.soulboy"></context:component-scan>

基于注解整合 Dbutils

核心配置文件

 1<?xml version="1.0" encoding="UTF-8"?>
 2<beans xmlns="http://www.springframework.org/schema/beans"
 3       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4       xmlns:context="http://www.springframework.org/schema/context"
 5       xsi:schemaLocation="
 6                http://www.springframework.org/schema/beans
 7                http://www.springframework.org/schema/beans/spring-beans.xsd
 8                http://www.springframework.org/schema/context
 9                http://www.springframework.org/schema/context/spring-context.xsd
10">
11    <!--注解的组件扫描-->
12    <context:component-scan base-package="com.soulboy"></context:component-scan>
13    <!--加载jdbc.properties文件-->
14    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
15    <!--在DruidDataSource连接池中设置dataSource-->
16    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
17        <property name="driverClassName" value="${jdbc.driverClassName}"></property>
18        <property name="url" value="${jdbc.url}"></property>
19        <property name="username" value="${jdbc.username}"></property>
20        <property name="password" value="${jdbc.password}"></property>
21    </bean>
22    <!--QueryRunner-->
23    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
24        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
25    </bean>
26</beans>

DAO

 1package com.soulboy.dao.impl;
 2
 3import com.soulboy.dao.AccountDao;
 4import com.soulboy.domain.Account;
 5import org.apache.commons.dbutils.QueryRunner;
 6import org.apache.commons.dbutils.handlers.BeanHandler;
 7import org.apache.commons.dbutils.handlers.BeanListHandler;
 8import org.springframework.beans.factory.annotation.Autowired;
 9import org.springframework.stereotype.Repository;
10
11import java.sql.SQLException;
12import java.util.List;
13
14@Repository("accountDao")
15public class AccountDaoImpl implements AccountDao {
16
17    @Autowired
18    private QueryRunner queryRunner;
19
20    public void setQueryRunner(QueryRunner queryRunner) {
21        this.queryRunner = queryRunner;
22    }
23
24    /**
25     * 查询所有记录
26     * @return List<Account>
27     */
28    @Override
29    public List<Account> findAll() {
30        List<Account> list = null;
31        //编写sql
32        String sql = "select * from account";
33        try{
34            //执行sql
35            list = queryRunner.query(sql, new BeanListHandler<Account>(Account.class));
36        } catch (SQLException e) {
37            throw new RuntimeException(e);
38        }
39        return list;
40    }
41
42    /**
43     * 通过id查询
44     * @return Account
45     */
46    @Override
47    public Account findById(Integer id) {
48        Account account = null;
49        String sql = "select * from account where id = ?";
50        try {
51            account = queryRunner.query(sql, new BeanHandler<Account>(Account.class),id);
52        } catch (SQLException e) {
53            e.printStackTrace();
54        }
55        return account;
56    }
57
58    /**
59     * 添加记录
60     * @return
61     */
62    @Override
63    public void save(Account account) {
64        String sql = "insert into account values(null,?,?)";
65        try {
66            queryRunner.update(sql, account.getName(), account.getMoney());
67        } catch (SQLException e) {
68            e.printStackTrace();
69        }
70    }
71
72    /**
73     * 更新记录
74     * @return
75     */
76    @Override
77    public void update(Account account) {
78        String sql = "update account set name = ?,money = ? where id = ?";
79        try {
80            queryRunner.update(sql, account.getName(), account.getMoney(), account.getId());
81        } catch (SQLException e) {
82            e.printStackTrace();
83        }
84    }
85
86    /**
87     * 删除记录
88     * @return
89     */
90    @Override
91    public void delete(Integer id) {
92        String sql = "delete from account where id = ?";
93        try {
94            queryRunner.update(sql, id);
95        } catch (SQLException e) {
96            e.printStackTrace();
97        }
98    }
99}

Service

 1package com.soulboy.service.impl;
 2
 3import com.soulboy.dao.AccountDao;
 4import com.soulboy.domain.Account;
 5import com.soulboy.service.AccountService;
 6import org.springframework.beans.factory.annotation.Autowired;
 7import org.springframework.beans.factory.annotation.Qualifier;
 8import org.springframework.beans.factory.annotation.Value;
 9import org.springframework.stereotype.Service;
10
11import java.util.List;
12@Service("accountService")
13public class AccountServiceImpl implements AccountService {
14
15    @Autowired
16    @Qualifier("accountDao")
17    private AccountDao accountDao;
18
19    @Value("注入普通属性")
20    private String str;
21
22    @Value("${jdbc.driverClassName}")
23    private String driver;
24
25
26    @Override
27    public List<Account> findAll() {
28        System.out.println(str);//注入普通属性
29        System.out.println(driver);//com.mysql.jdbc.Driver
30        return accountDao.findAll();
31    }
32
33    @Override
34    public Account findById(Integer id) {
35        return accountDao.findById(id);
36    }
37
38    @Override
39    public void save(Account account) {
40        accountDao.save(account);
41    }
42
43    @Override
44    public void update(Account account) {
45        accountDao.update(account);
46    }
47
48    @Override
49    public void delete(Integer id) {
50        accountDao.delete(id);
51    }
52}

测试类

 1package com.soulboy.test;
 2
 3import com.soulboy.domain.Account;
 4import com.soulboy.service.AccountService;
 5import org.junit.Test;
 6import org.springframework.context.ApplicationContext;
 7import org.springframework.context.support.ClassPathXmlApplicationContext;
 8
 9import java.util.List;
10
11public class AccountServiceTest {
12    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
13    AccountService accountService = applicationContext.getBean(AccountService.class);
14
15    /**
16     * 测试保存
17     */
18    @Test
19    public void testSave(){
20        Account account = new Account();
21        account.setName("高中美");
22        account.setMoney(100d);
23        accountService.save(account);
24    }
25
26    /**
27     * 测试基于id查询
28     */
29    @Test
30    public void testFindById(){
31        Account account = accountService.findById(3);
32        System.out.println(account);
33    }
34
35    /**
36     * 测试查询所有
37     */
38    @Test
39    public void testFindAll(){
40        List<Account> accounts = accountService.findAll();
41        for (Account account : accounts) {
42            System.out.println(account);
43        }
44    }
45
46    /**
47     * 测试更新记录
48     */
49    @Test
50    public void testUpdateById(){
51        Account account = new Account();
52        account.setId(1);
53        account.setName("妞妞");
54        account.setMoney(20000D);
55        accountService.update(account);
56    }
57
58    /**
59     * 测试删除(基于id)
60     */
61    @Test
62    public void testDeleteById(){
63        accountService.delete(2);
64    }
65}

Spring 纯注解整合 Dbutils

　使用上面的注解还不能全部替代 XML 配置文件，还需要使用注解替代的配置如下：

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

步骤分析

1. 编写 Spring 核心配置类
   SpringConfig

 1package com.soulboy.config;
 2
 3import org.apache.commons.dbutils.QueryRunner;
 4import org.springframework.beans.factory.annotation.Autowired;
 5import org.springframework.context.annotation.*;
 6
 7import javax.sql.DataSource;
 8
 9@Configuration
10@ComponentScan("com.soulboy")
11@Import(DataSourceConfig.class)
12public class SpringConfig {
13    @Bean("queryRunner")
14    public QueryRunner getQueryRunner(@Autowired DataSource dataSource) {
15        QueryRunner queryRunner = new QueryRunner(dataSource);
16        return queryRunner;
17    }
18}

2. 编写数据库配置信息类
   DataSourceConfig

 1package com.soulboy.config;
 2
 3import com.alibaba.druid.pool.DruidDataSource;
 4import org.springframework.beans.factory.annotation.Value;
 5import org.springframework.context.annotation.Bean;
 6import org.springframework.context.annotation.PropertySource;
 7
 8import javax.sql.DataSource;
 9
10@PropertySource("classpath:jdbc.properties")
11public class DataSourceConfig {
12    @Value("${jdbc.driverClassName}")
13    private String driver;
14    @Value("${jdbc.url}")
15    private String url;
16    @Value("${jdbc.username}")
17    private String username;
18    @Value("${jdbc.password}")
19    private String password;
20
21    @Bean("dataSource")
22    public DataSource getDataSource(){
23        DruidDataSource druidDataSource = new DruidDataSource();
24        druidDataSource.setDriverClassName(driver);
25        druidDataSource.setUrl(url);
26        druidDataSource.setUsername(username);
27        druidDataSource.setPassword(password);
28        return druidDataSource;
29    }
30}

3. 编写测试代码
   AccountServiceTest

 1package com.soulboy.test;
 2
 3import com.soulboy.config.SpringConfig;
 4import com.soulboy.domain.Account;
 5import com.soulboy.service.AccountService;
 6import org.junit.Test;
 7import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 8import java.util.List;
 9
10public class AccountServiceTest {
11    //ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
12    //ccountService accountService = applicationContext.getBean(AccountService.class);
13
14    // 纯注解形式
15    AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
16    AccountService accountService = (AccountService)annotationConfigApplicationContext.getBean("accountService");
17    
18    /**
19     * 测试保存
20     */
21    @Test
22    public void testSave() {
23        Account account = new Account();
24        account.setName("高中美");
25        account.setMoney(100d);
26        accountService.save(account);
27    }
28
29    /**
30     * 测试基于id查询
31     */
32    @Test
33    public void testFindById() {
34        Account account = accountService.findById(3);
35        System.out.println(account);
36    }
37
38    /**
39     * 测试查询所有
40     */
41    @Test
42    public void testFindAll() {
43        List<Account> accounts = accountService.findAll();
44        for (Account account : accounts) {
45            System.out.println(account);
46        }
47    }
48
49    /**
50     * 测试更新记录
51     */
52    @Test
53    public void testUpdateById() {
54        Account account = new Account();
55        account.setId(1);
56        account.setName("妞妞");
57        account.setMoney(20000D);
58        accountService.update(account);
59    }
60
61    /**
62     * 测试删除(基于id)
63     */
64    @Test
65    public void testDeleteById() {
66        accountService.delete(2);
67    }
68}