Spring Reference
Spring概述
Spring是分层的 Java SE/EE应用 full-stack(全栈式) 轻量级开源框架。
提供了表现层 SpringMVC和持久层 Spring JDBC Template以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。
两大核心：以 IOC（Inverse Of Control：控制反转）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。
发展历程
* 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）
优势
| 优势 | 说明 |
|---|---|
| 方便解耦，简化开发 | Spring就是一个容器，可以将所有对象创建和关系维护交给Spring管理。什么是耦合度？对象之间的关系，通常说当一个模块(对象)更改时也需要更改其他模块(对象)，这就是耦合，耦合度过高会使代码的维护成本增加，要尽量解耦。 |
| AOP编程的支持 | Spring提供面向切面编程，方便实现程序进行权限拦截，运行监控等功能。 |
| 声明式事务的支持 | 通过配置完成事务的管理，无需手动编程。 |
| 方便测试，降低JavaEE API的使用 | Spring对Junit4支持，可以使用注解测试 |
| 方便集成各种优秀框架 | 不排除各种优秀的开源框架，内部提供了对各种优秀框架的直接支持 |
体系结构
IOC
控制反转（Inverse Of Control）不是什么技术，而是一种设计思想。它的目的是指导我们设计出更加松耦合的程序。
控制：在java中指的是对象的控制权限（创建、销毁）
反转：指的是对象控制权由原来由开发者在类中手动控制反转到由Spring容器控制
* 传统方式
之前我们需要一个userDao实例，需要开发者自己手动创建 new UserDao();
* IOC方式
现在我们需要一个userDao实例，直接从spring的IOC容器获得，对象的创建权交给了spring控制
传统开发方式service层调用dao层
- 创建java项目，导入自定义IOC相关坐标
<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>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
- 编写Dao接口和实现类
IUserDao
public interface IUserDao {
public void save();
}
UserDaoImpl
public class UserDaoImpl implements IUserDao {
@Override
public void save() {
System.out.println("UserDaoImpl save successfully!");
}
}
- 编写Service接口和实现类
IUserService
public interface IUserService {
public void save();
}
IUserServiceImpl
public class IUserServiceImpl implements IUserService {
@Override
public void save() {
//调用Dao层方法: 传统方式
IUserDao userDao = new UserDaoImpl();
userDao.save();
}
}
- 编写测试代码
package com.soulboy.test;
import com.soulboy.service.IUserService;
import com.soulboy.service.impl.IUserServiceImpl;
import org.junit.Test;
public class SpringTest {
@Test
public void test1(){
//获取业务层对象
IUserService userService = new IUserServiceImpl();
//调用save方法
userService.save(); //UserDaoImpl save successfully!
}
}
自定义IOC容器
问题
当前service对象和dao对象耦合度太高，而且每次new的都是一个新的对象，导致服务器压力过大。
解耦合的原则是编译期不依赖，而运行期依赖就行了。
5. 编写beans.xml
src/main/resources/beans.xml，把所有需要创建对象的信息定义在配置文件中
<?xml version="1.0" encoding="UTF-8" ?>
<beans>
<bean id="userDao" class="com.soulboy.dao.impl.UserDaoImpl"></bean>
</beans>
- BeanFactory工具类
package com.soulboy.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 resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
//2.解析xml(dom4j)
SAXReader saxReader = new SAXReader();
try {
Document document = saxReader.read(resourceAsStream);
//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");
//className: "com.soulboy.dao.impl.UserDaoImpl"
String className = element.attributeValue("class");
//使用反射生成实力对象
Object o = Class.forName(className).newInstance();
//存到map中 key(id):value(object)
iocmap.put(id,o);
}
} catch (DocumentException e) {
throw new RuntimeException(e);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
public static Object getBean(String beanId) {
Object o = iocmap.get(beanId);
return o;
}
}
- 测试类
package com.soulboy.test;
import com.soulboy.service.IUserService;
import com.soulboy.service.impl.IUserServiceImpl;
import org.junit.Test;
public class SpringTest {
@Test
public void test1() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
//获取业务层对象
IUserService userService = new IUserServiceImpl();
//调用save方法
userService.save();
}
}
最终效果
* 其实升级后的BeanFactory就是一个简单的Spring的IOC容器所具备的功能。
* 之前我们需要一个userDao实例，需要开发者自己手动创建 new UserDao();
* 现在我们需要一个userdao实例，直接从spring的IOC容器获得，对象的创建权交给了spring控制
* 最终目标：代码解耦合
快速上手
- 创建java项目，导入spring开发基本坐标
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
- 编写Dao接口和实现类
IUserDao
public interface IUserDao {
public void save();
}
UserDaoImpl
public class UserDaoImpl implements IUserDao {
@Override
public void save() {
System.out.println("UserDaoImpl save successfully!");
}
}
- 创建spring核心配置文件，在spring配置文件中配置 UserDaoImpl
src/main/resources/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.soulboy.dao.impl.UserDaoImpl"></bean>
</beans>
- 使用spring相关API获得Bean实例
package com.soulboy.test;
import com.soulboy.dao.IUserDao;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringTest {
@Test
public void test1() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
//获取到了spring上下文对象，借助上下文对象可以获取IOC容器中的bean对象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//使用上下文对象从IOC容器中获取到了bean对象
IUserDao userDao = (IUserDao) applicationContext.getBean("userDao");
//调用方法
userDao.save();
}
}
Spring相关API
API继承体系结构
BeanFactory
BeanFactory是 IOC 容器的核心接口，它定义了IOC的基本功能，在第一次调用getBean()方法时，创建指定对象的实例。
@Test
public void test2() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
//获取到了spring上下文对象，借助上下文对象可以获取IOC容器中的bean对象
BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
//使用上下文对象从IOC容器中获取到了bean对象
IUserDao userDao = (IUserDao) beanFactory.getBean("userDao");
//调用方法
userDao.save();
}
ApplicationContext
代表应用上下文对象，可以获得spring中IOC容器的Bean对象。特点：在spring容器启动时，加载并创建所有对象的实例
常用实现类
1. ClassPathXmlApplicationContext
它是从类的根路径下加载配置文件 推荐使用这种。
2. FileSystemXmlApplicationContext
它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
3. AnnotationConfigApplicationContext
当使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。
getBean()方法
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有多个情况。
Spring配置文件
bean标签基本配置
基本属性
<bean id="" class=""></bean>
* 用于配置对象交由Spring来创建。
* 基本属性：
id：Bean实例在Spring容器中的唯一标识
class：Bean的全限定名
* 默认情况下它调用的是类中的 无参构造函数，如果没有无参构造函数则不能创建成功
作用域配置
<bean id="" class="" scope=""></bean>
| 取值范围 | 说明 |
|---|---|
| singleton | 默认值，单例的 |
| prototype | 多例的 |
| request | WEB项目中，Spring创建一个Bean的对象，将对象存入到request域中 |
| session | WEB项目中，Spring创建一个Bean的对象，将对象存入到session域中 |
| global session | WEB项目中，Spring创建一个Bean的对象，将对象存入到session域中 |
1. 当scope的取值为singleton时
Bean的实例化个数：1个
Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例
Bean的生命周期：
对象创建：当应用加载，创建容器时，对象就被创建了
对象运行：只要容器在，对象一直活着
对象销毁：当应用卸载，销毁容器时，对象就被销毁了
2. 当scope的取值为prototype时
Bean的实例化个数：多个
Bean的实例化时机：当调用getBean()方法时实例化Bea
Bean的生命周期：
对象创建：当使用对象时，创建新的对象实例
对象运行：只要对象在使用中，就一直活着
对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了
测试多例 prototype
@Test
public void test3() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
//获取到了spring上下文对象，借助上下文对象可以获取IOC容器中的bean对象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//使用上下文对象从IOC容器中获取到了bean对象
IUserDao userDao1 = (IUserDao) applicationContext.getBean("userDao");
IUserDao userDao2 = (IUserDao) applicationContext.getBean("userDao");
//对比对象的地址值
System.out.println(userDao1);//com.soulboy.dao.impl.UserDaoImpl@6f43c82
System.out.println(userDao2);com.soulboy.dao.impl.UserDaoImpl@5db6b9cd
}
生命周期
配置
<bean id="userDao" class="com.soulboy.dao.impl.UserDaoImpl" scope="singleton" init-method="init" destroy-method="destory"> </bean>
测试类
@Test
public void test3() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
//获取到了spring上下文对象，借助上下文对象可以获取IOC容器中的bean对象
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//使用上下文对象从IOC容器中获取到了bean对象
IUserDao userDao1 = (IUserDao) applicationContext.getBean("userDao");
IUserDao userDao2 = (IUserDao) applicationContext.getBean("userDao");
//对比对象的地址值
System.out.println(userDao1);//com.soulboy.dao.impl.UserDaoImpl@6f43c82
System.out.println(userDao2);//com.soulboy.dao.impl.UserDaoImpl@5db6b9cd
//关闭容器
applicationContext.close();
}
输出
初始化方法执行了……
com.soulboy.dao.impl.UserDaoImpl@342c38f8
com.soulboy.dao.impl.UserDaoImpl@342c38f8
销毁方法执行了……
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
public class StaticFactoryBean {
public static UserDao createUserDao(){
return new UserDaoImpl();
}
}
applicationContext.xml
<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
public class DynamicFactoryBean {
public UserDao createUserDao(){
return new UserDaoImpl();
}
}
applicationContext.xml
<bean id="dynamicFactoryBean" class="com.lagou.factory.DynamicFactoryBean"/>
<bean id="userDao" factory-bean="dynamicFactoryBean" factory-method="createUserDao"/>
依赖注入
依赖注入 DI（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。
在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。
那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。简单的说，就是通过框架把持久层对象传入业务层，而不用我们自己去获取。
依赖注入的方式
构造方法注入
applicationContext.xml
<bean id="userDao" class="com.soulboy.dao.impl.UserDaoImpl"> </bean>
<bean id="userService" class="com.soulboy.service.impl.UserServiceImpl">
<!-- <constructor-arg index="0" type="com.soulboy.dao.IUserDao" ref="userDao"/>-->
<constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>
UserDaoImpl
public class UserDaoImpl implements IUserDao {
@Override
public void save() {
System.out.println("UserDaoImpl save successfully!");
}
}
UserServiceImpl
public class UserServiceImpl implements IUserService {
private IUserDao userDao;
public UserServiceImpl(IUserDao userDao) {
this.userDao = userDao;
}
@Override
public void save() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
//调用目标方法
userDao.save();
}
}
测试类
/**
* DI:构造方法注入
*/
@Test
public void test4() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
//获取到了spring上下文对象，借助上下文对象可以获取IOC容器中的bean对象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//使用上下文对象从IOC容器中获取到了bean对象
IUserService userService = (IUserService) applicationContext.getBean("userService");
//调用方法
userService.save();
}
set方法注入
applicationContext.xml
<bean id="userDao" class="com.soulboy.dao.impl.UserDaoImpl"> </bean>
<bean id="userService" class="com.soulboy.service.impl.UserServiceImpl">
<!-- <constructor-arg index="0" type="com.soulboy.dao.IUserDao" ref="userDao"/>-->
<!-- <constructor-arg name="userDao" ref="userDao"></constructor-arg> -->
<!-- set方法完成依赖注入 -->
<property name="userDao" ref="userDao"></property>
</bean>
UserDaoImpl
public class UserDaoImpl implements IUserDao {
@Override
public void save() {
System.out.println("UserDaoImpl save successfully!");
}
}
UserServiceImpl
public class UserServiceImpl implements IUserService {
private IUserDao userDao;
public IUserDao getUserDao() {
return userDao;
}
public void setUserDao(IUserDao userDao) {
this.userDao = userDao;
}
@Override
public void save() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
//调用目标方法
userDao.save();
}
}
测试类
/**
* DI:set方法注入
*/
@Test
public void test4() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
//获取到了spring上下文对象，借助上下文对象可以获取IOC容器中的bean对象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//使用上下文对象从IOC容器中获取到了bean对象
IUserService userService = (IUserService) applicationContext.getBean("userService");
//调用方法
userService.save();
}
P命名空间注入
命名空间注入本质也是set方法注入，但比起上述的set方法注入更加方便，主要体现在配置文件中，如下：
首先，需要引入P命名空间：
xmlns:p="http://www.springframework.org/schema/p"
其次，需要修改注入方式：
<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.lagou.service.impl.UserServiceImpl" p:userDao-ref="userDao"/>
依赖注入的数据类型
注入普通数据类型
applicationContext.xml
<bean id="student" class="com.soulboy.domain.Student">
<!-- value普通数据类型的注入, ref引用数据类型的注入 -->
<property name="age" value="18"/>
<property name="username" value="高中美"/>
</bean>
student
public class Student {
private String username;
private Integer age;
public void setUsername(String username) {
this.username = username;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"username='" + username + '\'' +
", age=" + age +
'}';
}
}
测试类
/**
* DI:注入普通数据类型
*/
@Test
public void test5() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
//获取到了spring上下文对象，借助上下文对象可以获取IOC容器中的bean对象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//使用上下文对象从IOC容器中获取到了bean对象
Student student = applicationContext.getBean("student", Student.class);
System.out.println(student);//Student{username='高中美', age=18}
}
List集合注入
applicationContext.xml
<bean id="user" class="com.soulboy.domain.User">
<property name="name" value="妞妞"></property>
<property name="age" value="28"></property>
</bean>
<bean id="student" class="com.soulboy.domain.Student">
<!-- value普通数据类型的注入, ref引用数据类型的注入 -->
<property name="age" value="18"/>
<property name="username" value="高中美"/>
<!-- List集合数据类型注入-->
<property name="list">
<list>
<value>aaa</value><!-- 注入普通数据类型字符串 -->
<ref bean="user"></ref>
</list>
</property>
</bean>
Student
private List<Object> list;
Set集合注入
applicationContext.xml
<bean id="user" class="com.soulboy.domain.User">
<property name="name" value="妞妞"></property>
<property name="age" value="28"></property>
</bean>
<bean id="student" class="com.soulboy.domain.Student">
<!-- value普通数据类型的注入, ref引用数据类型的注入 -->
<property name="age" value="18"/>
<property name="username" value="高中美"/>
<!-- Set集合数据类型注入-->
<property name="set">
<set>
<value>aaa</value><!-- 注入普通数据类型字符串 -->
<ref bean="user"></ref>
</set>
</property>
</bean>
Student
private Set<Object> set;
Array数组类型注入
applicationContext.xml
<bean id="user" class="com.soulboy.domain.User">
<property name="name" value="妞妞"></property>
<property name="age" value="28"></property>
</bean>
<bean id="student" class="com.soulboy.domain.Student">
<!-- value普通数据类型的注入, ref引用数据类型的注入 -->
<property name="age" value="18"/>
<property name="username" value="高中美"/>
<!-- Array数组数据类型注入-->
<property name="array">
<array>
<value>aaa</value><!-- 注入普通数据类型字符串 -->
<ref bean="user"></ref>
</array>
</property>
</bean>
Student
private Object[] array;
Map类型注入
applicationContext.xml
<bean id="user" class="com.soulboy.domain.User">
<property name="name" value="妞妞"></property>
<property name="age" value="28"></property>
</bean>
<bean id="student" class="com.soulboy.domain.Student">
<!-- value普通数据类型的注入, ref引用数据类型的注入 -->
<property name="age" value="18"/>
<property name="username" value="高中美"/>
<!-- Map类型注入-->
<property name="map">
<map>
<entry key="k1" value="ddd"></entry>
<entry key="k2" value-ref="user"></entry>
</map>
</property>
</bean>
Student
private Map<String, Object> map;
Properties类型注入
properties.xml
<bean id="user" class="com.soulboy.domain.User">
<property name="name" value="妞妞"></property>
<property name="age" value="28"></property>
</bean>
<bean id="student" class="com.soulboy.domain.Student">
<!-- value普通数据类型的注入, ref引用数据类型的注入 -->
<property name="age" value="18"/>
<property name="username" value="高中美"/>
<!-- Properties类型注入-->
<property name="properties">
<props>
<prop key="k1">v1</prop>
<prop key="k2">v2</prop>
<prop key="k3">v3</prop>
</props>
</property>
</bean>
student
private 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);
核心方法
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);
}
}
}
基于Spring的xml配置实现账户的CRUD案例
步骤分析：
1. 准备数据库环境
2. 创建java项目，导入坐标
3. 编写Account实体类
4. 编写AccountDao接口和实现类
5. 编写AccountService接口和实现类
6. 编写spring核心配置文件
7. 编写测试代码
准备数据库环境
CREATE DATABASE `spring_db`;
USE `spring_db`;
CREATE TABLE `account` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(32) DEFAULT NULL,
`money` double DEFAULT NULL,
PRIMARY KEY (`id`)
) ;
insert into `account`(`id`,`name`,`money`) values (1,'tom',1000),
(2,'jerry',1000);
创建java项目，导入坐标
<!--指定编码及版本-->
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.encoding>UTF-8</maven.compiler.encoding>
<java.version>11</java.version>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</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>
Account实体类
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 +
'}';
}
}
编写AccountDao接口和实现类
AccountDao
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);
}
AccountDaoImpl
public class AccountDaoImpl implements AccountDao {
private QueryRunner queryRunner;
public void setQueryRunner(QueryRunner queryRunner) {
this.queryRunner = queryRunner;
}
/**
* 查询所有记录
* @return List<Account>
*/
@Override
public List<Account> findAll() {
List<Account> list = null;
//编写sql
String sql = "select * from account";
try{
//执行sql
list = queryRunner.query(sql, new BeanListHandler<Account>(Account.class));
} catch (SQLException e) {
throw new RuntimeException(e);
}
return list;
}
/**
* 通过id查询
* @return Account
*/
@Override
public Account findById(Integer id) {
Account account = null;
String sql = "select * from account where id = ?";
try {
account = queryRunner.query(sql, new BeanHandler<Account>(Account.class),id);
} catch (SQLException e) {
e.printStackTrace();
}
return account;
}
/**
* 添加记录
* @return
*/
@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();
}
}
/**
* 更新记录
* @return
*/
@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();
}
}
/**
* 删除记录
* @return
*/
@Override
public void delete(Integer id) {
String sql = "delete from account where id = ?";
try {
queryRunner.update(sql, id);
} catch (SQLException e) {
e.printStackTrace();
}
}
}
编写AccountService接口和实现类
AccountService
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);
}
AccountServiceImpl
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);
}
}
编写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
">
<!--加载jdbc.properties文件-->
<context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
<!--在DruidDataSource连接池中设置dataSource-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--把数据库连接池交给IOC容器-->
<!--<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver">
</property>
<property name="url" value="jdbc:mysql://localhost:50000/spring_db">
</property>
<property name="username" value="root"></property>
<property name="password" value="123456"></property>
</bean>-->
<!-- QueryRunner: 利用有参构造函数注入dataSource -->
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
<constructor-arg name="ds" ref="dataSource"></constructor-arg>
</bean>
<!--AccountDao: AccountDaoImpl的queryRunner属性需要注入-->
<bean id="accountDao" class="com.soulboy.dao.impl.AccountDaoImpl">
<property name="queryRunner" ref="queryRunner"></property>
</bean>
<!--AccountService: AccountServiceImpl的accountDao属性需要注入-->
<bean id="accountService" class="com.soulboy.service.impl.AccountServiceImpl">
<property name="accountDao" ref="accountDao"></property>
</bean>
</beans>
编写properties文件
src/main/resources/jdbc.properties
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:50000/spring_db
jdbc.username=root
jdbc.password=123456
编写测试代码
AccountServiceTest
package com.soulboy.test;
import com.soulboy.domain.Account;
import com.soulboy.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 accountService = applicationContext.getBean(AccountService.class);
/**
* 测试保存
*/
@Test
public void testSave(){
Account account = new Account();
account.setName("高中美");
account.setMoney(100d);
accountService.save(account);
}
/**
* 测试基于id查询
*/
@Test
public void testFindById(){
Account account = accountService.findById(3);
System.out.println(account);
}
/**
* 测试查询所有
*/
@Test
public void testFindAll(){
List<Account> accounts = accountService.findAll();
for (Account account : accounts) {
System.out.println(account);
}
}
/**
* 测试更新记录
*/
@Test
public void testUpdateById(){
Account account = new Account();
account.setId(1);
account.setName("妞妞");
account.setMoney(20000D);
accountService.update(account);
}
/**
* 测试删除(基于id)
*/
@Test
public void testDeleteById(){
accountService.delete(2);
}
}
总结
* DataSource的创建权交由Spring容器去完成
* QueryRunner的创建权交由Spring容器去完成，使用构造方法传递DataSource
* Spring容器加载properties文件
<context:property-placeholder location="xx.properties"/>
<property name="" value="${key}"/>
注解开发
Spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml配置文件可以简化配置，提高开发效率。
| 注解 | 说明 |
|---|---|
| @Component | 使用在类上用于实例化Bean |
| Controller | 使用在web层类上用于实例化Bean |
| @Service | 使用在service层类上用于实例化Bean |
| @Repository | 使用在dao层类上用于实例化Bean |
| @Autowired | 使用在字段上用于根据类型依赖注入 |
| @Qualifier | 结合@Autowired一起使用,根据名称进行依赖注入，不能单独使用 |
| @Resource | 相当于@Autowired+@Qualifier，按照名称进行注入，javax包的扩展包，需要导入依赖坐标 |
| @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
<!--注解的组件扫描-->
<context:component-scan base-package="com.soulboy"></context:component-scan>
基于注解整合Dbutils
核心配置文件
<?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.soulboy"></context:component-scan>
<!--加载jdbc.properties文件-->
<context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
<!--在DruidDataSource连接池中设置dataSource-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--QueryRunner-->
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
<constructor-arg name="ds" ref="dataSource"></constructor-arg>
</bean>
</beans>
DAO
package com.soulboy.dao.impl;
import com.soulboy.dao.AccountDao;
import com.soulboy.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("accountDao")
public class AccountDaoImpl implements AccountDao {
@Autowired
private QueryRunner queryRunner;
public void setQueryRunner(QueryRunner queryRunner) {
this.queryRunner = queryRunner;
}
/**
* 查询所有记录
* @return List<Account>
*/
@Override
public List<Account> findAll() {
List<Account> list = null;
//编写sql
String sql = "select * from account";
try{
//执行sql
list = queryRunner.query(sql, new BeanListHandler<Account>(Account.class));
} catch (SQLException e) {
throw new RuntimeException(e);
}
return list;
}
/**
* 通过id查询
* @return Account
*/
@Override
public Account findById(Integer id) {
Account account = null;
String sql = "select * from account where id = ?";
try {
account = queryRunner.query(sql, new BeanHandler<Account>(Account.class),id);
} catch (SQLException e) {
e.printStackTrace();
}
return account;
}
/**
* 添加记录
* @return
*/
@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();
}
}
/**
* 更新记录
* @return
*/
@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();
}
}
/**
* 删除记录
* @return
*/
@Override
public void delete(Integer id) {
String sql = "delete from account where id = ?";
try {
queryRunner.update(sql, id);
} catch (SQLException e) {
e.printStackTrace();
}
}
}
Service
package com.soulboy.service.impl;
import com.soulboy.dao.AccountDao;
import com.soulboy.domain.Account;
import com.soulboy.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 java.util.List;
@Service("accountService")
public class AccountServiceImpl implements AccountService {
@Autowired
@Qualifier("accountDao")
private AccountDao accountDao;
@Value("注入普通属性")
private String str;
@Value("${jdbc.driverClassName}")
private String driver;
@Override
public List<Account> findAll() {
System.out.println(str);//注入普通属性
System.out.println(driver);//com.mysql.jdbc.Driver
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);
}
}
测试类
package com.soulboy.test;
import com.soulboy.domain.Account;
import com.soulboy.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 accountService = applicationContext.getBean(AccountService.class);
/**
* 测试保存
*/
@Test
public void testSave(){
Account account = new Account();
account.setName("高中美");
account.setMoney(100d);
accountService.save(account);
}
/**
* 测试基于id查询
*/
@Test
public void testFindById(){
Account account = accountService.findById(3);
System.out.println(account);
}
/**
* 测试查询所有
*/
@Test
public void testFindAll(){
List<Account> accounts = accountService.findAll();
for (Account account : accounts) {
System.out.println(account);
}
}
/**
* 测试更新记录
*/
@Test
public void testUpdateById(){
Account account = new Account();
account.setId(1);
account.setName("妞妞");
account.setMoney(20000D);
accountService.update(account);
}
/**
* 测试删除(基于id)
*/
@Test
public void testDeleteById(){
accountService.delete(2);
}
}
Spring纯注解整合Dbutils
使用上面的注解还不能全部替代xml配置文件，还需要使用注解替代的配置如下：
* 非自定义的Bean的配置：<bean>
* 加载properties文件的配置：<context:property-placeholder>
* 组件扫描的配置：<context:component-scan>
* 引入其他文件：<import>
| 注解 | 说明 |
|---|---|
| @Configuration | 用于指定当前类是一个Spring 配置类，当创建容器时会从该类上加载注解 |
| @Bean | 使用在方法上，标注将该方法的返回值存储到 Spring 容器中 |
| @PropertySource | 用于加载 properties 文件中的配置 |
| @ComponentScan | 用于指定 Spring 在初始化容器时要扫描的包 |
| @Import | 用于导入其他配置类 |
步骤分析
- 编写Spring核心配置类
SpringConfig
package com.soulboy.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.soulboy")
@Import(DataSourceConfig.class)
public class SpringConfig {
@Bean("queryRunner")
public QueryRunner getQueryRunner(@Autowired DataSource dataSource) {
QueryRunner queryRunner = new QueryRunner(dataSource);
return queryRunner;
}
}
- 编写数据库配置信息类
DataSourceConfig
package com.soulboy.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;
}
}
- 编写测试代码
AccountServiceTest
package com.soulboy.test;
import com.soulboy.config.SpringConfig;
import com.soulboy.domain.Account;
import com.soulboy.service.AccountService;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import java.util.List;
public class AccountServiceTest {
//ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//ccountService accountService = applicationContext.getBean(AccountService.class);
// 纯注解形式
AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
AccountService accountService = (AccountService)annotationConfigApplicationContext.getBean("accountService");
/**
* 测试保存
*/
@Test
public void testSave() {
Account account = new Account();
account.setName("高中美");
account.setMoney(100d);
accountService.save(account);
}
/**
* 测试基于id查询
*/
@Test
public void testFindById() {
Account account = accountService.findById(3);
System.out.println(account);
}
/**
* 测试查询所有
*/
@Test
public void testFindAll() {
List<Account> accounts = accountService.findAll();
for (Account account : accounts) {
System.out.println(account);
}
}
/**
* 测试更新记录
*/
@Test
public void testUpdateById() {
Account account = new Account();
account.setId(1);
account.setName("妞妞");
account.setMoney(20000D);
accountService.update(account);
}
/**
* 测试删除(基于id)
*/
@Test
public void testDeleteById() {
accountService.delete(2);
}
}
Spring整合Junit
在普通的测试类中，需要开发者手动加载配置文件并创建Spring容器，然后通过Spring相关API获得Bean实例；如果不这么做，那么无法从容器中获得对象。
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
AccountService accountService =applicationContext.getBean(AccountService.class);
我们可以让SpringJunit负责创建Spring容器来简化这个操作，开发者可以直接在测试类注入Bean实例；但是需要将配置文件的名称告诉它。
- 导入spring集成Junit的坐标
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<!--此处需要注意的是，spring5 及以上版本要求 junit 的版本必须是 4.12 及以上-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
- 使用@Runwith注解替换原来的运行器
- 使用@ContextConfiguration指定配置文件或配置类
- 使用@Autowired注入需要测试的对象
- 创建测试方法进行测试
SpringJunitTest
package com.soulboy.test;
import com.soulboy.config.SpringConfig;
import com.soulboy.domain.Account;
import com.soulboy.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SpringConfig.class}) // 加载spring核心配置类
public class SpringJunitTest {
@Autowired
private AccountService accountService;
@Test
public void testfindAll(){
List<Account> accounts = accountService.findAll();
for (Account account : accounts) {
System.out.println(account);
}
}
}
没有AOP的转账案例
使用spring框架整合DBUtils技术，实现用户转账功能
步骤分析
- 创建java项目，导入坐标
- 编写Account实体类
- 编写AccountDao接口和实现类
- 编写AccountService接口和实现类
- 编写spring核心配置文件
- 编写测试代码
1）创建java项目，导入坐标，创建数据库并插入数据
<!--指定编码及版本-->
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.encoding>UTF-8</maven.compiler.encoding>
<java.version>11</java.version>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</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>
<!--此处需要注意的是，spring5 及以上版本要求 junit 的版本必须是 4.12 及以上-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
</dependencies>
SQL语句
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 (5,'tom',1000),(6,'jerry',1000)
2） 编写Account实体类
Account
package com.soulboy.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 +
'}';
}
}
3）编写AccountDao接口和实现类
AccountDao
public interface AccountDao {
// 转出操作
public void out(String outUser,Double money);
// 转入操作
public void in(String inUser, Double money);
}
AccountDaoImpl
package com.soulboy.dao.impl;
import com.soulboy.dao.AccountDao;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import java.sql.SQLException;
@Repository("accountDao") // 生成该类实例存到IOC容器中
public class AccountDaoImpl implements AccountDao {
@Autowired
private QueryRunner queryRunner;
/*
转出操作
*/
@Override
public void out(String outUser, Double money) {
String sql = "update account set money = money - ? where name = ?";
try {
queryRunner.update(sql, money, outUser);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
/*
转入操作
*/
@Override
public void in(String inUser, Double money) {
String sql = "update account set money = money + ? where name = ?";
try {
queryRunner.update(sql, money, inUser);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}
4）编写AccountService接口和实现类
AccountService
package com.soulboy.service;
public interface AccountService {
// 转账方法
public void transfer(String outUser, String inUser, Double money);
}
AccountServiceImpl
package com.soulboy.service.impl;
import com.soulboy.dao.AccountDao;
import com.soulboy.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service("accountService")
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
/*
转账方法
*/
@Override
public void transfer(String outUser, String inUser, Double money) {
//减钱
accountDao.out(outUser, money);
//加钱
accountDao.in(inUser, money);
}
}
5）编写spring核心配置文件和properties文件
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.soulboy"/>
<!-- 加载jdbc配置文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--把数据库连接池交给IOC容器-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--把QueryRunner交给IOC容器-->
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
<constructor-arg name="ds" ref="dataSource"></constructor-arg>
</bean>
</beans>
jdbc.properties
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:50000/spring_db?useSSL=false
jdbc.username=root
jdbc.password=123456
6）编写测试代码
AccountServiceTest
package com.soulboy.test;
import com.soulboy.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class AccountServiceTest {
@Autowired
private AccountService accountService;
@Test
public void testTransfer() {
accountService.transfer("妞妞", "超蛋", 200d);
}
}
7）问题分析
上面的代码事务在dao层，转出转入操作都是一个独立的事务，但实际开发，应该把业务逻辑控制在一个事务中，所以应该将事务挪到service层。
传统事务
步骤分析
- 编写线程绑定工具类（连接工具类：从数据源中获取一个连接，并且将获取到的连接与线程进行绑定，在同一个connection中使用转账的两个方法in&out
- 编写事务管理器
- 修改service层代码
- 修改dao层代码
1）编写线程绑定工具类
ConnectionUtils
package com.soulboy.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
/*
连接工具类：从数据源中获取一个连接，并且将获取到的连接与线程进行绑定，在同一个connection中使用转账的两个方法
*/
@Component
public class ConnectionUtils {
@Autowired
private DataSource dataSource;
// ThreadLocal:线程内部的存储类，可以在指定线程内，存储数据。
private ThreadLocal<Connection> threadLocal = new ThreadLocal<>();
/**
* 获取当前线程上的连接:如果获取到的连接为空，那么就要从数据源中获取连接，并且放到ThreadLocal中(绑定到当前线程)
*
* @return Connection
*/
public Connection getThreadConnection() {
// 1.先从ThreadLocal上获取
Connection connection = threadLocal.get();
// 2.判断当前线程是否有连接
if (connection == null) {
try {
// 3.从数据源中获取一个连接，并存入到ThreadLocal中
connection = dataSource.getConnection();
threadLocal.set(connection);
} catch (SQLException e) {
e.printStackTrace();
}
}
return connection;
}
/**
* 解除当前线程的连接绑定
*/
public void removeThreadConnection() {
threadLocal.remove();
}
}
2）编写事务管理器
TransactionManager
package com.soulboy.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.sql.SQLException;
/**
* 事务管理器工具类，包含：开启事务、提交事务、回滚事务、释放资源
*/
@Component
public class TransactionManager {
@Autowired
private ConnectionUtils connectionUtils;
public void beginTransaction() {
try {
connectionUtils.getThreadConnection().setAutoCommit(false);
} catch (SQLException e) {
e.printStackTrace();
}
}
public void commit() {
try {
connectionUtils.getThreadConnection().commit();
} catch (SQLException e) {
e.printStackTrace();
}
}
public void rollback() {
try {
connectionUtils.getThreadConnection().rollback();
} catch (SQLException e) {
e.printStackTrace();
}
}
public void release() {
try {
connectionUtils.getThreadConnection().setAutoCommit(true); // 改回自动提交事务
connectionUtils.getThreadConnection().close();// 归还到连接池
connectionUtils.removeThreadConnection();// 解除线程绑定
} catch (SQLException e) {
e.printStackTrace();
}
}
}
3）修改service层代码
AccountServiceImpl
package com.soulboy.service.impl;
import com.soulboy.dao.AccountDao;
import com.soulboy.service.AccountService;
import com.soulboy.utils.TransactionManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service("accountService")
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
@Autowired
private TransactionManager transactionManager;
/*
转账方法
*/
@Override
public void transfer(String outUser, String inUser, Double money) {
try {
// 开启事务
transactionManager.beginTransaction();
//减钱
accountDao.out(outUser, money);
int i=1/0;
//加钱
accountDao.in(inUser, money);
// 提交事务
transactionManager.commit();
} catch (Exception e) {
e.printStackTrace();
// 回滚事务
transactionManager.rollback();
} finally {
// 释放资源
transactionManager.release();
}
}
}
4）修改dao层代码
AccountDaoImpl
package com.soulboy.dao.impl;
import com.soulboy.dao.AccountDao;
import com.soulboy.utils.ConnectionUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import java.sql.SQLException;
@Repository("accountDao") // 生成该类实例存到IOC容器中
public class AccountDaoImpl implements AccountDao {
@Autowired
private QueryRunner queryRunner;
@Autowired
private ConnectionUtils connectionUtils;
/*
转出操作
*/
@Override
public void out(String outUser, Double money) {
String sql = "update account set money = money - ? where name = ?";
try {
queryRunner.update(connectionUtils.getThreadConnection(),sql, money, outUser);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
/*
转入操作
*/
@Override
public void in(String inUser, Double money) {
String sql = "update account set money = money + ? where name = ?";
try {
queryRunner.update(connectionUtils.getThreadConnection(),sql, money, inUser);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}
5）问题分析
上面代码，通过对业务层改造，已经可以实现事务控制了，但是由于我们添加了事务控制，也产生了一个新的问题： 业务层方法变得臃肿了，里面充斥着很多重复代码。并且业务层方法和事务控制方法耦合了，违背了面向对象的开发思想。
Proxy优化转账案例
我们可以将业务代码和事务代码进行拆分，通过动态代理的方式，对业务方法进行事务的增强。这样就不会对业务层产生影响，解决了事务管理代码与业务层代码耦合的问题。
常用的动态代理技术
JDK 代理 : 基于接口的动态代理技术·：利用拦截器（必须实现invocationHandler）加上反射机制生成一个代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理，从而实现方法增强。
CGLIB代理：基于父类的动态代理技术：动态生成一个要代理的子类，子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截技术拦截所有的父类方法的调用，顺势织入横切逻辑，对方法进行增强。
| 代理方式 | 底层原理 | 说明 | 性能对比 |
|---|---|---|---|
| JDK动态代理 | 拦截的方式，通过反射获取模版借口名字、内部方法及参数，再原来的接口上修改，生成一个新的java代理对象：1、拼接java源代码；2、编译为class文件；3、类加载器加载新的class到内存中；4、通过反射执行方法(invoke) | 生成的代理对象不能直接调用被代理对象的方法，而是通过反射，每次调用都需要反射，执行效率不高 | jdk动态代理生成代理类速度快，执行目标方法慢，启动速度比CGLIB快8倍 |
| CGLIB动态代理 | CGLIB采用动态继承的方式，底层基于asm字节码技术，生成一个新的Java代理对象，Cglib代理实际上是通过继承，也就是生成一个纵承被代理对象的类，编译成Class文件时还会额外生成一个fastclass文件，该文件记录各个method的class索(类名+方法名+参数)，当执行某个方法时，通过计算索引，定位到具体的方法，代理对象执行该方法，然后super调用父类(执行了被代理对象的方法)。生成代理对象时通过fastcass索引机制直接定位到被代理对象的class文件，从而实现反复调用，等于说是class复用，每次都是直接拿被代理对专的class内容执行的 | 1W执行下，JDK7、8的动态代理性能比CGLIB要好20%左右，JDK每次版本升级性能都会提升，CGLIB仍止步不前 | CGLIB动态代理生成代理类速度慢，执行目标方法快，执行速度比JDK快10倍 |
JDK代理
被代理类 AccountServiceImpl
package com.soulboy.service.impl;
import com.soulboy.dao.AccountDao;
import com.soulboy.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service("accountService")
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
/*
转账方法
*/
@Override
public void transfer(String outUser, String inUser, Double money) {
//减钱
accountDao.out(outUser, money);
//int i=1/0;
//加钱
accountDao.in(inUser, money);
}
}
代理类 JDKProxyFactory
package com.soulboy.proxy;
import com.soulboy.service.AccountService;
import com.soulboy.utils.TransactionManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
@Component
public class JDKProxyFactory {
@Autowired
private AccountService accountService; //注入AccountServiceImpl对象实例
@Autowired
private TransactionManager transactionManager;
/*
采用动态代理技术生成目标类的代理对象
*/
public AccountService createAccountServiceJDKProxy() {
/*
ClassLoader loader：类加载器：借助被代理对象获取到类加载器
Class<?>[] interfaces：被代理类所需要实现的全部接口
InvocationHandler h：当代理对象调用接口中的任意方法时，那么都会执行InvocationHandler中的invoke方法
*/
AccountService accountServiceProxy =(AccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
accountService.getClass().getInterfaces(),
new InvocationHandler() { //匿名内部类
//proxy: 代理对象的引用
//method: 被调用的目标方法的引用
//args: 被调用的目标方法所用到的参数
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
// 开启事务
transactionManager.beginTransaction();
//让被代理对象的原方法执行
method.invoke(accountService, args);
// 提交事务
transactionManager.commit();
} catch (Exception e) {
e.printStackTrace();
// 回滚事务
transactionManager.rollback();
} finally {
// 释放资源
transactionManager.release();
}
return null;
}
});
return accountServiceProxy;
}
}
测试类 AccountServiceTest
package com.soulboy.test;
import com.soulboy.proxy.CglibProxyFactory;
import com.soulboy.proxy.JDKProxyFactory;
import com.soulboy.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class AccountServiceTest {
@Autowired
private AccountService accountService;
@Autowired
private JDKProxyFactory jdkProxyFactory;
@Autowired
private CglibProxyFactory cglibProxyFactory;
@Test
public void testTransfer() {
accountService.transfer("妞妞", "超蛋", 200d);
}
@Test
public void testTransferJDKProxy(){
//当前返回的实际上是AccountService的代理对象
AccountService accountServiceJDKProxy = jdkProxyFactory.createAccountServiceJDKProxy();
//代理对象proxy调用接口中的任意方法时，都会执行底层的invoke方法
accountServiceJDKProxy.transfer("妞妞", "超蛋", 200d);
}
@Test
public void testTransferCglibProxy(){
//acccountServiceCglibProxy:proxy
AccountService acccountServiceCglibProxy = cglibProxyFactory.createAcccountServiceCglibProxy();
//调用目标方法
acccountServiceCglibProxy.transfer("妞妞", "超蛋", 200d);
}
}
Cglib代理
目标类 AccountServiceImpl
package com.soulboy.service.impl;
import com.soulboy.dao.AccountDao;
import com.soulboy.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service("accountService")
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
/*
转账方法
*/
@Override
public void transfer(String outUser, String inUser, Double money) {
//减钱
accountDao.out(outUser, money);
//int i=1/0;
//加钱
accountDao.in(inUser, money);
}
}
代理类 CglibProxyFactory
package com.soulboy.proxy;
import com.soulboy.service.AccountService;
import com.soulboy.utils.TransactionManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
/*
该类就是采用cglib动态代理来对目标类(AccountServiceImpl)进行方法的动态增强（添加事务控制）
*/
@Component
public class CglibProxyFactory {
@Autowired
private AccountService accountService;
@Autowired
private TransactionManager transactionManager;
public AccountService createAcccountServiceCglibProxy(){
//编写cglib对应的API来生成代理对象进行返回
//参数1: 目标类的字节码对象(AccountService)
//参数2: 动作类,当代理对象调用目标对象中原方法时，那么会执行intercept方法
AccountService accountServiceProxy = (AccountService)Enhancer.create(accountService.getClass(), new MethodInterceptor() {
// o: 生成的代理对象
// method: 调用目标方法的引用
// methodProxy: 代理方法
// objects: 方法入参
// methodProxy: 代理方法
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
try {
// 开启事务
transactionManager.beginTransaction();
//执行目标方法
method.invoke(accountService, objects);
// 提交事务
transactionManager.commit();
} catch (Exception e) {
e.printStackTrace();
// 回滚事务
transactionManager.rollback();
} finally {
// 释放资源
transactionManager.release();
}
return null;
}
});
return accountServiceProxy;
}
}
测试类 AccountServiceTest
package com.soulboy.test;
import com.soulboy.proxy.CglibProxyFactory;
import com.soulboy.proxy.JDKProxyFactory;
import com.soulboy.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class AccountServiceTest {
@Autowired
private AccountService accountService;
@Autowired
private JDKProxyFactory jdkProxyFactory;
@Autowired
private CglibProxyFactory cglibProxyFactory;
@Test
public void testTransfer() {
accountService.transfer("妞妞", "超蛋", 200d);
}
@Test
public void testTransferJDKProxy(){
//当前返回的实际上是AccountService的代理对象
AccountService accountServiceJDKProxy = jdkProxyFactory.createAccountServiceJDKProxy();
//代理对象proxy调用接口中的任意方法时，都会执行底层的invoke方法
accountServiceJDKProxy.transfer("妞妞", "超蛋", 200d);
}
@Test
public void testTransferCglibProxy(){
//acccountServiceCglibProxy:proxy
AccountService acccountServiceCglibProxy = cglibProxyFactory.createAcccountServiceCglibProxy();
//调用目标方法
acccountServiceCglibProxy.transfer("妞妞", "超蛋", 200d);
}
}
AOP
AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程
AOP 是 OOP（面向对象编程） 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。这样做的好处是：
- 在程序运行期间，在不修改源码的情况下对方法进行功能增强
- 逻辑清晰，开发核心业务的时候，不必关注增强业务的代码
- 减少重复代码，提高开发效率，便于后期维护
AOP底层实现
实际上，AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。
AOP相关术语
Spring 的 AOP 实现底层就是对上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。
| 方法名 | 描述 |
|---|---|
| Target（目标对象） | 被代理类（AccountServiceImpl） |
| Proxy （代理） | 一个类被 AOP 织入增强后，就产生一个结果代理类 |
| Joinpoint（连接点） | 所谓连接点是指那些可以被拦截到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点 |
| Pointcut（切入点） | 真正被拦截增强的方法，所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义 |
| Advice（通知/ 增强） | 增强的业务逻辑代码，所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知分类：前置通知、后置通知、异常通知、最终通知、环绕通知 |
| Aspect（切面） | 是切入点和通知（引介）的结合 |
| Weaving（织入） | 是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入 |
AOP开发明确事项
- 编写核心业务代码（目标类的目标方法） 切入点
- 把公用代码抽取出来，制作成通知（增强功能方法） 通知
- 在配置文件中，声明切入点与通知间的关系，即切面
运行阶段（Spring框架完成的）
Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。
底层代理实现
在 Spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。
- 当bean实现接口时，会用JDK代理模式
- 当bean没有实现接口，用cglib实现（ 可以强制使用cglib（在spring配置中加入）
基于XML的AOP开发
步骤分析
- 创建java项目，导入AOP相关坐标
- 创建目标接口和目标实现类（定义切入点）
- 创建通知类及方法（定义通知）
- 将目标类和通知类对象创建权交给spring
- 在核心配置文件中配置织入关系，及切面
- 编写测试代码
- 创建java项目，导入AOP相关坐标
<!--指定编码及版本-->
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.encoding>UTF-8</maven.compiler.encoding>
<java.version>11</java.version>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
</properties>
<dependencies>
<!--导入spring的context坐标，context依赖aop-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<!-- aspectj的织入（切点表达式需要用到该jar包） -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.14</version>
</dependency>
<!--此处需要注意的是，spring5 及以上版本要求 junit 的版本必须是 4.12 及以上-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
</dependencies>
- 创建目标接口和目标实现类（定义切入点）
AccountService
package com.soulboy.service;
public interface AccountService {
/*
目标方法:(切入点:要进行拦截增强的方法)
*/
public void transfer();
}
AccountServiceImpl
package com.soulboy.service.impl;
import com.soulboy.service.AccountService;
public class AccountServiceImpl implements AccountService {
/*
目标方法:(切入点:要进行拦截增强的方法)
*/
@Override
public void transfer() {
System.out.println("转账了……");
}
}
- 创建通知类及方法（定义通知）
MyAdvice
package com.soulboy.advice;
import org.springframework.stereotype.Component;
/*
通知类
*/
public class MyAdvice {
public void before(){
System.out.println("前置通知执行了……");
}
}
- 将目标类和通知类对象创建权交给spring
<!-- 目标类交给IOC容器 -->
<bean id="accountService" class="com.soulboy.service.impl.AccountServiceImpl"></bean>
<!-- 通知类交给IOC容器 -->
<bean id="myAdvice" class="com.soulboy.advice.MyAdvice"></bean>
- 在核心配置文件中配置织入关系，及切面
src/main/resources/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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 目标类交给IOC容器 -->
<bean id="accountService" class="com.soulboy.service.impl.AccountServiceImpl"></bean>
<!-- 通知类交给IOC容器 -->
<bean id="myAdvice" class="com.soulboy.advice.MyAdvice"></bean>
<!-- aop配置 -->
<aop:config>
<!-- 引入通知类 -->
<aop:aspect ref="myAdvice">
<!-- 配置目标类的transfer方法执行时，使用通知类的before方法进行前置增强-->
<aop:before method="before"
pointcut="execution(public void
com.soulboy.service.impl.AccountServiceImpl.transfer())"/>
</aop:aspect>
</aop:config>
</beans>
- 编写测试代码
AccountServiceTest
package com.soulboy.test;
import com.soulboy.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class AccountServiceTest {
@Autowired
private AccountService accountService;
@Test
public void testTransfer(){
accountService.transfer();
}
}
前置通知执行了……
转账了……
切点表达式
表达式语法：execution([修饰符] 返回值类型 包名.类名.方法名(参数))
-
访问修饰符可以省略
-
返回值类型、包名、类名、方法名可以使用星号 * 代替，代表任意
-
包名与类名之间一个点 . 代表当前包下的类，两个点 .. 表示当前包及其子包下的类
-
参数列表可以使用两个点 .. 表示任意个数，任意类型的参数列表
参考用例：
execution(public void com.lagou.service.impl.AccountServiceImpl.transfer()) execution(void com.lagou.service.impl.AccountServiceImpl.*(..)) execution(* com.lagou.service.impl.*.*(..)) execution(* com.lagou.service..*.*(..))
切点表达式抽取
当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用 pointcut-ref 属性代替pointcut 属性来引用抽取后的切点表达式。
<?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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 目标类交给IOC容器 -->
<bean id="accountService" class="com.soulboy.service.impl.AccountServiceImpl"></bean>
<!-- 通知类交给IOC容器 -->
<bean id="myAdvice" class="com.soulboy.advice.MyAdvice"></bean>
<!-- aop配置 -->
<aop:config>
<!--抽取的切点表达式-->
<aop:pointcut id="myPointcut" expression="execution(* com.soulboy.service..*.*(..))"/>
<aop:aspect ref="myAdvice">
<aop:before method="before" pointcut-ref="myPointcut"></aop:before>
</aop:aspect>
</aop:config>
</beans>
通知类型
通知的配置语法：<aop:通知类型 method=“通知类中方法名” pointcut=“切点表达式"></aop:通知类型>
| 名称 | 标签 | 说明 |
|---|---|---|
| 前置通知 | aop:before | 用于配置前置通知。指定增强的方法在切入点方法之前执行 |
| 后置通知 | aop:afterReturning | 用于配置后置通知。指定增强的方法在切入点方法之后执行，后置通知和异常通知只会有一个生效 |
| 异常通知 | aop:afterThrowing | 用于配置异常通知。指定增强的方法出现异常后执行，后置通知和异常通知只会有一个生效 |
| 最终通知 | aop:after | 用于配置最终通知。无论切入点方法执行时是否有异常，都会执行 |
| 环绕通知 | aop:around | 用于配置环绕通知。开发者可以手动控制增强代码在什么时候执行 |
注意：通常情况下，环绕通知都是独立使用的
使用示例
通知类MyAdvice
package com.soulboy.advice;
import org.aspectj.lang.ProceedingJoinPoint;
/*
通知类
*/
public class MyAdvice {
public void before(){
System.out.println("前置通知执行了……");
}
public void afterReturning(){
System.out.println("后置通知执行了……");
}
public void after(){
System.out.println("最终通知执行了……");
}
public void afterThrowing(){
System.out.println("异常通知执行了……");
}
/*
ProceedingJoinPoint：正在执行的连接点:切点
*/
public Object around(ProceedingJoinPoint pjp){
Object proceed =null;
//切点方法执行
try {
System.out.println("前置通知执行了……");
proceed = pjp.proceed();
System.out.println("后置通知执行了……");
} catch (Throwable e) {
e.printStackTrace();
System.out.println("异常通知执行了……");
} finally {
System.out.println("最终通知执行了……");
}
return proceed;
}
}
src/main/resources/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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 目标类交给IOC容器 -->
<bean id="accountService" class="com.soulboy.service.impl.AccountServiceImpl"></bean>
<!-- 通知类交给IOC容器 -->
<bean id="myAdvice" class="com.soulboy.advice.MyAdvice"></bean>
<!-- aop配置 -->
<aop:config>
<!--抽取的切点表达式-->
<aop:pointcut id="myPointcut" expression="execution(* com.soulboy.service..*.*(..))"/>
<aop:aspect ref="myAdvice">
<aop:before method="before" pointcut-ref="myPointcut"></aop:before>
<aop:after-returning method="afterReturning" pointcut-ref="myPointcut"/>
<aop:after-throwing method="afterThrowing" pointcut-ref="myPointcut"/>
<aop:after method="after" pointcut-ref="myPointcut"/>
<!--<aop:around method="around" pointcut-ref="myPointcut"/>-->
</aop:aspect>
</aop:config>
</beans>
测试结果
前置通知执行了……
转账了……
后置通知执行了……
最终通知执行了……
基于注解的AOP开发
注意
当前四个通知组合在一起时，执行顺序如下： @Before -> 切入点->@After -> @AfterReturning（如果有异常：@AfterThrowing）
步骤分析
1. 创建java项目，导入AOP相关坐标
2. 创建目标接口和目标实现类（定义切入点）
3. 创建通知类（定义通知）
4. 将目标类和通知类对象创建权交给spring
5. 在通知类中使用注解配置织入关系，升级为切面类
6. 在配置文件中开启组件扫描和 AOP 的自动代理
7. 编写测试代码
- 创建java项目，导入AOP相关坐标
<!--指定编码及版本-->
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.encoding>UTF-8</maven.compiler.encoding>
<java.version>11</java.version>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
</properties>
<dependencies>
<!--导入spring的context坐标，context依赖aop-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<!-- aspectj的织入（切点表达式需要用到该jar包） -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.14</version>
</dependency>
<!--spring整合junit-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<!--此处需要注意的是，spring5 及以上版本要求 junit 的版本必须是 4.12 及以上-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
- 创建目标接口和目标实现类（定义切入点），并交由Spring容器管理
AccountService
package soulboy.service;
public interface AccountService {
/*
目标方法:(切入点:要进行拦截增强的方法)
*/
public void transfer();
}
AccountServiceImpl
package com.soulboy.service.impl;
import com.soulboy.service.AccountService;
import org.springframework.stereotype.Service;
@Service
public class AccountServiceImpl implements AccountService {
/*
目标方法:(切入点:要进行拦截增强的方法)
*/
@Override
public void transfer() {
System.out.println("转账了……");
}
}
- 创建通知类（定义通知），并交由Spring容器管理
MyAdvice
package com.soulboy.advice;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
/*
通知类
*/
@Component
@Aspect
public class MyAdvice {
@Pointcut("execution (* com.soulboy..*.*(..))")
public void myPoint(){}
@Before("MyAdvice.myPoint()")
public void before(){
System.out.println("前置通知执行了……");
}
@AfterReturning("MyAdvice.myPoint()")
public void afterReturning(){
System.out.println("后置通知执行了……");
}
@After("MyAdvice.myPoint()")
public void after(){
System.out.println("最终通知执行了……");
}
@AfterThrowing("MyAdvice.myPoint()")
public void afterThrowing(){
System.out.println("异常通知执行了……");
}
/* @Around("MyAdvice.myPoint()")
public Object around(ProceedingJoinPoint pjp){
Object proceed =null;
//切点方法执行
try {
System.out.println("前置通知执行了……");
proceed = pjp.proceed();
System.out.println("后置通知执行了……");
} catch (Throwable e) {
e.printStackTrace();
System.out.println("异常通知执行了……");
} finally {
System.out.println("最终通知执行了……");
}
return proceed;
}*/
}
- 定义配置类
SpringConfig
package com.soulboy.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@Configuration
@ComponentScan("com.soulboy")
@EnableAspectJAutoProxy // <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
aop的自动代理:spring会采用动态代理完成织入增强，并且生成代理 proxy-target-class="true" 强制使用cglib动态代理
public class SpringConfig {
}
- 测试类
AccountServiceTest
package com.soulboy.test;
import com.soulboy.config.SpringConfig;
import com.soulboy.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
@Autowired
private AccountService accountService;
@Test
public void testTransfer(){
accountService.transfer();
}
}
６. 测试结果
前置通知执行了……
转账了……
最终通知执行了……
后置通知执行了……
AOP：转账案例优化之XML
- 导入坐标
<!--指定编码及版本-->
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.encoding>UTF-8</maven.compiler.encoding>
<java.version>11</java.version>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</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>
<!-- aspectj的织入（切点表达式需要用到该jar包） -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.14</version>
</dependency>
<!--此处需要注意的是，spring5 及以上版本要求 junit 的版本必须是 4.12 及以上-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
</dependencies>
- 配置文件
<?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"
xmlns:aop="http://www.springframework.org/schema/aop"
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
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 开启扫描 -->
<context:component-scan base-package="com.soulboy"/>
<!-- 加载jdbc配置文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--把数据库连接池交给IOC容器-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--把QueryRunner交给IOC容器-->
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
<constructor-arg name="ds" ref="dataSource"></constructor-arg>
</bean>
<!--AOP配置-->
<aop:config>
<!--切点表达式-->
<aop:pointcut id="myPointCut" expression="execution(* com.soulboy.service..*.*(..))"/>
<!-- 切面配置 -->
<aop:aspect ref="transactionManager">
<aop:before method="beginTransaction" pointcut-ref="myPointCut"/>
<aop:after-returning method="commit" pointcut-ref="myPointCut"/>
<aop:after-throwing method="rollback" pointcut-ref="myPointCut"/>
<aop:after method="release" pointcut-ref="myPointCut"/>
</aop:aspect>
</aop:config>
</beans>
- 目标类与接口
AccountServiceImpl
package com.soulboy.service.impl;
import com.soulboy.dao.AccountDao;
import com.soulboy.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service("accountService")
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
/*
转账方法
*/
@Override
public void transfer(String outUser, String inUser, Double money) {
//减钱
accountDao.out(outUser, money);
//int i=1/0;
//加钱
accountDao.in(inUser, money);
System.out.println("转账成功");
}
@Override
public void save() {
System.out.println("save方法");
}
@Override
public void update() {
System.out.println("update方法");
}
@Override
public void delete() {
System.out.println("delete方法");
}
}
- 事务管理类(通知)
TransactionManager
package com.soulboy.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.sql.SQLException;
/**
* 事务管理器工具类，包含：开启事务、提交事务、回滚事务、释放资源
*/
@Component
public class TransactionManager {
@Autowired
private ConnectionUtils connectionUtils;
public void beginTransaction() {
try {
connectionUtils.getThreadConnection().setAutoCommit(false);
System.out.println("前置通知:beginTransaction");
} catch (SQLException e) {
e.printStackTrace();
}
}
public void commit() {
try {
connectionUtils.getThreadConnection().commit();
System.out.println("后置通知:commit");
} catch (SQLException e) {
e.printStackTrace();
}
}
public void rollback() {
try {
connectionUtils.getThreadConnection().rollback();
System.out.println("异常通知:rollback");
} catch (SQLException e) {
e.printStackTrace();
}
}
public void release() {
try {
connectionUtils.getThreadConnection().setAutoCommit(true); // 改回自动提交事务
connectionUtils.getThreadConnection().close();// 归还到连接池
connectionUtils.removeThreadConnection();// 解除线程绑定
System.out.println("最终通知:release");
} catch (SQLException e) {
e.printStackTrace();
}
}
}
ConnectionUtils
package com.soulboy.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
/*
连接工具类：从数据源中获取一个连接，并且将获取到的连接与线程进行绑定，在同一个connection中使用转账的两个方法
*/
@Component
public class ConnectionUtils {
@Autowired
private DataSource dataSource;
// ThreadLocal:线程内部的存储类，可以在指定线程内，存储数据。
private ThreadLocal<Connection> threadLocal = new ThreadLocal<>();
/**
* 获取当前线程上的连接:如果获取到的连接为空，那么就要从数据源中获取连接，并且放到ThreadLocal中(绑定到当前线程)
*
* @return Connection
*/
public Connection getThreadConnection() {
// 1.先从ThreadLocal上获取
Connection connection = threadLocal.get();
// 2.判断当前线程是否有连接
if (connection == null) {
try {
// 3.从数据源中获取一个连接，并存入到ThreadLocal中
connection = dataSource.getConnection();
threadLocal.set(connection);
} catch (SQLException e) {
e.printStackTrace();
}
}
return connection;
}
/**
* 解除当前线程的连接绑定
*/
public void removeThreadConnection() {
threadLocal.remove();
}
}
- 测试类
package com.soulboy.test;
import com.soulboy.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class AccountServiceTest {
@Autowired
private AccountService accountService;
@Test
public void testTransfer() {
accountService.transfer("妞妞", "超蛋", 200d);
}
}
- 测试结果
前置通知:beginTransaction
转账成功
后置通知:commit
最终通知:release
AOP：转账案例优化之注解
- 配置文件
<?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"
xmlns:aop="http://www.springframework.org/schema/aop"
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
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 开启扫描 -->
<context:component-scan base-package="com.soulboy"/>
<!--开启AOP注解支持-->
<aop:aspectj-autoproxy/>
<!-- 加载jdbc配置文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--把数据库连接池交给IOC容器-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--把QueryRunner交给IOC容器-->
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
<constructor-arg name="ds" ref="dataSource"></constructor-arg>
</bean>
</beans>
- 事务管理器（通知）
TransactionManager
package com.soulboy.utils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.sql.SQLException;
/**
* 事务管理器工具类，包含：开启事务、提交事务、回滚事务、释放资源
*/
@Component
@Aspect
public class TransactionManager {
@Autowired
private ConnectionUtils connectionUtils;
public void beginTransaction() {
try {
connectionUtils.getThreadConnection().setAutoCommit(false);
System.out.println("前置通知:beginTransaction");
} catch (SQLException e) {
e.printStackTrace();
}
}
public void commit() {
try {
connectionUtils.getThreadConnection().commit();
System.out.println("后置通知:commit");
} catch (SQLException e) {
e.printStackTrace();
}
}
public void rollback() {
try {
connectionUtils.getThreadConnection().rollback();
System.out.println("异常通知:rollback");
} catch (SQLException e) {
e.printStackTrace();
}
}
public void release() {
try {
connectionUtils.getThreadConnection().setAutoCommit(true); // 改回自动提交事务
connectionUtils.getThreadConnection().close();// 归还到连接池
connectionUtils.removeThreadConnection();// 解除线程绑定
System.out.println("最终通知:release");
} catch (SQLException e) {
e.printStackTrace();
}
}
@Around("execution(* com.soulboy.service..*.*(..))")
public Object around(ProceedingJoinPoint pjp) {
Object object = null;
try {
// 开启事务
connectionUtils.getThreadConnection().setAutoCommit(false);
System.out.println("前置通知:beginTransaction");
// 业务逻辑
pjp.proceed();
// 提交事务
connectionUtils.getThreadConnection().commit();
System.out.println("后置通知:commit");
} catch (Throwable throwable) {
throwable.printStackTrace();
// 回滚事务
try {
connectionUtils.getThreadConnection().rollback();
} catch (SQLException e) {
e.printStackTrace();
}
System.out.println("异常通知:rollback");
} finally {
try {
connectionUtils.getThreadConnection().setAutoCommit(true);
connectionUtils.getThreadConnection().close();
connectionUtils.removeThreadConnection();
System.out.println("最终通知:release");
} catch (SQLException e) {
e.printStackTrace();
}
}
return object;
}
}
JdbcTemplate
JdbcTemplate是spring框架中提供的一个模板对象，是对原始繁琐的Jdbc API对象的简单封装。
jdbcTemplate使用和dbutils使用很相似，都是数据库进行crud操作
核心对象
JdbcTemplate jdbcTemplate = new JdbcTemplate(DataSource dataSource);
核心方法
int update(); 执行增、删、改语句
List query(); 查询多个
T queryForObject(); 查询一个
new BeanPropertyRowMapper<>(); 实现ORM映射封装
Spring整合JdbcTemplate
基于Spring的xml配置实现账户的CRUD，步骤如下
1. 创建java项目，导入坐标
2. 编写Account实体类
3. 编写AccountDao接口和实现类
4. 编写AccountService接口和实现类
5. 编写spring核心配置文件
6. 编写测试代码
- 创建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.soulboy</groupId>
<artifactId>spring_jdbctemplate</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>11</java.version>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</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.15</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.13</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
</dependencies>
</project>
- 编写Account实体类
Account
package com.soulboy.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 +
'}';
}
}
- 编写AccountDao接口和实现类
AccountDao
package com.soulboy.dao;
import com.soulboy.domain.Account;
import java.util.List;
public interface AccountDao {
/**
* 查询所有
*/
public List<Account> findAll();
/**
* 根据ID查询账户
*/
public Account findOneById(Integer id);
/**
* 添加账户
*/
public void save(Account account);
/**
* 更新账户
*/
public void update(Account account);
/**
* 根据id删除账户
*/
public void deleteById(Integer id);
}
AccountDaoImpl
package com.soulboy.dao.impl;
import com.soulboy.dao.AccountDao;
import com.soulboy.domain.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public class AccountDaoImpl implements AccountDao {
@Autowired
private JdbcTemplate jdbcTemplate;
/**
* 查询所有账户
* @return
*/
@Override
public List<Account> findAll() {
String sql = "select * from account";
List<Account> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Account>(Account.class));
return list;
}
/**
* 根据id查询账户
* @param id
* @return
*/
@Override
public Account findOneById(Integer id) {
String sql = "select * from account where id = ?";
Account account = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Account>(Account.class), id);
return account;
}
/**
* 添加账户
*
* @param account
*/
@Override
public void save(Account account) {
String sql = "insert into account values(null,?,?)";
jdbcTemplate.update(sql, account.getName(),account.getMoney());
}
/**
* 更新账户
* @param account
*/
@Override
public void update(Account account) {
String sql = "update account set money = ? where name = ?";
jdbcTemplate.update(sql, account.getMoney(), account.getName());
}
/**
* 删除账户
* @param id
*/
@Override
public void deleteById(Integer id) {
String sql = "delete from account where id = ?";
jdbcTemplate.update(sql, id);
}
}
- 编写AccountService接口和实现类
AccountService
package com.soulboy.service;
import com.soulboy.domain.Account;
import java.util.List;
public interface AccountService {
/**
* 查询所有
*/
public List<Account> findAll();
/**
* 根据ID查询账户
*/
public Account findOneById(Integer id);
/**
* 添加账户
*/
public void save(Account account);
/**
* 更新账户
*/
public void update(Account account);
/**
* 根据id删除账户
*/
public void deleteById(Integer id);
}
AccountServiceImpl
package com.soulboy.service.impl;
import com.soulboy.dao.AccountDao;
import com.soulboy.domain.Account;
import com.soulboy.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
@Override
public List<Account> findAll() {
List<Account> list = accountDao.findAll();
return list;
}
@Override
public Account findOneById(Integer id) {
Account account = accountDao.findOneById(id);
return account;
}
@Override
public void save(Account account) {
accountDao.save(account);
}
@Override
public void update(Account account) {
accountDao.update(account);
}
@Override
public void deleteById(Integer id) {
accountDao.deleteById(id);
}
}
- 编写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.soulboy"/>
<!--加载jdbc.properties文件-->
<context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
<!--dataSource-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--注入JdbcTemplate-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<constructor-arg name="dataSource" ref="dataSource"/>
</bean>
</beans>
jdbc.properties
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:50000/spring_db?useSSL=false
jdbc.username=root
jdbc.password=123456
- 编写测试类
AccountServiceImplTest
package com.soulboy.test;
import com.soulboy.domain.Account;
import com.soulboy.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class AccountServiceImplTest {
@Autowired
private AccountService accountService;
/**
* 测试方法：保存账户
*/
@Test
public void testSave(){
Account account = new Account();
account.setName("高中直");
account.setMoney(5d);
accountService.save(account);
}
/**
* 测试方法：查询所有
*/
@Test
public void testFindAll(){
List<Account> accounts = accountService.findAll();
for (Account account : accounts) {
System.out.println(account);
}
}
/**
* 测试方法：根据ID进行查询
*/
@Test
public void testFindById(){
Account account = accountService.findOneById(8);
System.out.println(account);
}
/**
* 测试方法：更新
*/
@Test
public void testUpdate(){
Account account = new Account();
account.setName("高中直");
account.setMoney(9d);
accountService.update(account);
}
/**
* 测试方法：删除
*/
@Test
public void testDeleteById(){
accountService.deleteById(6);
}
}
实现转账案例
步骤分析
1. 创建java项目，导入坐标
2. 编写Account实体类
3. 编写AccountDao接口和实现类
4. 编写AccountService接口和实现类
5. 编写spring核心配置文件
6. 编写测试代码
- 创建java项目，导入坐标
<!--指定编码及版本-->
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.encoding>UTF-8</maven.compiler.encoding>
<java.version>11</java.version>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</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.15</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.13</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
</dependencies>
- 编写Account实体类
Account
package com.soulboy.domain;
public class Account {
private Integer id;
private String name;
private Double money;
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", money=" + 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;
}
}
- 编写AccountDao接口和实现类
AccountDao
package com.soulboy.dao;
public interface AccountDao {
/**
* 减钱：转出操作
*/
public void out(String outUser, Double moeny);
/**
* 转入：转入操作
*/
public void in(String inUser, Double money);
}
AccountDaoImpl
package com.soulboy.dao.impl;
import com.soulboy.dao.AccountDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
@Repository
public class AccountDaoImpl implements AccountDao {
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public void out(String outUser, Double money) {
String sql = "update account set money = money - ? where name = ?";
jdbcTemplate.update(sql, money, outUser);
}
@Override
public void in(String inUser, Double money) {
String sql = "update account set money = money + ? where name = ?";
jdbcTemplate.update(sql, money, inUser);
}
}
- 编写AccountService接口和实现类
AccountService
package com.soulboy.service;
public interface AccountService {
/**
* 转账
*/
public void transfer(String outUser, String inUser,Double money);
}
AccountServiceImpl
package com.soulboy.service.impl;
import com.soulboy.dao.AccountDao;
import com.soulboy.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
@Override
public void transfer(String outUser, String inUser, Double money) {
accountDao.out(outUser, money);
accountDao.in(inUser,money);
}
}
- 编写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.soulboy"></context:component-scan>
<!--加载jdbc.properties文件-->
<context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
<!--dataSource-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--注入JdbcTemplate-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<constructor-arg name="dataSource" ref="dataSource"/>
</bean>
</beans>
jdbc.properties
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:50000/spring_db?useSSL=false
jdbc.username=root
jdbc.password=123456
- 编写测试代码
AccountServiceImplTest
package com.soulboy.test;
import com.soulboy.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class AccountServiceImplTest {
@Autowired
private AccountService accountService;
/**
* 测试方法：转账
*/
@Test
public void testTransfer(){
accountService.transfer("高中美","高中直",100d);
}
}
Spring的事务
Spring的事务控制可以分为编程式事务控制和声明式事务控制。
编程式
开发者直接把事务的代码和业务代码耦合到一起，在实际开发中不用。
声明式
开发者采用配置的方式来实现的事务控制，业务代码与事务代码实现解耦合，使用的AOP思想。
编程式事务控制相关对象【了解即可】
开发者直接把事务的代码和业务代码耦合到一起，在实际开发中不用。
Spring中的事务控制主要就是通过这三个API实现的
理解三者的关系：事务管理器通过读取事务定义参数进行事务管理，然后会产生一系列的事务状态。
- PlatformTransactionManager 负责事务的管理，它是个接口，其子类负责具体工作
- TransactionDefinition 定义了事务的一些相关参数
- TransactionStatus 代表事务运行的一个实时状态
PlatformTransactionManager
PlatformTransactionManager接口，是spring的事务管理器，里面提供了我们常用的操作事务的方法。
| 方法 | 说明 |
|---|---|
| TransactionStatus getTransaction(TransactionDefinition definition); | 开启事务并获取事务的状态信息 |
| void commit(TransactionStatus status)； | 提交事务 |
| void rollback(TransactionStatus status)； | 回滚事务 |
注意：
PlatformTransactionManager 是接口类型，不同的 Dao 层技术则有不同的实现类。
* Dao层技术是jdbcTemplate或mybatis时：
DataSourceTransactionManager
* Dao层技术是hibernate时：
HibernateTransactionManager
* Dao层技术是JPA时：
JpaTransactionManager
TransactionDefinition
TransactionDefinition接口提供事务的定义信息（事务隔离级别、事务传播行为等等）
| 方法 | 说明 |
|---|---|
| int getIsolationLevel() | 获得事务的隔离级别 |
| int getPropogationBehavior() | 获得事务的传播行为 |
| int getTimeout() | 获得超时时间 |
| boolean isReadOnly() | 是否只读 |
事务隔离级别
设置隔离级别，可以解决事务并发产生的问题，如脏读、不可重复读和虚读（幻读）。
- ISOLATION_DEFAULT 使用数据库默认级别 MySQL(可重复读) Oracle(读已提交)
- ISOLATION_READ_UNCOMMITTED 读未提交
- ISOLATION_READ_COMMITTED 读已提交 能解决脏读
- ISOLATION_REPEATABLE_READ 可重复读 能解决脏读、不可重复读
- ISOLATION_SERIALIZABLE 串行化
事务传播行为
事务传播行为指的就是当一个业务方法【被】另一个业务方法调用时，应该如何进行事务控制。
| 方法 | 说明 |
|---|---|
| REQUIRED | 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。一般的选择（默认值）, 使用场景：增、删、改 |
| SUPPORTS | 支持当前事务，如果当前没有事务，就以非事务方式执行（没有事务），使用场景：查询 |
| MANDATORY | 使用当前的事务，如果当前没有事务，就抛出异常 |
| REQUERS_NEW | 新建事务，如果当前在事务中，把当前事务挂起 |
| NOT_SUPPORTED | 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起 |
| NEVER | 以非事务方式运行，如果当前存在事务，抛出异常 |
| NESTED | 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行REQUIRED 类似的操作 |
- read-only（是否只读）：建议查询时设置为只读
- timeout（超时时间）：默认值是-1，没有超时限制。如果有，以秒为单位进行设置
TransactionStatus
TransactionStatus 接口提供的是事务具体的运行状态。
| 方法 | 说明 |
|---|---|
| boolean isNewTransaction() | 是否是新事务 |
| boolean hasSavepoint() | 是否是回滚点 |
| boolean isRollbackOnly() | 事务是否回滚 |
| boolean isCompleted() | 事务是否完成 |
1）配置文件
<!--事务管理器交给IOC-->
<bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
2）业务层代码
AccountServiceImpl
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
@Autowired
private PlatformTransactionManager transactionManager;
@Override
public void transfer(String outUser, String inUser, Double money) {
// 创建事务定义对象
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
// 设置是否只读，false支持事务
def.setReadOnly(false);
// 设置事务隔离级别，可重复读mysql默认级别
def.setIsolationLevel(TransactionDefinition.ISOLATION_REPEATABLE_READ);
// 设置事务传播行为，必须有事务
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
// 配置事务管理器
TransactionStatus status = transactionManager.getTransaction(def);
try {
// 转账
accountDao.out(outUser, money);
accountDao.in(inUser, money);
// 提交事务
transactionManager.commit(status);
} catch (Exception e) {
e.printStackTrace();
// 回滚事务
transactionManager.rollback(status);
}
}
}
声明式事务控制：XML
在 Spring 配置文件中声明式的处理事务来代替代码式的处理事务。底层采用AOP思想来实现的。
声明式事务控制明确事项
- 核心业务代码(目标对象) （切入点是谁？）
- 事务增强代码(Spring已提供事务管理器)）（通知是谁？）
- 切面配置（切面如何配置？）
需求
使用spring声明式事务控制转账业务。
步骤分析
- 引入tx命名空间（平台事务管理器配置）
- 事务管理器通知配置
- 事务管理器AOP配置（织入的配置）
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"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
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
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!--注解扫描-->
<context:component-scan base-package="com.soulboy"></context:component-scan>
<!--加载jdbc.properties文件-->
<context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
<!--dataSource-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--注入JdbcTemplate-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<constructor-arg name="dataSource" ref="dataSource"/>
</bean>
<!--事务管理器-->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--通知: 增强事务-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<!--定义事务的属性 *任意名称的方法都走默认配置-->
<tx:attributes>
<tx:method name="*"/>
</tx:attributes>
</tx:advice>
<!--aop配置-->
<aop:config>
<!--切面配置-->
<aop:advisor advice-ref="txAdvice"
pointcut="execution(* com.soulboy.service..*.*(..))"/>
</aop:config>
</beans>
jdbc.properties
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:50000/spring_db?useSSL=false
jdbc.username=root
jdbc.password=123456
- 测试事务控制转账业务代码
事务参数的配置详解
示例代码
<!--通知: 增强事务-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<!--定义事务的属性 *任意名称的方法都走默认配置-->
<tx:attributes>
<!--
* name：切点方法名称
* isolation:事务的隔离级别
* propogation：事务的传播行为
* timeout：超时时间 -1 代表没有超时时间
* read-only：是否只读
-->
<tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" timeout="-1"/>
</tx:attributes>
</tx:advice>
CRUD常用配置
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED"/>
<tx:method name="delete*" propagation="REQUIRED"/>
<tx:method name="update*" propagation="REQUIRED"/>
<tx:method name="find*" read-only="true"/>
<tx:method name="*"/>
</tx:attributes>
声明式事务控制：注解+XML
步骤分析
1. 修改service层，增加事务注解
2. 修改spring核心配置文件，开启事务注解支持
- 修改service层，增加事务注解
AccountServiceImpl
package com.soulboy.service.impl;
import com.soulboy.dao.AccountDao;
import com.soulboy.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
@Override
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ,timeout = -1,readOnly = false)
public void transfer(String outUser, String inUser, Double money) {
accountDao.out(outUser, money);
int i = 1 / 0;
accountDao.in(inUser,money);
}
}
- 修改spring核心配置文件，开启事务注解支持
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
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
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!--注解扫描-->
<context:component-scan base-package="com.soulboy"></context:component-scan>
<!--加载jdbc.properties文件-->
<context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
<!--dataSource-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--注入JdbcTemplate-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<constructor-arg name="dataSource" ref="dataSource"/>
</bean>
<!--事务管理器：不能注释-->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--事务的注解支持-->
<tx:annotation-driven/>
<!--通知: 增强事务-->
<!-- <tx:advice id="txAdvice" transaction-manager="transactionManager">-->
<!-- <!–定义事务的属性 *任意名称的方法都走默认配置–>-->
<!-- <tx:attributes>-->
<!-- <!–-->
<!-- * name：切点方法名称-->
<!-- * isolation:事务的隔离级别-->
<!-- * propogation：事务的传播行为-->
<!-- * timeout：超时时间 -1 代表没有超时时间-->
<!-- * read-only：是否只读-->
<!-- –>-->
<!-- <tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" timeout="-1"/>-->
<!-- </tx:attributes>-->
<!-- </tx:advice>-->
<!--aop配置-->
<!-- <aop:config>-->
<!-- <!–切面配置–>-->
<!-- <aop:advisor advice-ref="txAdvice"-->
<!-- pointcut="execution(* com.soulboy.service..*.*(..))"/>-->
<!-- </aop:config>-->
</beans>
声明式事务控制：纯注解
完全不需要applicationContext.xml文件
核心配置类
SpringConfig
package com.soulboy.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.sql.DataSource;
@Configuration
@ComponentScan("com.soulboy")
@Import(DataSourceConfig.class)
@EnableTransactionManagement //<tx:annotation-driven/>
public class SpringConfig {
@Bean
public JdbcTemplate getJdbcTemplate(@Autowired DataSource dataSource) {
return new JdbcTemplate(dataSource);
}
@Bean("transactionManager")
public PlatformTransactionManager getPlatformTransactionManager(@Autowired DataSource dataSource) {
return new DataSourceTransactionManager(dataSource);
}
}
数据源配置类
DataSourceConfig
package com.soulboy.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
public DataSource getDataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName(driver);
dataSource.setUrl(url);
dataSource.setUsername(username);
dataSource.setPassword(password);
return dataSource;
}
}
Dao层
AccountDaoImpl
package com.soulboy.dao.impl;
import com.soulboy.dao.AccountDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
@Repository
public class AccountDaoImpl implements AccountDao {
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public void out(String outUser, Double money) {
String sql = "update account set money = money - ? where name = ?";
jdbcTemplate.update(sql, money, outUser);
}
@Override
public void in(String inUser, Double money) {
String sql = "update account set money = money + ? where name = ?";
jdbcTemplate.update(sql, money, inUser);
}
}
Service层
AccountServiceImpl
package com.soulboy.service.impl;
import com.soulboy.dao.AccountDao;
import com.soulboy.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
@Service
//@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ,timeout = -1,readOnly = false)
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
@Override
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ,timeout = -1,readOnly = false)
public void transfer(String outUser, String inUser, Double money) {
accountDao.out(outUser, money);
//int i = 1 / 0;
accountDao.in(inUser,money);
}
}
测试类
AccountServiceImplTest
package com.soulboy.test;
import com.soulboy.config.SpringConfig;
import com.soulboy.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
//@ContextConfiguration({"classpath:applicationContext.xml"})
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceImplTest {
@Autowired
private AccountService accountService;
/**
* 测试方法：转账
*/
@Test
public void testTransfer(){
accountService.transfer("妞妞","高中直",100d);
}
}
知识小结
- 平台事务管理器配置（xml、注解方式）
- 事务通知的配置（@Transactional注解配置）
- 事务注解驱动的配置 、@EnableTransactionManagement