Spring

Spring

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

1.Spring概述

Rod Johnson（spring 之父）

1.1spring 的优势

方便解耦，简化开发

通过 Spring 提供的 IOC 容器，可以将对象间的依赖关系交由 Spring 进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

AOP 编程的支持

通过 Spring 的 AOP 功能，方便进行面向切面的编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松应付。

声明式事务的支持

可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，提高开发效率和质量。

方便程序的测试

可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。

方便集成各种优秀框架

Spring 可以降低各种框架的使用难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的直接支持。

降低 JavaEE API 的使用难度

Spring 对 JavaEE API（如 JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些 API 的使用难度大为降低。

Java 源码是经典学习范例

Spring 的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对 Java 设计模式灵活运用以及对 Java 技术的高深造诣。它的源代码无意是 Java 技术的最佳实践的范例。

1.2spring 的体系结构

image-20220725171213979

官网：http://spring.io/

下载地址：http://repo.springsource.org/libs-release-local/org/springframework/spring

2. IOC

本章我们使用的案例是，账户的业务层和持久层的依赖关系解决。在开始 spring 的配置之前，我们要先准备

一下环境。由于我们是使用 spring 解决依赖关系，并不是真正的要做增删改查操作，所以此时我们没必要写实体类。并且我们在此处使用的是 java 工程，不是 java web 工程。

2.1基于 XML 的配置

  • 第一步：拷贝必备的 jar 包到工程的 lib 目录中

  • 第二步：在类的根路径下创建一个任意名称的 xml 文件

给配置文件导入约束：bean.xml

1
2
3
4
5
6
<?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">
</beans>
  • 第三步：让 spring 管理资源，在配置文件中配置 service 和 dao

bean.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
<?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">
    <!-- bean 标签：用于配置让 spring 创建对象，并且存入 ioc 容器之中
 		id 属性：对象的唯一标识。
 		class 属性：指定要创建对象的全限定类名-->
	<!-- 配置 service --> 
	<bean id="accountService" class="com.ep.service.impl.AccountServiceImpl"></bean>
	<!-- 配置 dao --> 
    <bean id="accountDao" class="com.ep.dao.impl.AccountDaoImpl"></bean>
</beans>
  • 测试配置是否成功
1
2
3
4
5
6
7
8
9
10
11
12
13
public class Client {
/**
 * 使用 main 方法获取容器测试执行
 */
	public static void main(String[] args) {
		//1.使用 ApplicationContext 接口，就是在获取 spring 容器
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2.根据 bean 的 id 获取对象
		IAccountService aService = (IAccountService) ac.getBean("accountService");
		System.out.println(aService);
		IAccountDao aDao = (IAccountDao) ac.getBean("accountDao");
		System.out.println(aDao);
} }

2.2spring 中工厂的类结构图

image-20220725193802120

image-20220725193837174

BeanFactory 才是 Spring 容器中的顶层接口。

ApplicationContext 是它的子接口。

BeanFactory 和 ApplicationContext 的区别：

​ 创建对象的时间点不一样。

​ ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。

​ BeanFactory：什么使用什么时候创建对象。

ApplicationContext 接口的实现类

ClassPathXmlApplicationContext：它是从类的根路径下加载配置文件 推荐使用这种

FileSystemXmlApplicationContext：它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置

AnnotationConfigApplicationContext:当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解

2.3IOC 中 bean 标签和管理对象细节

2.3.1bean 标签

作用：

​ 用于配置对象让 spring 来创建的。

​ 默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。

属性：

​ id：给对象在容器中提供一个唯一标识。用于获取对象。

​ class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。

​ scope：指定对象的作用范围。

​ singleton :默认值，单例的.

​ prototype :多例的.

​ request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.

​ session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.

​ global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么globalSession 相当于 session.

​ init-method：指定类中的初始化方法名称。

​ destroy-method：指定类中销毁方法名称

2.3.2bean 的作用范围和生命周期

  • 单例对象：scope=”singleton”

    ​ 一个应用只有一个对象的实例。它的作用范围就是整个引用。

         生命周期：

    ​ 对象出生：当应用加载，创建容器时，对象就被创建了。

    ​ 对象活着：只要容器在，对象一直活着。

    ​ 对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

  • 多例对象：scope=”prototype”

    ​ 每次访问对象时，都会重新创建对象实例。

    ​ 生命周期：

    ​ 对象出生：当使用对象时，创建新的对象实例。

    ​ 对象活着：只要对象在使用中，就一直活着。

    ​ 对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

2.3.3实例化 Bean 的三种方式

第一种方式：使用默认无参构造函数

1
2
3
<!--在默认情况下：
它会根据默认无参构造函数来创建类对象。如果 bean 中没有默认无参构造函数，将会创建失败。--> 
<bean id="accountService" class="com.ep.service.impl.AccountServiceImpl"/>

第二种方式：spring管理静态工厂使用静态工厂的方法创建对象

1
2
3
4
5
6
7
8
/**
* 模拟一个静态工厂，创建业务层实现类
*/
public class StaticFactory {
	public static IAccountService createAccountService(){
		return new AccountServiceImpl();
	} 
}
1
2
3
4
5
6
7
8
<!-- 此种方式是:
使用 StaticFactory 类中的静态方法 createAccountService 创建对象，并存入 spring 容器
id 属性：指定 bean 的 id，用于从容器中获取
class 属性：指定静态工厂的全限定类名
factory-method 属性：指定生产对象的静态方法--> 
<bean id="accountService"
 class="com.ep.factory.StaticFactory"
 factory-method="createAccountService"></bean>

第三种方式：spring 管理实例工厂-使用实例工厂的方法创建对象

1
2
3
4
5
6
7
8
9
/**
* 模拟一个实例工厂，创建业务层实现类
* 此工厂创建对象，必须现有工厂实例对象，再调用方法
*/
public class InstanceFactory {
	public IAccountService createAccountService(){
		return new AccountServiceImpl();
	} 
}
1
2
3
4
5
6
7
8
9
<!-- 此种方式是：
先把工厂的创建交给 spring 来管理。
然后在使用工厂的 bean 来调用里面的方法
factory-bean 属性：用于指定实例工厂 bean 的 id。
factory-method 属性：用于指定实例工厂中创建对象的方法。
--> <bean id="instancFactory" class="com.ep.factory.InstanceFactory"></bean> 
<bean id="accountService"
 factory-bean="instancFactory"
 factory-method="createAccountService"></bean>

2.4spring 的依赖注入

2.4.1 依赖注入的概念

依赖注入：Dependency Injection。它是 spring 框架核心 ioc 的具体实现。

我们的程序在编写时，通过控制反转，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。

ioc 解耦只是降低他们的依赖关系，但不会消除。例如：我们的业务层仍会调用持久层的方法。那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。

简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

2.4.2 构造函数注入

顾名思义，就是使用类中的构造函数，给成员变量赋值。注意，赋值的操作不是我们自己做的，而是通过配置的方式，让 spring 框架来为我们注入。具体代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class AccountServiceImpl implements IAccountService {
	private String name;
	private Integer age;
	private Date birthday;
	public AccountServiceImpl(String name, Integer age, Date birthday) {
		this.name = name;
		this.age = age;
		this.birthday = birthday; 
    }
	@Override
	public void saveAccount() {
		System.out.println(name+","+age+","+birthday);
	} 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<!-- 使用构造函数的方式，给 service 中的属性传值
要求：
	类中需要提供一个对应参数列表的构造函数。
涉及的标签：
	constructor-arg
属性：
	index:指定参数在构造函数参数列表的索引位置
	type:指定参数在构造函数中的数据类型
	name:指定参数在构造函数中的名称 用这个找给谁赋值
=======上面三个都是找给谁赋值，下面两个指的是赋什么值的==============
	value:它能赋的值是基本数据类型和 String 类型
	ref:它能赋的值是其他 bean 类型，也就是说，必须得是在配置文件中配置过的 bean
-->
<bean id="accountService" class="com.ep.service.impl.AccountServiceImpl"> 
    <constructor-arg name="name" value="张三"></constructor-arg> 
    <constructor-arg name="age" value="18"></constructor-arg> 
    <constructor-arg name="birthday" ref="now"></constructor-arg>
</bean> 
<bean id="now" class="java.util.Date"></bean>

2.4.3 set 方法注入

顾名思义，就是在类中提供需要注入成员的 set 方法。具体代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class AccountServiceImpl implements IAccountService {
	private String name;
	private Integer age;
	private Date birthday;
	public void setName(String name) {
		this.name = name; 
    }
	public void setAge(Integer age) {
		this.age = age; 
    }
	public void setBirthday(Date birthday) {
		this.birthday = birthday; 
    }
	@Override
	public void saveAccount() {
		System.out.println(name+","+age+","+birthday);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!-- 通过配置文件给 bean 中的属性传值：使用 set 方法的方式
涉及的标签：
	property
属性：
	name：找的是类中 set 方法后面的部分
	ref：给属性赋值是其他 bean 类型的
	value：给属性赋值是基本数据类型和 string 类型的
实际开发中，此种方式用的较多。
--> 
<bean id="accountService" class="com.ep.service.impl.AccountServiceImpl"> 
    <property name="name" value="test"></property> 
    <property name="age" value="21"></property> 
    <property name="birthday" ref="now"></property>
</bean>
<bean id="now" class="java.util.Date"></bean>

2.4.4 使用 p 名称空间注入数据（本质还是调用 set 方法）

此种方式是通过在 xml 中导入 p 名称空间，使用 p:propertyName 来注入数据，它的本质仍然是调用类中的set 方法实现注入功能。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
* 使用 p 名称空间注入，本质还是调用类中的 set 方法
*/
public class AccountServiceImpl4 implements IAccountService {
	private String name;
	private Integer age;
	private Date birthday;
	public void setName(String name) {
		this.name = name;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
	@Override
	public void saveAccount() {
		System.out.println(name+","+age+","+birthday);
	} 
}
1
2
3
4
5
6
7
8
9
10
<beans xmlns="http://www.springframework.org/schema/beans"
 		xmlns:p="http://www.springframework.org/schema/p"
       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">
 
<bean id="accountService" 
      class="com.ep.service.impl.AccountServiceImpl4"
 	  p:name="test" p:age="21" p:birthday-ref="now"/>
</beans>

2.3.5注入集合属性

顾名思义，就是给类中的集合成员传值，它用的也是set方法注入的方式，只不过变量的数据类型都是集合。我们这里介绍注入数组，List,Set,Map,Properties。具体代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class AccountServiceImpl implements IAccountService {
	private String[] myStrs;
	private List<String> myList;
	private Set<String> mySet;
	private Map<String,String> myMap;
	private Properties myProps;
	public void setMyStrs(String[] myStrs) {
		this.myStrs = myStrs; 
    }
	public void setMyList(List<String> myList) {
		this.myList = myList; 
    }
	public void setMySet(Set<String> mySet) {
		this.mySet = mySet; 
    }
	public void setMyMap(Map<String, String> myMap) {
		this.myMap = myMap; 
    }
	public void setMyProps(Properties myProps) {
		this.myProps = myProps; 
    }
	@Override
	public void saveAccount() {
		System.out.println(Arrays.toString(myStrs));
		System.out.println(myList);
		System.out.println(mySet);
		System.out.println(myMap);
    	System.out.println(myProps);
	} 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
<!-- 注入集合数据
	List 结构的：
		array,list,set
	Map 结构的
		map,entry,props,prop
-->
<bean id="accountService" class="com.ep.service.impl.AccountServiceImpl">
	<!-- 在注入集合数据时，只要结构相同，标签可以互换 -->
	<!-- 给数组注入数据 -->
    <property name="myStrs"> 
        <set>
            <value>AAA</value>
            <value>BBB</value> 
            <value>CCC</value>
		</set>
	</property>
	<!-- 注入 list 集合数据 --> 
    <property name="myList"> 
        <array> 
            <value>AAA</value> 
            <value>BBB</value> 
            <value>CCC</value>
		</array>
	</property>
	<!-- 注入 set 集合数据 --> 
    <property name="mySet"> 
        <list>
            <value>AAA</value> 
            <value>BBB</value> 
            <value>CCC</value>
		</list>
	</property>
	<!-- 注入 Map 数据 --> 
    <property name="myMap"> 
        <props> 
            <prop key="testA">aaa</prop> 
            <prop key="testB">bbb</prop>
		</props>
	</property>
	<!-- 注入 properties 数据 -->
    <property name="myProps"> 
        <map>
            <entry key="testA" value="aaa"></entry> 
            <entry key="testB"> 
                <value>bbb</value>
			</entry>
		</map>
	</property>
</bean>

2.5配置对象举例

image-20220725204125788

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<?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">
 
	<!-- 配置 service --> 
    <bean id="accountService"
		class="com.ep.service.impl.AccountServiceImpl"> 
        <!--service里面要用到accountDao-->
        <property name="accountDao" ref="accountDao"></property>
	</bean>
	<!-- 配置 dao --> 
    <bean id="accountDao" class="com.ep.dao.impl.AccountDaoImpl"> 
        <property name="dbAssit" ref="dbAssit"></property>
	</bean>
	<!-- 配置 dbAssit 此处我们只注入了数据源，表明每条语句独立事务--> 
    <bean id="dbAssit" class="com.ep.dbassit.DBAssit">
    	<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 配置数据源 --> 
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> 
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property> 
        <property name="jdbcUrl" value="jdbc:mysql:///spring_day02"></property>
        <property name="user" value="root"></property> 
        <property name="password" value="1234"></property>
	</bean>
</beans>

测试：

1
2
3
4
5
6
7
8
9
10
11
12
/**
* 测试保存
*/
@Test
public void testSaveAccount() {
	Account account = new Account();
	account.setName("123");
	account.setMoney(100000f);
	ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
	IAccountService as = ac.getBean("accountService",IAccountService.class);
	as.saveAccount(account);
}

2.6 基于注解的 IOC 配置

注意：在基于注解的配置中，我们还要多拷贝一个 aop 的 jar 包。

使用@Component注解配置管理的资源

1
2
3
4
5
6
7
@Component("accountService")
public class AccountServiceImpl implements IAccountService {
	private IAccountDao accountDao;
	public void setAccountDao(IAccountDao accountDao) {
		this.accountDao = accountDao; 
    } 
}

创建 spring 的xml配置文件并开启对注解的支持

注意：

基于注解整合时，导入约束时需要多导入一个 context 名称空间下的约束。

由于我们使用了注解配置，此时不能在继承 JdbcDaoSupport，需要自己配置一个 JdbcTemplate

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
 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
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 告知 spring 创建容器时要扫描的包 --> 
    <context:component-scan base-package="com.ep"></context:component-scan>
    <!-- 配置 dbAssit --> 
    <bean id="dbAssit" class="com.ep.dbassit.DBAssit">
        <property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 配置数据源 --> 
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> 
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property> 
        <property name="jdbcUrl" value="jdbc:mysql:///spring_day02"></property> 
        <property name="user" value="root"></property> 
        <property name="password" value="1234"></property>
</bean>

2.7常用注解

2.7.1用于创建对象：

@Component

相当于：<bean id="" class="">

作用：把资源让 spring 来管理。相当于在 xml 中配置一个 bean。

属性：value：指定 bean 的 id。如果不指定 value 属性，默认 bean 的 id 是当前类的类名。首字母小写。

@Controller @Service @Repository

他们三个注解都是针对一个的衍生注解，他们的作用及属性都是一模一样的。

他们只不过是提供了更加明确的语义化。

@Controller：一般用于表现层的注解。

@Service：一般用于业务层的注解。

@Repository：一般用于持久层的注解。

细节：如果注解中有且只有一个属性要赋值时，且名称是 value，value 在赋值是可以不写。

2.7.2用于注入数据：

@Autowired

相当于：<property name="" ref=""> <property name="" value="">

作用：自动按照类型注入。当使用注解注入属性时，set 方法可以省略。它只能注入其他 bean 类型。当有多个类型匹配时，使用要注入的对象变量名称作为 bean 的 id，在 spring 容器查找，找到了也可以注入成功。找不到就报错。

@Qualifier

作用：在自动按照类型注入的基础之上，再按照 Bean 的 id 注入。它在给字段注入时不能独立使用，必须@Autowire 一起使用；但是给方法参数注入时，可以独立使用。

属性：value：指定 bean 的 id。

@Resource

作用：直接按照 Bean 的 id 注入。它也只能注入其他 bean 类型。

属性：name：指定 bean 的 id。

@Value

作用：注入基本数据类型和 String 类型数据的

属性：value：用于指定值

2.7.3用于改变作用范围的：

相当于：<bean id="" class="" scope="">

@Scope

作用：指定 bean 的作用范围。

属性：value：指定范围的值。

​ 取值：singleton prototype request session globalsession

2.7.4 和生命周期相关的：

相当于：<bean id="" class="" init-method="" destroy-method="" />

@PostConstruct

作用：用于指定初始化方法。

@PreDestroy

作用：用于指定销毁方法。

image-20220726110811429

注解的优势：配置简单，维护方便（我们找到类，就相当于找到了对应的配置）。

XML 的优势：修改时，不用改源码。不涉及重新编译和部署。

@Configuration

作用：用于指定当前类是一个 spring 配置类，当创建容器时会从该类上加载注解。获取容器时需要使用

AnnotationApplicationContext(有@Configuration 注解的类.class)。

属性：value:用于指定配置类的字节码

1
2
3
4
5
6
7
示例代码：
/**
* spring 的配置类，相当于 bean.xml 文件
*/
@Configuration
public class SpringConfiguration {
}

注意：我们已经把配置文件用类来代替了，但是如何配置创建容器时要扫描的包呢？
请看下一个注解。

@ComponentScan

作用：用于指定 spring 在初始化容器时要扫描的包。作用和在 spring 的 xml 配置文件中的：

​ <context:component-scan base-package=”com.ep”/>是一样的。

属性：basePackages：用于指定要扫描的包。和该注解中的 value 属性作用一样。

1
2
3
4
5
6
7
8
9
示例代码：
/**
* spring 的配置类，相当于 bean.xml 文件
* @Version 1.0
*/
@Configuration
@ComponentScan("com.ep")
public class SpringConfiguration {
}

注意：我们已经配置好了要扫描的包，但是数据源和 JdbcTemplate 对象如何从配置文件中移除呢？

请看下一个注解。

@Bean

作用：该注解只能写在方法上，表明使用此方法创建一个对象，并且放入 spring 容器。

属性：name：给当前@Bean 注解方法创建的对象指定一个名称(即 bean 的 id）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/**
* 连接数据库的配置类
*/
public class JdbcConfig {
/**
* 创建一个数据源，并存入 spring 容器中
* @return
*/
	@Bean(name="dataSource")
	public DataSource createDataSource() {
		try {
			ComboPooledDataSource ds = new ComboPooledDataSource();
			ds.setUser("root");
			ds.setPassword("1234");
			ds.setDriverClass("com.mysql.jdbc.Driver");
			ds.setJdbcUrl("jdbc:mysql:///spring_day02");
			return ds;
			} catch (Exception e) {
				throw new RuntimeException(e);
			} 
    }
/**
* 创建一个 DBAssit，并且也存入 spring 容器中
* @param dataSource
* @return
*/
	@Bean(name="dbAssit")
	public DBAssit createDBAssit(DataSource dataSource) {
		return new DBAssit(dataSource);
	} 
}

注意:我们已经把数据源和 DBAssit 从配置文件中移除了，此时可以删除 bean.xml 了。

但是由于没有了配置文件，创建数据源的配置又都写死在类中了。如何把它们配置出来呢？

请看下一个注解。

@PropertySource

作用：用于加载.properties 文件中的配置。例如我们配置数据源时，可以把连接数据库的信息写到properties 配置文件中，就可以使用此注解指定 properties 配置文件的位置。

属性：value[]：用于指定 properties 文件位置。如果是在类路径下，需要写上 classpath:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
配置：
/**
* 连接数据库的配置类
*/
public class JdbcConfig {
	@Value("${jdbc.driver}")
	private String driver;
	@Value("${jdbc.url}")
	private String url;
	@Value("${jdbc.username}")
	private String username;
	@Value("${jdbc.password}")
	private String password;
	/**
	* 创建一个数据源，并存入 spring 容器中
	* @return
	*/
	@Bean(name="dataSource")
	public DataSource createDataSource() {
		try {
			ComboPooledDataSource ds = new ComboPooledDataSource();
			ds.setDriverClass(driver);
			ds.setJdbcUrl(url);
			ds.setUser(username);
			ds.setPassword(password);
			return ds;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
    }
}

jdbc.properties 文件：

1
2
3
4
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring
jdbc.username=root
jdbc.password=1234

注意：此时我们已经有了两个配置类，但是他们还没有关系。如何建立他们的关系呢？

请看下一个注解。

@Import

作用：用于导入其他配置类，在引入其他配置类时，可以不用再写@Configuration 注解。当然，写上也没问

题。

属性：value[]：用于指定其他配置类的字节码。

1
2
3
4
5
@Configuration
@ComponentScan(basePackages = "com.ep") 
@Import({ JdbcConfig.class})
public class SpringConfiguration { 
}
1
2
3
4
@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig{
}

注意：我们已经把要配置的都配置好了，但是新的问题产生了，由于没有配置文件了，如何获取容器呢？

请看下一小节

通过注解获取容器：

1
ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);

3.Spring 整合 Junit

第一步：拷贝整合 junit 的必备 jar 包到 lib 目录

此处需要注意的是，导入 jar 包时，需要导入一个 spring 中 aop 的 jar 包。

第二步：使用@RunWith 注解替换原有运行器

1
2
3
4
5
6
/**
* 测试类
*/
@RunWith(SpringJUnit4ClassRunner.class)
public class AccountServiceTest {
}

第三步：使用@ContextConfiguration*指定 spring 配置文件的位置

1
2
3
4
5
6
7
/**
* 测试类
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations= {"classpath:bean.xml"})
public class AccountServiceTest {
}

@ContextConfiguration 注解：

locations 属性：用于指定配置文件的位置。如果是类路径下，需要用 **classpath:**表明

classes 属性：用于指定注解的类。当不使用 xml 配置时，需要用此属性指定注解类的位置。

第四步：使用@Autowired 给测试类中的变量注入数据

1
2
3
4
5
6
7
8
9
/**
* 测试类
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations= {"classpath:bean.xml"})
public class AccountServiceTest {
	@Autowired
	private IAccountService as ; 
}

4.动态代理技术

  • 基于接口的动态代理

    • 提供者：JDK 官方的 Proxy 类。
    • 要求：被代理类最少实现一个接口。

  • 基于子类的动态代理

    • 提供者：第三方的 CGLib，如果报 asmxxxx 异常，需要导入 asm.jar。
    • 要求：被代理类不能用 final 修饰的类（最终类）。

4.1使用 JDK 官方的 Proxy 类创建代理对象

此处我们使用的是一个演员的例子：
在很久以前，演员和剧组都是直接见面联系的。没有中间人环节。而随着时间的推移，产生了一个新兴职业：经纪人（中间人），这个时候剧组再想找演员就需要通过经纪人来找了。下面我们就用代码演示出来。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

/**
* 一个经纪公司的要求:
* 能做基本的表演和危险的表演
*/
public interface IActor {
	/**
	* 基本演出
	* @param money
	*/
	public void basicAct(float money);
	/**
	* 危险演出
	* @param money
	*/
	public void dangerAct(float money);
}

/**
* 一个演员
*/
//实现了接口，就表示具有接口中的方法实现。即：符合经纪公司的要求
public class Actor implements IActor{
	public void basicAct(float money){
		System.out.println("拿到钱，开始基本的表演："+money);
	}
	public void dangerAct(float money){
		System.out.println("拿到钱，开始危险的表演："+money);
	} 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
public class Client {
	public static void main(String[] args) {
	//一个剧组找演员：
		final Actor actor = new Actor();//直接
		/**
		* 代理：
		* 	间接。
		* 获取代理对象：
		* 	要求：
		*		 被代理类最少实现一个接口
		* 创建的方式
		* 	Proxy.newProxyInstance(三个参数)
		* 参数含义：
		* 	ClassLoader：和被代理对象使用相同的类加载器。
		* 	Interfaces：和被代理对象具有相同的行为。实现相同的接口。
		* 	InvocationHandler：如何代理。
		* 		策略模式：使用场景是：
		*			数据有了，目的明确。
		* 			如何达成目标，就是策略。
		* 
		*/
		IActor proxyActor = (IActor) Proxy.newProxyInstance(
			actor.getClass().getClassLoader(), 
			actor.getClass().getInterfaces(), 
			new InvocationHandler() {
			/**
			* 执行被代理对象的任何方法，都会经过该方法。
			* 此方法有拦截的功能。
			* 
			* 参数：
			* 	 proxy：代理对象的引用。不一定每次都用得到
			*	 method：当前执行的方法对象
			*	 args：执行方法所需的参数
			* 返回值：
			*	 当前执行方法的返回值
			*/
				@Override
				public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
					String name = method.getName();
					Float money = (Float) args[0];
					Object rtValue = null;
                    //每个经纪公司对不同演出收费不一样，此处开始判断
					if("basicAct".equals(name)){
						//基本演出，没有 2000 不演
						if(money > 2000){
						//看上去剧组是给了 8000，实际到演员手里只有 4000
						//这就是我们没有修改原来 basicAct 方法源码，对方法进行了增强
						rtValue = method.invoke(actor, money/2);
						} 
                    }
					if("dangerAct".equals(name)){
						//危险演出,没有 50000 不演
						if(money > 50000){
						//看上去剧组是给了 50000，实际到演员手里只有 25000
						//这就是我们没有修改原来 dangerAct 方法源码，对方法进行了增强
						rtValue = method.invoke(actor, money/2);
						} 
                    }
				return rtValue;
  		  }
		});
	//没有经纪公司的时候，直接找演员。
	// actor.basicAct(1000f);
	// actor.dangerAct(5000f);
	//剧组无法直接联系演员，而是由经纪公司找的演员
	proxyActor.basicAct(8000f);
	proxyActor.dangerAct(50000f);
	} 
}

4.2使用 CGLib 的 Enhancer 类创建代理对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
还是那个演员的例子，只不过不让他实现接口。
/**
* 一个演员
*/
public class Actor{//没有实现任何接口
	public void basicAct(float money){
		System.out.println("拿到钱，开始基本的表演："+money);
	}
	public void dangerAct(float money){
		System.out.println("拿到钱，开始危险的表演："+money);
        } 
}

public class Client {
	/**
	* 基于子类的动态代理
	* 要求：
	* 被代理对象不能是最终类
	* 用到的类：
	* Enhancer
	* 用到的方法：
	* create(Class, Callback)
	* 方法的参数：
	* Class：被代理对象的字节码
	* Callback：如何代理
	* @param args
	*/
	public static void main(String[] args) {
		final Actor actor = new Actor();
		Actor cglibActor = (Actor) Enhancer.create(actor.getClass(),new MethodInterceptor() {
			/**
			* 执行被代理对象的任何方法，都会经过该方法。在此方法内部就可以对被代理对象的任何方法进行增强。
			* 
			* 参数：
			* 	前三个和基于接口的动态代理是一样的。
			*	 MethodProxy：当前执行方法的代理对象。
			* 返回值：
			* 	当前执行方法的返回值
			*/
		@Override
		public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
			String name = method.getName();
			Float money = (Float) args[0];
			Object rtValue = null;
			if("basicAct".equals(name)){
				//基本演出
				if(money > 2000){
				rtValue = method.invoke(actor, money/2);
    			} 
       	 	}
            if("dangerAct".equals(name)){
				//危险演出
				if(money > 5000){
				rtValue = method.invoke(actor, money/2);
				} 
            }
			return rtValue;
		}
	});
	cglibActor.basicAct(10000);
	cglibActor.dangerAct(100000);
} }

5.AOP

AOP：全称是 Aspect Oriented Programming 即：面向切面编程。

简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。

5.1AOP 的作用及优势

作用：在程序运行期间，不修改源码对已有方法进行增强。

优势：减少重复代码 提高开发效率 维护方便

实现方式:使用动态代理技术

5.2AOP 相关术语:

**Joinpoint(连接点):**所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。

**Pointcut(切入点):**所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。

**Advice(通知/增强):**所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。

通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。

**Introduction(引介):**引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。

**Target(目标对象):**代理的目标对象。

**Weaving(织入):**是指把增强应用到目标对象来创建新的代理对象的过程。

spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。

**Proxy（代理）:**一个类被 AOP 织入增强后，就产生一个结果代理类。

**Aspect(切面):**是切入点和通知（引介）的结合。

在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

5.3基于 XML 的 AOP 配置

第一步：拷贝必备的 jar 包到工程的 lib 目录

第二步：创建 spring 的配置文件并导入约束

1
2
3
4
5
6
7
8
9
10
此处要导入 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: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">
</beans>

第四步：配置 spring 的 ioc

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<!-- 配置 service --> 
<bean id="accountService" class="com.ep.service.impl.AccountServiceImpl"> 
    <property name="accountDao" ref="accountDao"></property>
</bean>
<!-- 配置 dao --> 
<bean id="accountDao" class="com.ep.dao.impl.AccountDaoImpl">
    <property name="dbAssit" ref="dbAssit"></property>
</bean>
<!-- 配置数据库操作对象 --> 
<bean id="dbAssit" class="com.ep.dbassit.DBAssit"> 
    <property name="dataSource" ref="dataSource"></property>
	<!-- 指定 connection 和线程绑定 --> 
    <property name="useCurrentConnection" value="true"></property>
</bean>
<!-- 配置数据源 --> 
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> 
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property> 
    <property name="jdbcUrl" value="jdbc:mysql:///spring_day02"></property> 
    <property name="user" value="root"></property> 
    <property name="password" value="1234"></property>
</bean>

第四步：抽取公共代码制作成通知

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/**
* 事务控制类
*/
public class TransactionManager {
	//定义一个 DBAssit
	private DBAssit dbAssit ;
	public void setDbAssit(DBAssit dbAssit) {
		this.dbAssit = dbAssit; 
    }
	//开启事务
	public void beginTransaction() {
		try {
			dbAssit.getCurrentConnection().setAutoCommit(false);
		} catch (SQLException e) {
			e.printStackTrace();
		}
    }
    //提交事务
	public void commit() {
		try {
			dbAssit.getCurrentConnection().commit();
		} catch (SQLException e) {
			e.printStackTrace();
		}
    }
	//回滚事务
	public void rollback() {
		try {
			dbAssit.getCurrentConnection().rollback();
		} catch (SQLException e) {
			e.printStackTrace();
		} 
    }
	//释放资源
	public void release() {
		try {
			dbAssit.releaseConnection();
		} catch (Exception e) {
			e.printStackTrace();
		} 
    } 
}

配置步骤

第一步：把通知类用 bean 标签配置起来

1
2
3
4
<!-- 配置通知 --> 
<bean id="txManager" class="com.ep.utils.TransactionManager"> 
    <property name="dbAssit" ref="dbAssit"></property>
</bean>

第二步：使用 aop:config 声明 aop 配置

aop:config:
作用：用于声明开始 aop 的配置

1
2
3
<aop:config>
    <!-- 配置的代码都写在此处 -->
</aop:config>

第三步：使用 aop:aspect 配置切面

aop:aspect:

作用：用于配置切面。

属性：id：给切面提供一个唯一标识。 ref：引用配置好的通知类 bean 的 id。 

1
2
3
<aop:aspect id="txAdvice" ref="txManager">
	<!--配置通知的类型要写在此处-->
</aop:aspect>

第四步：使用 aop:pointcut 配置切入点表达式

aop:pointcut：

作用：用于配置切入点表达式。就是指定对哪些类的哪些方法进行增强。

属性：expression：用于定义切入点表达式。 id：用于给切入点表达式提供一个唯一标识

第五步：使用 aop:xxx 配置对应的通知类型

aop:before

作用：用于配置前置通知。指定增强的方法在切入点方法之前执行

属性：method:用于指定通知类中的增强方法名称

​ ponitcut-ref：用于指定切入点的表达式的引用

​ poinitcut：用于指定切入点表达式

执行时间点：切入点方法执行之前执行

<aop:before method=*"beginTransaction"* pointcut-ref=*"pt1"*/>

aop:after-returning

作用：用于配置后置通知

属性：method：指定通知中方法的名称。

​ pointct：定义切入点表达式

​ pointcut-ref：指定切入点表达式的引用

执行时间点：切入点方法正常执行之后。它和异常通知只能有一个执行

<aop:after-returning method=*"commit"* pointcut-ref=*"pt1"*/>

aop:after-throwing

作用：用于配置异常通知

属性：method：指定通知中方法的名称。

​ pointct：定义切入点表达式

​ pointcut-ref：指定切入点表达式的引用

执行时间点：切入点方法执行产生异常后执行。它和后置通知只能执行一个

<aop:after-throwing method=*"rollback"* pointcut-ref=*"pt1"*/>

aop:after

作用：用于配置最终通知

属性：method：指定通知中方法的名称。

​ pointct：定义切入点表达式

​ pointcut-ref：指定切入点表达式的引用

执行时间点：无论切入点方法执行时是否有异常，它都会在其后面执行。

<aop:after method=*"release"* pointcut-ref=*"pt1"*/>

切入点表达式说明

**execution:**匹配方法的执行(常用)

execution(表达式)

表达式语法：execution([修饰符] 返回值类型 包名.类名.方法名(参数))

写法说明：

​ 全匹配方式：

​ public void com.ep.service.impl.AccountServiceImpl.saveAccount(com.ep.domain.Account)

​ 访问修饰符可以省略

​ void com.ep.service.impl.AccountServiceImpl.saveAccount(com.ep.domain.Account)

​ 返回值可以使用*号，表示任意返回值

​ * com.ep.service.impl.AccountServiceImpl.saveAccount(com.ep.domain.Account)

​ 包名可以使用*号，表示任意包，但是有几级包，需要写几个*

​ * *.*.*.*.AccountServiceImpl.saveAccount(com.ep.domain.Account)

​ 使用..来表示当前包，及其子包

​ * com..AccountServiceImpl.saveAccount(com.ep.domain.Account)

​ 类名可以使用*号，表示任意类

​ * com..*.saveAccount(com.ep.domain.Account)

​ 方法名可以使用*号，表示任意方法

​ * com..*.*( com.ep.domain.Account)

​ 参数列表可以使用*，表示参数可以是任意数据类型，但是必须有参数

​ * com..*.*(*)

​ 参数列表可以使用..表示有无参数均可，有参数可以是任意类型

​ com..*.*(..)

​ 全通配方式：

​ ..*.*(..)

注：

通常情况下，我们都是对业务层的方法进行增强，所以切入点表达式都是切到业务层实现类。

execution(* com.ep.service.impl..(..))

环绕通知

配置方式:

1
2
3
4
5
6
 <aop:config> 
     <aop:pointcut expression="execution(* com.ep.service.impl.*.*(..))"id="pt1"/>
<aop:aspect id="txAdvice" ref="txManager">
<!-- 配置环绕通知 --> 
    <aop:around method="transactionAround" pointcut-ref="pt1"/></aop:aspect>
</aop:config>

aop:around：

作用：用于配置环绕通知

属性：method：指定通知中方法的名称。

​ pointct：定义切入点表达式

​ pointcut-ref：指定切入点表达式的引用

说明：它是 spring 框架为我们提供的一种可以在代码中手动控制增强代码什么时候执行的方式。

注意：通常情况下，环绕通知都是独立使用的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/**
* 环绕通知
* @param pjp
* spring 框架为我们提供了一个接口：ProceedingJoinPoint，它可以作为环绕通知的方法参数。
* 在环绕通知执行时，spring 框架会为我们提供该接口的实现类对象，我们直接使用就行。
* @return
*/
public Object transactionAround(ProceedingJoinPoint pjp) {
	//定义返回值
	Object rtValue = null;
	try {
		//获取方法执行所需的参数
		Object[] args = pjp.getArgs();
		//前置通知：开启事务
		beginTransaction();
		//执行方法
		rtValue = pjp.proceed(args);
		//后置通知：提交事务
		commit();
	}catch(Throwable e) {
		//异常通知：回滚事务
		rollback();
		e.printStackTrace();
	}finally {
		//最终通知：释放资源
		release();
	}
	return rtValue; 
}

5.4基于注解的 AOP 配置

第一步：准备必要的代码和 jar 包

第二步：在配置文件中导入 context 的名称空间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"		 					       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
	 http://www.springframework.org/schema/aop
 	http://www.springframework.org/schema/aop/spring-aop.xsd
 	http://www.springframework.org/schema/context
 	http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 配置数据库操作对象 --> 
    <bean id="dbAssit" class="com.ep.dbassit.DBAssit"> 
        <property name="dataSource" ref="dataSource"></property>
		<!-- 指定 connection 和线程绑定 --> 
        <property name="useCurrentConnection" value="true"></property>
	</bean>
<!-- 配置数据源 --> 
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> 
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///spring_day02"></property> 
        <property name="user" value="root"></property>
        <property name="password" value="1234"></property>
	</bean>
</beans>

第三步：把资源使用注解配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
* 账户的业务层实现类
*/
@Service("accountService")
public class AccountServiceImpl implements IAccountService {
	@Autowired
	private IAccountDao accountDao;
}

/**
* 账户的持久层实现类
*/
@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {
	@Autowired
	private DBAssit dbAssit ; 
}

第四步：在配置文件中指定 spring 要扫描的包

1
2
<!-- 告知 spring，在创建容器时要扫描的包 --> 
<context:component-scan base-package="com.ep"></context:component-scan>

配置步骤

第一步：把通知类也使用注解配置

1
2
3
4
5
6
7
8
9
/**
* 事务控制类
*/
@Component("txManager")
public class TransactionManager {
	//定义一个 DBAssit
	@Autowired
	private DBAssit dbAssit ; 
}

第二步：在通知类上使用@Aspect注解声明为切面

作用：把当前类声明为切面类。

1
2
3
4
5
6
7
8
9
10
/**
* 事务控制类
*/
@Component("txManager")
@Aspect//表明当前类是一个切面类
public class TransactionManager {
	//定义一个 DBAssit
	@Autowired
	private DBAssit dbAssit ; 
}

2.3.2.3 第三步：在增强的方法上使用注解配置通知

@Before

作用：把当前方法看成是前置通知。

属性：value：用于指定切入点表达式，还可以指定切入点表达式的引用。

1
2
3
4
5
6
7
8
9
10
//开启事务

@Before("execution(* com.ep.service.impl.*.*(..))")
public void beginTransaction() {
	try{
		dbAssit.getCurrentConnection().setAutoCommit(false);
	} catch (SQLException e) {
		e.printStackTrace();
	} 
}

@AfterReturning

作用：把当前方法看成是后置通知。

属性：value：用于指定切入点表达式，还可以指定切入点表达式的引用

1
2
3
4
5
6
7
8
9
10
//提交事务

@AfterReturning("execution(* com.ep.service.impl.*.*(..))")
public void commit() {
	try {
		dbAssit.getCurrentConnection().commit();
	} catch (SQLException e) {
		e.printStackTrace();
	}
}

@AfterThrowing

作用：把当前方法看成是异常通知。

属性：value：用于指定切入点表达式，还可以指定切入点表达式的引用

1
2
3
4
5
6
7
8
9
//回滚事务
@AfterThrowing("execution(* com.ep.service.impl.*.*(..))")
public void rollback() {
	try {
		dbAssit.getCurrentConnection().rollback();
	} catch (SQLException e) {
		e.printStackTrace();
	} 
}

@After

作用：把当前方法看成是最终通知。

属性：value：用于指定切入点表达式，还可以指定切入点表达式的引用

1
2
3
4
5
6
7
8
9
//释放资源
@After("execution(* com.ep.service.impl.*.*(..))")
public void release() {
	try{
		dbAssit.releaseConnection();
	} catch (Exception e) {
		e.printStackTrace();
	} 
}

第四步：在 spring 配置文件中开启 spring 对注解 AOP 的支持

aop:aspectj-autoproxy/

环绕通知注解配置

@Around

作用：把当前方法看成是环绕通知。

属性：value：用于指定切入点表达式，还可以指定切入点表达式的引用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
* 环绕通知
* @param pjp
* @return
*/

@Around("execution(* com.ep.service.impl.*.*(..))")

public Object transactionAround(ProceedingJoinPoint pjp) {
	//定义返回值
	Object rtValue = **null**;
	try{
		//获取方法执行所需的参数
		Object[] args = pjp.getArgs();
		//前置通知：开启事务
		beginTransaction();
		//执行方法
		rtValue = pjp.proceed(args);
		//后置通知：提交事务
		commit();
	}catch(Throwable e) {
		//异常通知：回滚事务
		rollback();
		e.printStackTrace();
	}finally {
		//最终通知：释放资源
		release();
	}
	return rtValue; 
}

切入点表达式注解

@Pointcut

作用：指定切入点表达式

属性：value：指定表达式的内容

1
2
@Pointcut("execution(* com.ep.service.impl.*.*(..))")
private void pt1() {}

引用方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/**
* 环绕通知
* @param pjp
* @return
*/
@Around("pt1()")//注意：千万别忘了写括号
public Object transactionAround(ProceedingJoinPoint pjp) {
	//定义返回值
	Object rtValue = **null**;
	try {
		//获取方法执行所需的参数
		Object[] args = pjp.getArgs();
		//前置通知：开启事务
		beginTransaction();
		//执行方法
		rtValue = pjp.proceed(args);
		//后置通知：提交事务
		commit();
	}catch(Throwable e) {
		//异常通知：回滚事务
		rollback();
		e.printStackTrace();
	}finally {
		//最终通知：释放资源
		release();
	}
	return rtValue; 
}

不使用 XML 的配置方式

1
2
3
4
5
6
@Configuration
@ComponentScan(basePackages="com.ep")
@EnableAspectJAutoProxy
public class SpringConfiguration {

}
#Spring #后端框架
Spring
http://example.com/2022/07/25/Spring/
作者
Deng ErPu
发布于
2022年7月25日
许可协议