Spring全栈式轻量级开源框架①

最新推荐文章于 2024-09-28 07:46:28 发布

Iliuhu

最新推荐文章于 2024-09-28 07:46:28 发布

阅读量351

点赞数

分类专栏：框架文章标签： spring

本文链接：https://blog.csdn.net/liu_to_liu/article/details/118092065

版权

框架专栏收录该内容

13 篇文章 0 订阅

订阅专栏

Spring全栈式轻量级开源框架之Spring IOC

一 Spring概述
二初识IOC
三 Spring快速入门
四 Spring相关API
五 Spring配置文件
六 DbUtils（IOC实战）
七 Spring注解开发
八 Spring整合Junit

一 Spring概述

1.1 Spring是什么

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

在这里插入图片描述

1.2 Spring发展历程

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

1.3 Spring优势

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

在这里插入图片描述

package com.myProject.test;

import org.junit.Test;

import java.sql.*;

public class JDBCTest {
    @Test
    public void test() throws SQLException, ClassNotFoundException {
        // 注册驱动 new存在编译依赖：耦合重的体现
//        DriverManager.registerDriver(new com.mysql.jdbc.Driver());

        // 在没有引入spring框架，常用的注册驱动方法，解决了编译器依赖，但没有解决运行期依赖
        Class.forName("com.mysql.jdbc.Driver");
        
        // 获取连接
        Connection connection = DriverManager.getConnection("jdbc:mysql:///mybatis_db","root","root");

        // 定义sql
        String sql = "select * from user";

        // 获取预编译
        PreparedStatement preparedStatement = connection.prepareStatement(sql);

        // 执行sql,得到结果
        ResultSet resultSet = preparedStatement.executeQuery();

        // 遍历结果
        while (resultSet.next()) {
            System.out.println(resultSet.getString("username"));
        }
    }
}

1.4 Spring体系结构

在这里插入图片描述

二初识IOC

2.1 概述

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

控制：在java中指的是对象的控制权限（创建、销毁）

反转：指的是对象控制权由原来 由开发者在类中手动控制 反转到 由Spring容器控制

举个栗子

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

在这里插入图片描述

2.2 自定义IOC容器

2.2.1 介绍

需求

实现service层与dao层代码解耦合

步骤分析

1. 创建java项目，导入自定义IOC相关坐标
2. 编写Dao接口和实现类
3. 编写Service接口和实现类
4. 编写测试代码

2.2.2 实现

1）创建java项目，向pom.xml引入依赖

<?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>com.myProject</groupId>
    <artifactId>jdbc_spring</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--指定编码和版本-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
        <java.version>1.8</java.version>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <!--引入相关依赖-->
    <dependencies>
        <!--引入mybatis依赖-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.4</version>
        </dependency>
        <!--引入mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!--引入junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.7</version>
        </dependency>
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.1.6</version>
        </dependency>
    </dependencies>
</project>

2）编写Dao接口和实现类

package com.myProject.dao;

public interface IUserDao {
    public void save();
}

package com.myProject.dao.impl;

import com.myProject.dao.IUserDao;

public class IUserDaoImpl implements IUserDao {
    @Override
    public void save() {
        System.out.println("到被调用了，保存成功");
    }
}

3）编写Service接口和实现类

package com.myProject.service;

public interface IUserService {
    public void save() throws ClassNotFoundException, InstantiationException, IllegalAccessException;
}

package com.myProject.service.impl;

import com.myProject.dao.IUserDao;
import com.myProject.dao.impl.IUserDaoImpl;
import com.myProject.service.IUserService;

public class IUserServiceImpl implements IUserService {
    @Override
    public void save() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        // 调用dao层方法 使用传统方式实现: 存在编译期依赖；耦合重
//        IUserDao userDao = new IUserDaoImpl();

        // 反射 会出先硬编码问题，是"com.myProject.dao.impl.IUserDaoImpl"引起的
//        IUserDao userDao  = (IUserDao) Class.forName("com.myProject.dao.impl.IUserDaoImpl").newInstance();

        IUserDao userDao = (IUserDao) BeanFactory.getBean("userDao");
        userDao.save();
    }
}

4）编写测试代码

package com.myProject.test;

import com.myProject.service.IUserService;
import com.myProject.service.impl.IUserServiceImpl;
import org.junit.Test;

public class SpringTest {
    @Test
    public void test1() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        // 获取业务层对象
        IUserService iUserService = new IUserServiceImpl();

        // 调用save方法
        iUserService.save();
    }
}

5）问题

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

解耦合的原则是编译期不依赖，而运行期依赖就行了。

6) 编写beans.xml

把所有需要创建对象的信息定义在配置文件中

<?xml version="1.0" encoding="UTF-8" ?>
<beans>
	<bean id="userDao" class="com.myProject.dao.impl.IUserDaoImpl"></bean>
</beans>

7）编写BeanFactory工具类

package com.utils;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

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

    // 程序启动时，初始化对象实例
    static {
        // 1.读取配置文件
        InputStream inputStream = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");

        // 2.解析xml
        SAXReader saxReader = new SAXReader();
        try {
            Document document = saxReader.read(inputStream);
            // 3.编写xpath
            String xpath = "//bean";

            // 4.获取所有的bean标签
            List<Element> list = document.selectNodes(xpath);

            // 5.遍历并使用反射创建对象实例，存到map集合中（IOC容器）中
            for (Element element : list) {
                String id = element.attributeValue("id");
                String className = element.attributeValue("class");
                // 使用反射生成实例对象
                Object o = Class.forName(className).newInstance();
                // 存到map中 key:id value:o
                iocmap.put(id, o);
            }

        } catch (DocumentException | ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
    public static Object getBean(String beanId) {
        Object o = iocmap.get(beanId);
        return o;
    }
}

在这里插入图片描述

2.2.3 知识小结

* 其实升级后的BeanFactory就是一个简单的Spring的IOC容器所具备的功能。

* 之前我们需要一个userDao实例，需要开发者自己手动创建 new UserDao();

* 现在我们需要一个userdao实例，直接从spring的IOC容器获得，对象的创建权交给了spring控制

* 最终目标：代码解耦合

三 Spring快速入门

3.1 介绍

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

步骤分析

1. 创建java项目，导入spring开发基本坐标
2. 编写Dao接口和实现类
3. 创建spring核心配置文件
4. 在spring配置文件中配置 UserDaoImpl
5. 使用spring相关API获得Bean实例

3.2 实现

1）创建java项目，向pom.xml导入spring依赖

<?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>com.myProject</groupId>
    <artifactId>spring_start</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--指定编码和版本-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
        <java.version>1.8</java.version>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <!--引入相关依赖-->
    <dependencies>
        <!--引入spring-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <!--引入junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
</project>

2）编写Dao接口和实现类

package com.myProject.dao;

public interface IUserDao {
    public void save();
}

package com.myProject.dao.impl;

import com.myProject.dao.IUserDao;

public class UserDaoImpl implements IUserDao {
    @Override
    public void save() {
        System.out.println("dao被调用了。。。");
    }
}

3）创建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">
    <!--在spring配置文件中配置 UserDaoImpl
        id: 唯一标识
        class: 类全路径
    -->
    <bean id="userDao" class="com.myProject.dao.impl.UserDaoImpl"></bean>
</beans>

4）使用spring相关API获得Bean实例

package com.myProject.test;

import com.myProject.dao.IUserDao;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    @Test
    public void test() {
        // 获取到了spring上下文对象，借助上下文对象可以获取到IOC容器的bean对象，加载的同时就创建了bean对象存到容器中
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 使用上下文对象从IOC容器中获取到了bean对象
        IUserDao userDao = (IUserDao) applicationContext.getBean("userDao");

        userDao.save();
    }
}

3.3 知识小结

Spring的开发步骤

1. 向pom.xml导入依赖
2. 创建Bean
3. 创建applicationContext.xml
4. 在配置文件中进行Bean配置
5. 创建ApplicationContext对象，执行getBean

四 Spring相关API

4.1 API继承体系介绍

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

4.2 BeanFactory

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

特点：在第一次调用getBean()方法时，创建指定对象的实例

BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));

4.3 ApplicationContext

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

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

常用实现类

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

ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

常用方法

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有多个情况。

1) 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">
    <!--在spring配置文件中配置 UserDaoImpl
        id: 唯一标识
        class: 类全路径
    -->
    <bean id="userDao" class="com.myProject.dao.impl.UserDaoImpl"></bean>
    <bean id="userDao2" class="com.myProject.dao.impl.UserDaoImpl2"></bean>
</beans>

2) 编写Dao接口和实现类

package com.myProject.dao;

public interface IUserDao {
    public void save();
}

package com.myProject.dao.impl;

import com.myProject.dao.IUserDao;

public class UserDaoImpl implements IUserDao {
    @Override
    public void save() {
        System.out.println("dao被调用了。。。");
    }
}

package com.myProject.dao.impl;

import com.myProject.dao.IUserDao;

public class UserDaoImpl2 implements IUserDao {
    @Override
    public void save() {

    }
}

3）使用spring相关API获得Bean实例

package com.myProject.test;

import com.myProject.dao.IUserDao;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    @Test
    public void test() {
        // 获取到了spring上下文对象，借助上下文对象可以获取到IOC容器的bean对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 使用上下文对象从IOC容器中获取到了bean对象
//        IUserDao userDao = (IUserDao) applicationContext.getBean("userDao");

        // 根据类型在容器中进行查询，有可能报错的情况： 根据当前类型匹配到多个实例,解决报错问题，需使用getBean两个参数的方法
        IUserDao userDao = applicationContext.getBean("userDao",IUserDao.class);
        userDao.save();
    }
}

4.4 知识小结

// 获取IOC容器
ApplicationContext app = new ClasspathXmlApplicationContext("xml文件");

// 获取Bean对象常用的两个方法
app.getBean("id");
app.getBean(Class);

五 Spring配置文件

5.1 Bean标签基本配置

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

* 用于配置对象交由Spring来创建。

* 基本属性：
	id：Bean实例在Spring容器中的唯一标识
	class：Bean的全限定名
	
* 默认情况下它调用的是类中的 无参构造函数，如果没有无参构造函数则不能创建成功。

5.2 Bean标签范围配置

<bean id="" class="" 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 的垃圾回收器回收了

5.3 Bean生命周期配置

<bean id="" class="" scope="" init-method="" destroy-method=""></bean>

* init-method：指定类中的初始化方法名称
* destroy-method：指定类中销毁方法名称

在这里插入图片描述

5.4 Bean实例化三种方式

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

5.4.1 无参构造方法实例化

它会根据默认无参构造方法来创建类对象，如果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">
    <!--在spring配置文件中配置 UserDaoImpl
        id: 唯一标识
        class: 类全路径
    -->
    <!--方式一：无参构造方法进行实例化-->
    <bean id="userDao" class="com.myProject.dao.impl.UserDaoImpl" init-method="init" destroy-method="destroy" />
    <bean id="userDao2" class="com.myProject.dao.impl.UserDaoImpl2"/>
</beans>

package com.myProject.test;

import com.myProject.dao.IUserDao;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    @Test
    public void test() {
        // 获取到了spring上下文对象，借助上下文对象可以获取到IOC容器的bean对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 使用上下文对象从IOC容器中获取到了bean对象
//        IUserDao userDao = (IUserDao) applicationContext.getBean("userDao");

        // 根据类型在容器中进行查询，有可能报错的情况： 根据当前类型匹配到多个实例
        IUserDao userDao = applicationContext.getBean("userDao",IUserDao.class);
        IUserDao userDao2 = applicationContext.getBean("userDao",IUserDao.class);
        System.out.println(userDao);
        System.out.println(userDao2);
    }
}

5.4.2 工厂静态方法实例化

应用场景

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

package com.myProject.factory;

import com.myProject.dao.IUserDao;
import com.myProject.dao.impl.UserDaoImpl;

// 工厂静态方法实例化
public class StaticFactoryBean {
    public static IUserDao createUserDao() {
        return new UserDaoImpl();
    }
}

<?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">
    <!--在spring配置文件中配置 UserDaoImpl
        id: 唯一标识
        class: 类全路径
    -->
    <!--方式二：工厂静态方法实例化-->
    <bean id="userDao" class="com.myProject.factory.StaticFactoryBean" factory-method="createUserDao" />
</beans>

package com.myProject.test;

import com.myProject.dao.IUserDao;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    @Test
    public void test() {
        // 获取到了spring上下文对象，借助上下文对象可以获取到IOC容器的bean对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 使用上下文对象从IOC容器中获取到了bean对象
//        IUserDao userDao = (IUserDao) applicationContext.getBean("userDao");

      
        IUserDao userDao = applicationContext.getBean("userDao",IUserDao.class);
        System.out.println(userDao);
    }
}

5.4.3 工厂普通方法实例化

应用场景

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

package com.myProject.factory;

import com.myProject.dao.IUserDao;
import com.myProject.dao.impl.UserDaoImpl;

// 工厂普通方法实例化
public class DynamicFactoryBean {
    public IUserDao createUserDao(){
        return new UserDaoImpl();
    }
}

<?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">
    <!--在spring配置文件中配置 UserDaoImpl
        id: 唯一标识
        class: 类全路径
    -->
	<!--方式三：工厂普通方法实例化-->
    <bean id="dynamicFactoryBean" class="com.myProject.factory.DynamicFactoryBean" />
    <bean id="userDao" factory-bean="dynamicFactoryBean" factory-method="createUserDao" />
</beans>

package com.myProject.test;

import com.myProject.dao.IUserDao;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    @Test
    public void test() {
        // 获取到了spring上下文对象，借助上下文对象可以获取到IOC容器的bean对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 使用上下文对象从IOC容器中获取到了bean对象
//        IUserDao userDao = (IUserDao) applicationContext.getBean("userDao");

        IUserDao userDao = applicationContext.getBean("userDao",IUserDao.class);
        System.out.println(userDao);
    }
}

5.5 Bean依赖注入概述

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

5.6 Bean依赖注入方式

5.6.1 构造方法

1) 在UserServiceImpl中创建有参构造

package com.myProject.service.impl;

import com.myProject.dao.IUserDao;
import com.myProject.service.IUserService;

public class UserServiceImpl implements IUserService {
    private IUserDao userDao;

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

    @Override
    public void save() {
        // 调用dao的save方法
        userDao.save();
    }
}

2) 配置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">
    <!--在spring配置文件中配置 UserDaoImpl
        id: 唯一标识
        class: 类全路径
    -->
    <!--方式一：无参构造方法进行实例化-->
    <bean id="userDao" class="com.myProject.dao.impl.UserDaoImpl" />

    <!--配置UserService-->
    <bean id="userService" class="com.myProject.service.impl.UserServiceImpl">
        <!--构造方法完成依赖注入-->
        <!--方式一：-->
        <!--<constructor-arg index="0" type="com.myProject.dao.IUserDao" ref="userDao" />-->
        <!--方式二：-->
        <!--name的值是有参构造的参数对象-->
        <constructor-arg name="userDao" ref="userDao" />
    </bean>
</beans>

3) 使用spring相关API获得Bean实例

package com.myProject.test;

import com.myProject.service.IUserService;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    @Test
    public void test() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        IUserService userServiceDao = (IUserService) applicationContext.getBean("userService");
        userServiceDao.save();
    }
}

在这里插入图片描述

5.6.2 set方法

1) 在UserServiceImpl中创建set方法

package com.myProject.service.impl;

import com.myProject.dao.IUserDao;
import com.myProject.service.IUserService;

public class UserServiceImpl implements IUserService {
    private IUserDao userDao;

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

    @Override
    public void save() {
        // 调用dao的save方法
        userDao.save();
    }
}

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

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--在spring配置文件中配置 UserDaoImpl
        id: 唯一标识
        class: 类全路径
    -->
    <!--方式一：无参构造方法进行实例化-->
    <bean id="userDao" class="com.myProject.dao.impl.UserDaoImpl" />

    <!--配置UserService-->
    <bean id="userService" class="com.myProject.service.impl.UserServiceImpl">
        <!--构造方法完成依赖注入-->
        <!--方式一：-->
        <!--<constructor-arg index="0" type="com.myProject.dao.IUserDao" ref="userDao" />-->
        <!--方式二：-->
        <!--name的值是有参构造的参数对象-->
        <!--<constructor-arg name="userDao" ref="userDao" />-->

        <!--set方法完成依赖注入-->
        <property name="userDao" ref="userDao"></property>
    </bean>
</beans>

3) 使用spring相关API获得Bean实例

package com.myProject.test;

import com.myProject.service.IUserService;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    @Test
    public void test() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        IUserService userServiceDao = (IUserService) applicationContext.getBean("userService");
        userServiceDao.save();
    }
}

5.6.3 P命名空间注入

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

首先，需要引入P命名空间：

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

1) 在UserServiceImpl中创建set方法

package com.myProject.service.impl;

import com.myProject.dao.IUserDao;
import com.myProject.service.IUserService;

public class UserServiceImpl implements IUserService {
    private IUserDao userDao;

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

    @Override
    public void save() {
        // 调用dao的save方法
        userDao.save();
    }
}

2) 配置Spring容器调用P命名空间进行注入

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
       
    <bean id="userDao" class="com.myProject.dao.impl.UserDaoImpl" />

    <!--P命名空间注入-->
    <bean id="userService" class="com.myProject.service.impl.UserServiceImpl" p:userDao-ref="userDao" />
</beans>

在这里插入图片描述

3) 使用spring相关API获得Bean实例

package com.myProject.test;

import com.myProject.service.IUserService;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    @Test
    public void test() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        IUserService userServiceDao = (IUserService) applicationContext.getBean("userService");
        userServiceDao.save();
    }
}

5.7 Bean依赖注入的数据类型

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

注入数据的三种数据类型

1. 普通数据类型
2. 引用数据类型
3. 集合数据类型

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

5.7.1 注入普通数据类型

1) 在UserDaoImpl中创建set方法

package com.myProject.dao.impl;

import com.myProject.dao.IUserDao;

public class UserDaoImpl implements IUserDao {
	// 注入普通数据类型
    private String username;
    private Integer age;

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

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

    @Override
    public void save() {
        System.out.println(username);
        System.out.println(age);
        System.out.println("dao被调用了。。。");
    }
}

2) 配置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">
    <!--配置UserDao：无参构造方法进行实例化-->
    <bean id="userDao" class="com.myProject.dao.impl.UserDaoImpl">
        <!--ref:用于引用数据类型的注入，value是用于普通数据类型的注入-->
        <property name="username" value="虎子"></property>
        <property name="age" value="18"></property>
    </bean>
</beans>

3) 使用spring相关API获得Bean实例

package com.myProject.test;

import com.myProject.dao.IUserDao;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    @Test
    public void test() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        IUserDao userDao = (IUserDao) applicationContext.getBean("userDao");
        userDao.save();
    }
}

5.7.2 注入集合数据类型

1）List集合注入

编写UserDaoImpl实现类

package com.myProject.dao.impl;

import com.myProject.dao.IUserDao;

import java.util.List;

public class UserDaoImpl implements IUserDao {
    // 注入集合数据类型
    private List<Object> list;

    public void setList(List<Object> list) {
        this.list = list;
    }
    
    @Override
    public void save() {
        System.out.println(list);
        System.out.println("dao被调用了。。。");
    }
}

User实体

package com.myProject.pojo;

public class User {
    private String username;
    private Integer age;

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

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

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", age=" + age +
                '}';
    }
}

创建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">
    <!--配置User对象-->

    <bean id="user" class="com.myProject.pojo.User">
        <!--普通数据类型注入-->
        <property name="username" value="AA1"></property>
        <property name="age" value="28"></property>
    </bean>

    <!--配置UserDao：无参构造方法进行实例化-->
    <bean id="userDao" class="com.myProject.dao.impl.UserDaoImpl">
        <!--进行list集合数据类型的注入-->
        <property name="list">
            <list>
                <!--注入普通类型数据-->
                <value>aaa</value>
                <!--注入User类型数据-->
                <ref bean="user"></ref>
            </list>
        </property>
    </bean>
</beans>

使用spring相关API获得Bean实例

package com.myProject.test;

import com.myProject.dao.IUserDao;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    @Test
    public void test() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        IUserDao userDao = (IUserDao) applicationContext.getBean("userDao");
        userDao.save();
    }
}

2）Set集合注入

编写UserDaoImpl实现类

package com.myProject.dao.impl;

import com.myProject.dao.IUserDao;

import java.util.Set;

public class UserDaoImpl implements IUserDao {
    // 注入set集合数据类型
    private Set<Object> set;

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

    @Override
    public void save() {
        System.out.println(set);
        System.out.println("dao被调用了。。。");
    }
}

User实体

package com.myProject.pojo;

public class User {
    private String username;
    private Integer age;

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

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

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", age=" + age +
                '}';
    }
}

创建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">
    <!--配置User对象-->

    <bean id="user" class="com.myProject.pojo.User">
        <!--普通数据类型注入-->
        <property name="username" value="AA1"></property>
        <property name="age" value="28"></property>
    </bean>

    <!--配置UserDao：无参构造方法进行实例化-->
    <bean id="userDao" class="com.myProject.dao.impl.UserDaoImpl">
        <!--进行set集合数据类型的注入-->
        <property name="set">
            <set>
                <value>bbb</value>
                <ref bean="user"></ref>
            </set>
        </property>
    </bean>
</beans>

使用spring相关API获得Bean实例

package com.myProject.test;

import com.myProject.dao.IUserDao;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    @Test
    public void test() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        IUserDao userDao = (IUserDao) applicationContext.getBean("userDao");
        userDao.save();
    }
}

3）Array数组注入

编写UserDaoImpl实现类

package com.myProject.dao.impl;

import com.myProject.dao.IUserDao;

import java.util.Set;

public class UserDaoImpl implements IUserDao {
    // 注入Array数组数据类型
    private Object[] array;

    public void setArray(Object[] array) {
        this.array = array;
    }

    @Override
    public void save() {
        System.out.println("Array数组：" + Arrays.toString(array));
        System.out.println("dao被调用了。。。");
    }
}

User实体

package com.myProject.pojo;

public class User {
    private String username;
    private Integer age;

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

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

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", age=" + age +
                '}';
    }
}

创建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">
    <!--配置User对象-->

    <bean id="user" class="com.myProject.pojo.User">
        <!--普通数据类型注入-->
        <property name="username" value="AA1"></property>
        <property name="age" value="28"></property>
    </bean>

    <!--配置UserDao：无参构造方法进行实例化-->
    <bean id="userDao" class="com.myProject.dao.impl.UserDaoImpl">
        <!--进行Array数组数据类型的注入-->
        <property name="array">
            <array>
                <value>ccc</value>
                <ref bean="user"></ref>
            </array>
        </property>
    </bean>
</beans>

使用spring相关API获得Bean实例

package com.myProject.test;

import com.myProject.dao.IUserDao;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    @Test
    public void test() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        IUserDao userDao = (IUserDao) applicationContext.getBean("userDao");
        userDao.save();
    }
}

4）Map集合注入

编写UserDaoImpl实现类

package com.myProject.dao.impl;

import com.myProject.dao.IUserDao;

import java.util.Set;

public class UserDaoImpl implements IUserDao {
    // 注入Map集合数据类型
    private Map<String, Object> map;

    public void setMap(Map<String, Object> map) {
        this.map = map;
    }
    
    @Override
    public void save() {
        System.out.println("Map集合：" + Arrays.toString(array));
        System.out.println("dao被调用了。。。");
    }
}

User实体

package com.myProject.pojo;

public class User {
    private String username;
    private Integer age;

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

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

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", age=" + age +
                '}';
    }
}

创建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">
    <!--配置User对象-->

    <bean id="user" class="com.myProject.pojo.User">
        <!--普通数据类型注入-->
        <property name="username" value="AA1"></property>
        <property name="age" value="28"></property>
    </bean>

    <!--配置UserDao：无参构造方法进行实例化-->
    <bean id="userDao" class="com.myProject.dao.impl.UserDaoImpl">
       <!--进行Map集合数据类型的注入-->
        <property name="map">
            <map>
                <entry key="k1" value="ddd"></entry>
                <entry key="k2" value-ref="user"></entry>
            </map>
        </property>
    </bean>
</beans>

使用spring相关API获得Bean实例

package com.myProject.test;

import com.myProject.dao.IUserDao;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    @Test
    public void test() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        IUserDao userDao = (IUserDao) applicationContext.getBean("userDao");
        userDao.save();
    }
}

5）Properties配置注入

编写UserDaoImpl实现类

package com.myProject.dao.impl;

import com.myProject.dao.IUserDao;

import java.util.Set;

public class UserDaoImpl implements IUserDao {
    // 注入Properties配置数据类型
    private Properties properties;

    public void setProperties(Properties properties) {
        this.properties = properties;
    }
    
    @Override
    public void save() {
        System.out.println("Properties配置：" + properties);
        System.out.println("dao被调用了。。。");
    }
}

User实体

package com.myProject.pojo;

public class User {
    private String username;
    private Integer age;

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

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

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", age=" + age +
                '}';
    }
}

创建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">
    <!--配置User对象-->

    <bean id="user" class="com.myProject.pojo.User">
        <!--普通数据类型注入-->
        <property name="username" value="AA1"></property>
        <property name="age" value="28"></property>
    </bean>

    <!--配置UserDao：无参构造方法进行实例化-->
    <bean id="userDao" class="com.myProject.dao.impl.UserDaoImpl">
       <!--进行Properties配置数据类型的注入-->
        <property name="properties">
            <props>
                <prop key="k1">v1</prop>
                <prop key="k2">v2</prop>
                <prop key="k3">v3</prop>
            </props>
        </property>
    </bean>
</beans>

使用spring相关API获得Bean实例

package com.myProject.test;

import com.myProject.dao.IUserDao;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    @Test
    public void test() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        IUserDao userDao = (IUserDao) applicationContext.getBean("userDao");
        userDao.save();
    }
}

5.8 配置文件模块化

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

1）并列的多个配置文件

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml","applicationContext-products.xml","applicationContext-service.xml","applicationContext-user.xml",...);

2）主从配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--配置User对象-->

    <bean id="user" class="com.myProject.pojo.User">
        <!--普通数据类型注入-->
        <property name="username" value="AA1"></property>
        <property name="age" value="28"></property>
    </bean>

    <!--配置UserDao：无参构造方法进行实例化-->
    <bean id="userDao" class="com.myProject.dao.impl.UserDaoImpl">
        <!--ref:用于引用数据类型的注入，value是用于普通数据类型的注入-->
        <property name="username" value="虎子"></property>
        <property name="age" value="18"></property>

        <!--进行list集合数据类型的注入-->
        <property name="list">
            <list>
                <!--注入普通类型数据-->
                <value>aaa</value>
                <!--注入User类型数据-->
                <ref bean="user"></ref>
            </list>
        </property>

        <!--进行set集合数据类型的注入-->
        <property name="set">
            <set>
                <value>bbb</value>
                <ref bean="user"></ref>
            </set>
        </property>

        <!--进行Array数组数据类型的注入-->
        <property name="array">
            <array>
                <value>ccc</value>
                <ref bean="user"></ref>
            </array>
        </property>

        <!--进行Map集合数据类型的注入-->
        <property name="map">
            <map>
                <entry key="k1" value="ddd"></entry>
                <entry key="k2" value-ref="user"></entry>
            </map>
        </property>

        <!--进行Properties配置数据类型的注入-->
        <property name="properties">
            <props>
                <prop key="k1">v1</prop>
                <prop key="k2">v2</prop>
                <prop key="k3">v3</prop>
            </props>
        </property>
    </bean>
    <!--借助import标签-->
    <!--<import resource="applicationContext-xxx.xml"/>-->
    <import resource="classpath:applicationContext-user.xml"></import>
</beans>

注意：

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

5.9 知识小结

Spring的重点配置

<bean>标签：创建对象并放到spring的IOC容器
	id属性:在容器中Bean实例的唯一标识，不允许重复
	class属性:要实例化的Bean的全限定名
	scope属性:Bean的作用范围，常用是Singleton(默认)和prototype
	
<constructor-arg>标签：属性注入
	name属性：属性名称
	value属性：注入的普通属性值
	ref属性：注入的对象引用值
	
<property>标签：属性注入
	name属性：属性名称
	value属性：注入的普通属性值
	ref属性：注入的对象引用值
	<list>
	<set>
	<array>
	<map>
	<props>
	
<import>标签:导入其他的Spring的分文件

六 DbUtils（IOC实战）

6.1 DbUtils是什么

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

核心对象

QueryRunner queryRunner = new QueryRunner(DataSource dataSource);

核心方法

int update(); 执行增、删、改语句

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

举个栗子

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

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);
        }
    }
}

6.2 Spring的xml整合DbUtils

6.2.1 介绍

需求

基于Spring的xml配置实现账户的CRUD案例
步骤分析

1. 准备数据库环境
2. 创建java项目，导入坐标
3. 编写Account实体类
4. 编写AccountDao接口和实现类
5. 编写AccountService接口和实现类
6. 编写spring核心配置文件
7. 编写测试代码

在这里插入图片描述

6.2.2 实现

1）准备数据库环境

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);

2）创建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>com.myProject</groupId>
    <artifactId>spring_dbutils</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</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>

3）编写Account实体类

package com.myProject.domain;

public class Account {
    private Integer id;
    private String name;
    private Double money;

    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 +
                '}';
    }
}

4）编写AccountDao接口和实现类

package com.myProject.dao;

import com.myProject.domain.Account;

import java.util.List;

public interface AccountDao {
    public List<Account> findAll();

    public Account findById(Integer id);

    public void save(Account account);

    public void update(Account account);

    public void delete(Integer id);
}

package com.myProject.dao.impl;

import com.myProject.dao.AccountDao;
import com.myProject.domain.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;

public class AccountDaoImpl implements AccountDao {
    private QueryRunner queryRunner;

    public void setQueryRunner(QueryRunner queryRunner) {
        this.queryRunner = queryRunner;
    }

    @Override
    public List<Account> findAll() {
        List<Account> list = null;
        // 编写sql
        String sql = "select * from account";
        try {
            list = queryRunner.query(sql, new BeanListHandler<>(Account.class));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return list;
    }

    @Override
    public Account findById(Integer id) {
        Account query = null;
        // 编写sql
        String sql = "select * from account where id = ?";
        try {
            query = queryRunner.query(sql, new BeanHandler<>(Account.class), id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return query;
    }

    @Override
    public void save(Account account) {
        String sql = "insert into account values(null, ?, ?)";
        try {
            queryRunner.update(sql, account.getName(), account.getMoney());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void update(Account account) {
        String sql = "update account set name = ?, money = ? where id = ?";
        try {
            queryRunner.update(sql, account.getName(), account.getMoney(), account.getId());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void delete(Integer id) {
        String sql = "delete from account where id = ?";
        try {
            queryRunner.update(sql, id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

5）编写AccountService接口和实现类

package com.myProject.service;

import com.myProject.domain.Account;

import java.util.List;

public interface AccountService {
    public List<Account> findAll();

    public Account findById(Integer id);

    public void save(Account account);

    public void update(Account account);

    public void delete(Integer id);
}

package com.myProject.service.impl;

import com.myProject.dao.AccountDao;
import com.myProject.domain.Account;
import com.myProject.service.AccountService;

import java.util.List;

public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;

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

    @Override
    public List<Account> findAll() {
        return accountDao.findAll();
    }

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

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

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

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

6）编写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">
    <!--把数据库连接池交给IOC容器-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql:///spring_db" />
        <property name="username" value="root" />
        <property name="password" value="root" />
    </bean>

    <!--把QueryRunner交给IOC容器-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner" >
        <constructor-arg name="ds" ref="dataSource" />
    </bean>

    <!--把AccountDao交给IOC容器-->
    <bean id="accountDao" class="com.myProject.dao.impl.AccountDaoImpl">
        <property name="queryRunner" ref="queryRunner" />
     </bean>

    <!--把AccountService交给IOC容器-->
    <bean id="accountService" class="com.myProject.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao" />
    </bean>
</beans>

7）编写测试代码

package com.myProject.test;

import com.myProject.domain.Account;
import com.myProject.service.AccountService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

public class AccountServiceTest {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    AccountService accountSerivce = (AccountService) applicationContext.getBean("accountService");
    // 测试添加
    @Test
    public void testSave() {
        Account account = new Account();
        account.setName("lucy");
        account.setMoney(888d);
        accountSerivce.save(account);
    }

    // 测试查询
    @Test
    public void testFindById(){
        Account account = accountSerivce.findById(3);
        System.out.println(account);
    }

    // 测试查询所有
    @Test
    public void testFindAll(){
        List<Account> all = accountSerivce.findAll();
        for (Account account : all) {
            System.out.println(account);
        }
    }

    // 测试更新
    @Test
    public void testUpdate() {
        Account account = new Account();
        account.setId(3);
        account.setName("jack");
        account.setMoney(2000d);
        accountSerivce.update(account);
    }

    // 测试删除
    @Test
    public void testDelete() {
        accountSerivce.delete(3);
    }
}

8）抽取jdbc配置文件

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

jdbc.properties

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///spring_db
jdbc.username=root
jdbc.password=root

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"
       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" />
    <!--把数据库连接池交给IOC容器-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <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>
 </beens>

6.3 知识小结

* DataSource的创建权交由Spring容器去完成

* QueryRunner的创建权交由Spring容器去完成，使用构造方法传递DataSource

* Spring容器加载properties文件
	<context:property-placeholder location="xx.properties"/>
	<property name="" value="${key}"/>

七 Spring注解开发

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

7.1 Spring常用注解

7.1.1 介绍

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

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

说明：

JDK11以后完全移除了javax扩展导致不能使用@resource注解

<!--需要maven引入依赖-->

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

注意

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

    <!--引入jdbc.properties-->
    <context:property-placeholder location="classpath:jdbc.properties" />
    
    <!--把数据库连接池交给IOC容器-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <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交给IOC容器-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner" >
        <constructor-arg name="ds" ref="dataSource" />
    </bean>

    <!--把AccountDao交给IOC容器-->
    <bean id="accountDao" class="com.myProject.dao.impl.AccountDaoImpl">
        <property name="queryRunner" ref="queryRunner" />
    </bean>

    <!--把AccountService交给IOC容器-->
    <!--<bean id="accountService" class="com.myProject.service.impl.AccountServiceImpl">-->
    <!--    <property name="accountDao" ref="accountDao" />-->
    <!--</bean>-->
</beans>

AccountServiceImpl.java

package com.myProject.service.impl;

import com.myProject.dao.AccountDao;
import com.myProject.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service // 相当于配置了bean标签 id属性
public class AccountServiceImpl implements AccountService {
    @Autowired // 根据类型去完成依赖注入
    @Qualifier("accountDao1") // 结合@Autowired使用，不能单独使用
    @Resource
    private AccountDao accountDao;

    @Value("zhangsan")
    private String username;
}

7.1.2 实现

1）Bean实例化（IOC）

<!--把AccountDao交给IOC容器-->
<bean id="accountDao" class="com.myProject.dao.impl.AccountDaoImpl">
    <property name="queryRunner" ref="queryRunner" />
</bean>

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

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

2）属性依赖注入（DI）

<!--把AccountService交给IOC容器-->
<bean id="accountService" class="com.myProject.service.impl.AccountServiceImpl">
    <property name="accountDao" ref="accountDao" />
</bean>

使用@Autowired或者@Autowired+@Qulifier或者@Resource进行accountDao的注入

@Service("accountService") // 相当于配置了bean标签 id属性
@Scope("prototype") // 就会变成多例对象
public class AccountServiceImpl implements AccountService {
	// <property name="accountDao" ref="accountDao"/>
	// @Autowired
	// @Qualifier("accountDao")
	// @Resource(name = "accountDao")
	@Autowired
	private UserDao accountDao;
	/*public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}*/
}

3）@Value

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

@Service
public class AccountServiceImpl implements AccountService {
	@Value("注入普通数据")
	private String str;
	
	@Value("${jdbc.driver}")
	private String driver;
}

4）@Scope

<bean scope=""/>

使用@Scope标注Bean的范围

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

5）Bean生命周期

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

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

@PostConstruct
public void init(){
	System.out.println("初始化方法....");
}
@PreDestroy
public void destroy(){
	System.out.println("销毁方法.....");
}

7.2 Spring常用注解整合DbUtils

步骤分析

1. 拷贝xml配置项目，改为注解配置项目
2. 修改AccountDaoImpl实现类
3. 修改AccountServiceImpl实现类
4. 修改spring核心配置文件
5. 编写测试代码

在这里插入图片描述

1）创建java项目，改为常用注解方式配置项目

pom.xml

<?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>com.myProject</groupId>
    <artifactId>spring_dbutils</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</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>

jdbc.properties

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///spring_db
jdbc.username=root
jdbc.password=root

2）修改AccountDaoImpl实现类

package com.myProject.dao.impl;

import com.myProject.dao.AccountDao;
import com.myProject.domain.Account;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

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

@Repository // 相当于配置了bean标签
public class AccountDaoImpl implements AccountDao {
    @Autowired
    private QueryRunner queryRunner;

    @Override
    public List<Account> findAll() {
        List<Account> list = null;
        // 编写sql
        String sql = "select * from account";
        try {
            list = queryRunner.query(sql, new BeanListHandler<>(Account.class));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return list;
    }

    @Override
    public Account findById(Integer id) {
        Account query = null;
        // 编写sql
        String sql = "select * from account where id = ?";
        try {
            query = queryRunner.query(sql, new BeanHandler<>(Account.class), id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return query;
    }

    @Override
    public void save(Account account) {
        String sql = "insert into account values(null, ?, ?)";
        try {
            queryRunner.update(sql, account.getName(), account.getMoney());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void update(Account account) {
        String sql = "update account set name = ?, money = ? where id = ?";
        try {
            queryRunner.update(sql, account.getName(), account.getMoney(), account.getId());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void delete(Integer id) {
        String sql = "delete from account where id = ?";
        try {
            queryRunner.update(sql, id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

3）修改AccountServiceImpl实现类

package com.myProject.service.impl;

import com.myProject.dao.AccountDao;
import com.myProject.domain.Account;
import com.myProject.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service("accountService") // 相当于配置了bean标签 id属性
public class AccountServiceImpl implements AccountService {
    @Autowired // 根据类型去完成依赖注入
    private AccountDao accountDao;

     @Override
    public List<Account> findAll() {
        return accountDao.findAll();
    }

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

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

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

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

4）修改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"
       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.myProject" />
    
    <!--引入jdbc.properties-->
    <context:property-placeholder location="classpath:jdbc.properties" />
    
    <!--把数据库连接池交给IOC容器-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <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交给IOC容器-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner" >
        <constructor-arg name="ds" ref="dataSource" />
    </bean>
</beans>

5）编写测试代码

package com.myProject.test;

import com.myProject.domain.Account;
import com.myProject.service.AccountService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

public class AccountServiceTest {
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    AccountService accountSerivce = (AccountService) applicationContext.getBean("accountService");
    // 测试添加
    @Test
    public void testSave() {
        Account account = new Account();
        account.setName("lucy");
        account.setMoney(888d);
        accountService.save(account);
    }

    // 测试查询
    @Test
    public void testFindById(){
        Account account = accountSerivce.findById(3);
        System.out.println(account);
    }

    // 测试查询所有
    @Test
    public void testFindAll(){
        List<Account> all = accountService.findAll();
        for (Account account : all) {
            System.out.println(account);
        }
    }

    // 测试更新
    @Test
    public void testUpdate() {
        Account account = new Account();
        account.setId(3);
        account.setName("jack");
        account.setMoney(2000d);
        accountService.update(account);
    }

    // 测试删除
    @Test
    public void testDelete() {
        accountService.delete(3);
    }
}

7.3 Spring新注解

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

* 非自定义的Bean的配置：<bean>

* 加载properties文件的配置：<context:property-placeholder>

* 组件扫描的配置：<context:component-scan>

* 引入其他文件：<import>

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

在这里插入图片描述

7.4 Spring纯注解整合DbUtils

步骤分析

1. 编写Spring核心配置类
2. 编写数据库配置信息类
3. 编写测试代码

在这里插入图片描述

1）编写Spring核心配置类

package com.myProject.config;

import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.*;

import javax.sql.DataSource;

@Configuration
@ComponentScan("com.myProject")
@Import(DataSourceConfig.class)
public class SpringConfig {
    @Bean("queryRunner")
    public QueryRunner getQueryRunner(@Autowired DataSource dataSource) {
        QueryRunner queryRunner = new QueryRunner(dataSource);
        return queryRunner;
    }
}

2）编写数据库配置信息类

package com.myProject.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;

@PropertySource("classpath:jdbc.properties")
public class DataSourceConfig {
    @Value("${jdbc.driverClassName}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    @Bean("dataSource")
    public DataSource getDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driver);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);

        return druidDataSource;
    }
}

3）编写测试代码

package com.myProject.test;

import com.myProject.config.SpringConfig;
import com.myProject.domain.Account;
import com.myProject.service.AccountService;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.util.List;

public class AccountServiceTest {
    // 当前改成了纯注解形式
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
    AccountService accountService = (AccountService) applicationContext.getBean("accountService");

    // 测试添加
    @Test
    public void testSave() {
        Account account = new Account();
        account.setName("lucy");
        account.setMoney(888d);
        accountService.save(account);
    }

    // 测试查询
    @Test
    public void testFindById(){
        Account account = accountService.findById(3);
        System.out.println(account);
    }

    // 测试查询所有
    @Test
    public void testFindAll(){
        List<Account> all = accountService.findAll();
        for (Account account : all) {
            System.out.println(account);
        }
    }

    // 测试更新
    @Test
    public void testUpdate() {
        Account account = new Account();
        account.setId(3);
        account.setName("jack");
        account.setMoney(2000d);
        accountService.update(account);
    }

    // 测试删除
    @Test
    public void testDelete() {
        accountService.delete(3);
    }
}

八 Spring整合Junit

8.1普通Junit测试问题

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

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

AccountService accountService = applicationContext.getBean(AccountService.class);

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

8.2 Spring整合Junit

步骤分析

1. 导入spring集成Junit的坐标
2. 使用@Runwith注解替换原来的运行器
3. 使用@ContextConfiguration指定配置文件或配置类
4. 使用@Autowired注入需要测试的对象
5. 创建测试方法进行测试

1）向pom.xml导入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>

2）使用@Runwith注解替换原来的运行器

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

@RunWith(SpringJUnit4ClassRunner.class) // @RunWith指定junit的运行环境 SpringJUnit4ClassRunner是spring提供的作为junit运行环境的类
public class AccountServiceTest {}

3）使用@ContextConfiguration指定配置文件或配置类

@RunWith(SpringJUnit4ClassRunner.class)
//@ContextConfiguration(value = {"classpath:applicationContext.xml"}) 加载spring核心配置文件
@ContextConfiguration(classes = {SpringConfig.class}) // 加载spring核心配置类
public class SpringJunitTest {}

@RunWith(SpringJUnit4ClassRunner.class) // @RunWith指定junit的运行环境 SpringJUnit4ClassRunner是spring提供的作为junit运行环境的类
// @ContextConfiguration({"classpath:applicationContext.xml"}) // 加载spring核心配置文件
@ContextConfiguration(classes = {SpringConfig.class}) // 加载spring核心配置类
public class AccountServiceTest {}

4）使用@Autowired注入需要测试的对象

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SpringConfig.class})
public class SpringJunitTest {
	@Autowired
	private AccountService accountService;
}

@RunWith(SpringJUnit4ClassRunner.class) // @RunWith指定junit的运行环境 SpringJUnit4ClassRunner是spring提供的作为junit运行环境的类
// @ContextConfiguration({"classpath:applicationContext.xml"}) // 加载spring核心配置文件
@ContextConfiguration(classes = {SpringConfig.class}) // 加载spring核心配置类
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;
}

5）创建测试方法进行测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SpringConfig.class})
public class SpringJunitTest {
	@Autowired
	private AccountService accountService;
	//测试查询
	@Test
	public void testFindById() {
		Account account = accountService.findById(3);
		System.out.println(account);
	}
}

@RunWith(SpringJUnit4ClassRunner.class) // @RunWith指定junit的运行环境 SpringJUnit4ClassRunner是spring提供的作为junit运行环境的类
// @ContextConfiguration({"classpath:applicationContext.xml"}) // 加载spring核心配置文件
@ContextConfiguration(classes = {SpringConfig.class}) // 加载spring核心配置类
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;

	// 测试查询
    @Test
    public void testFindById(){
        Account account = accountService.findById(3);
        System.out.println(account);
    }