Spring中的AOP
完善day02的案例
- 添加一个新方法:转账(
public void transfer(String sourceName, String targetName, Float Money)
)
- 工具类:连接的工具类,它用于从数据源中获取一个连接,并且实现和线程的绑定
public class ConnectionUtils {
private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
private DataSource dataSource;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
public Connection getThreadConnection() {
try{
Connection conn = tl.get();
if (conn == null) {
conn = dataSource.getConnection();
tl.set(conn);
}
return conn;
}catch (Exception e){
throw new RuntimeException(e);
}
}
public void removeConnection(){
tl.remove();
}
}
- 工具类:和事务管理相关的工具类,它包含了,开启事务,提交事务,回滚事务和释放连接
public class TransactionManager {
private ConnectionUtils connectionUtils;
public void setConnectionUtils(ConnectionUtils connectionUtils) {
this.connectionUtils = connectionUtils;
}
public void beginTransaction(){
try {
connectionUtils.getThreadConnection().setAutoCommit(false);
}catch (Exception e){
e.printStackTrace();
}
}
public void commit(){
try {
connectionUtils.getThreadConnection().commit();
}catch (Exception e){
e.printStackTrace();
}
}
public void rollback(){
try {
connectionUtils.getThreadConnection().rollback();
}catch (Exception e){
e.printStackTrace();
}
}
public void release(){
try {
connectionUtils.getThreadConnection().close();
connectionUtils.removeConnection();
}catch (Exception e){
e.printStackTrace();
}
}
}
- 业务层实现事务控制
public class AccountServiceImpl_OLD implements IAccountService{
private IAccountDao accountDao;
private TransactionManager txManager;
public void setTxManager(TransactionManager txManager) {
this.txManager = txManager;
}
public void setAccountDao(IAccountDao accountDao) {
this.accountDao = accountDao;
}
@Override
public List<Account> findAllAccount() {
try {
txManager.beginTransaction();
List<Account> accounts = accountDao.findAllAccount();
txManager.commit();
return accounts;
}catch (Exception e){
txManager.rollback();
throw new RuntimeException(e);
}finally {
txManager.release();
}
}
@Override
public Account findAccountById(Integer accountId) {
try {
txManager.beginTransaction();
Account account = accountDao.findAccountById(accountId);
txManager.commit();
return account;
}catch (Exception e){
txManager.rollback();
throw new RuntimeException(e);
}finally {
txManager.release();
}
}
@Override
public void saveAccount(Account account) {
try {
txManager.beginTransaction();
accountDao.saveAccount(account);
txManager.commit();
}catch (Exception e){
txManager.rollback();
}finally {
txManager.release();
}
}
@Override
public void updateAccount(Account account) {
try {
txManager.beginTransaction();
accountDao.updateAccount(account);
txManager.commit();
}catch (Exception e){
txManager.rollback();
}finally {
txManager.release();
}
}
@Override
public void deleteAccount(Integer acccountId) {
try {
txManager.beginTransaction();
accountDao.deleteAccount(acccountId);
txManager.commit();
}catch (Exception e){
txManager.rollback();
}finally {
txManager.release();
}
}
@Override
public void transfer(String sourceName, String targetName, Float money) {
try {
txManager.beginTransaction();
Account source = accountDao.findAccountByName(sourceName);
Account target = accountDao.findAccountByName(targetName);
source.setMoney(source.getMoney()-money);
target.setMoney(target.getMoney()+money);
accountDao.updateAccount(source);
int i=1/0;
accountDao.updateAccount(target);
txManager.commit();
}catch (Exception e){
txManager.rollback();
e.printStackTrace();
}finally {
txManager.release();
}
}
}
分析案例中的问题
- 代码很臃肿,重复代码很多
- 依赖严重—存在于方法之间,如
txManager.beginTransaction()
回顾动态代理
- 特点:字节码随用随创建,随用随加载
- 作用:不修改源码的基础上对方法增强
- 分类:
- 基于接口的动态代理:
- 涉及的类:
Proxy
- 提供者:JDK官方
- 如何创建代理对象:
- 使用
Proxy
类中的newProxyInstance
方法
- 创建代理对象的要求
newProxyInstance
方法的参数
ClassLoader
:类加载器,用于加载代理对象字节码。写的是被代理对象的类加载器(和被代理对象使用相同的类加载器,固定写法,即代理谁就写谁的类.getClass().getClassLoader()
)Class[]
:字节码数组,它是用于让代理对象和被代理对象有相同的方法。只要两个实现同一个接口,就都会由相同的方法(代理谁就写谁的类.getClass().getInterfaces()
)InvocationHandler
:用于提供增强的代码。它是让我们写如何代理。我们一般都是写一个该接口的实现类,通常情况下都是匿名内部类,但不必须(此接口的实现类都是谁用谁写)
InvocationHandler
位置invoke
方法的参数
proxy
:代理对象的引用method
:当前执行的方法args
:当前执行方法所需的参数- 返回值:和被代理对象有相同的返回值
- 例子:
public class Client {
public static void main(String[] args) {
final Producer producer = new Producer();
IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
producer.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object returnValue = null;
Float money = (Float)args[0];
if("saleProduct".equals(method.getName())) {
returnValue = method.invoke(producer, money*0.8f);
}
return returnValue;
}
});
proxyProducer.saleProduct(10000f);
}
}
- 问题:必须实现接口,如果是普通类,则不行
- 基于子类的动态代理
- 第三方jar包(cglib)
<dependencies>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.1_3</version>
</dependency>
</dependencies>
- 涉及的类:
Enhancer
- 提供者:第三方cglib库
- 如何创建代理对象:
- 创建代理对象的要求
- 被代理类不能是最终类(最终类不能创建子类,也就不能创建代理对象了)
create
方法的参数
Class
:字节码。用于指定被代理对象的字节码(即要代理谁,就写谁的.getClass()
)Callback
:用于提供增强的代码。它是让我们写如何代理。我们一般都是写一个该接口的实现类,通常情况下都是匿名内部类,但不必须(此接口的实现类都是谁用谁写)。我们一般写的都是该接口的子接口实现类:MethodInterceptor
(方法拦截)
Callback
位置MethodInterceptor
方法的参数
proxy
:代理对象的引用method
:当前执行的方法args
:当前执行方法所需的参数methodProxy
:当前执行方法的代理对象- 返回值:和被代理对象有相同的返回值
- 实例:
public class Client {
public static void main(String[] args) {
final Producer producer = new Producer();
Producer cglibProducer = (Producer)Enhancer.create(producer.getClass(), new MethodInterceptor() {
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
Object returnValue = null;
Float money = (Float)args[0];
if("saleProduct".equals(method.getName())) {
returnValue = method.invoke(producer, money*0.8f);
}
return returnValue;
}
});
cglibProducer.saleProduct(12000f);
}
}
动态代理改造案例(基于子类的动态代理)
public class BeanFactory {
private IAccountService accountService;
private TransactionManager txManager;
public void setTxManager(TransactionManager txManager) {
this.txManager = txManager;
}
public final void setAccountService(IAccountService accountService) {
this.accountService = accountService;
}
public IAccountService getAccountService() {
return (IAccountService)Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
accountService.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if("test".equals(method.getName())){
return method.invoke(accountService,args);
}
Object rtValue = null;
try {
txManager.beginTransaction();
rtValue = method.invoke(accountService, args);
txManager.commit();
return rtValue;
} catch (Exception e) {
txManager.rollback();
throw new RuntimeException(e);
} finally {
txManager.release();
}
}
});
}
}
<?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 id="proxyAccountService" factory-bean="beanFactory" factory-method="getAccountService"></bean>
<bean id="beanFactory" class="com.itheima.factory.BeanFactory">
<property name="accountService" ref="accountService"></property>
<property name="txManager" ref="txManager"></property>
</bean>
AOP的概念
- Aspect Orented Programing 即面向切面编程
- 在软件业,AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是**OOP(面向对象编程)**的延续,是软件开发中的一-个热点,也是Spring框架中的一一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
- 简单地说就是把我们程序重复的代码抽取出来,在需要执行的时候,使用动态代理的技术,在不修改源码的情况下基础上,对我们的已有方法进行增强
- 优势:减少重复代码、提高开发效率、维护方便
spring总的AOP相关术语
- Joinpoint(连接点):
- 所谓连接点是指那些被拦截到的点,在spring中,这些点指的是方法,因为spring只支持方法类型的连接点。(比如业务层中的方法)
- Ponitcut(切入点):
- 所谓切入点是指我们要对哪些Joinpoint进行拦截的定义
- 所有的切入点都是连接点,但只有被增强的连接点才是切入点
- Advice(通知 /增强 ):
- 所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
- 通知的类型:前置通知,后置通知,异常通知,最终通知,环绕通知。
method.invoke
前面的就是前置,后面的就是后置,catch
里面的就是异常,finally
里面的就是最终,整个invoke
方法正在执行就是环绕通知(在环绕通知中有明确的的切入点方法调用)
- Introduction(引介 :
- 引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field(字段)。
- Target(目标对象):
- Weaving(织入):
- 是指把增强应用到目标对象来创建新的代理对象的过程。(原本的service不支持事务,我们用动态代理的方式返回了一个代理对象,返回代理对象的时候从中加入了事务,这个过程就是织入)
- spring 采用动态代理织入,而 AspectJ 采用编译期织入和类装载期织入。
- Proxy(代理) :
- 一个类被 AOP 织入增强后,就产生一个结果代理类。(
return
回去的)
- Aspect(切面 ):
- 是切入点和通知(引介)的结合。(哪些方法哪些配置哪些顺序)
- 也就是配种文件中,声明切入点于通知间的关系
基于XML的AOP配置
入门入门入门
- 把通知Bean也交给spring来管理
- 使用
aop:config
标签表明开始AOP的配置 - 使用
aop:aspect
标签表明配置切面
id
属性:是给切面提供一个唯一表示ref
属性:是指定通知bean的id
- 在
aop:aspect
标签的内部使用对应标签来配置通知的类型
- 比方说我们现在的实例是让
printLog
方法在切入点方法执行前执行,所以是前置通知 aop:before
:表示前置通知
method
属性:用于指定Logger
类中哪个方法是前置通知pointcut
属性:用于指定切入点表达式,该表达式的含义指的是对业务层中哪些方法进行增强
- 切入点表达式的写法
- 关键字:
execution
(表达式) - 表达式:访问修饰符 返回值 包名.包名.包名…类名.方法名(参数列表)
- 标准写法:
public void com.my.service.impl.AccountServiceImpl.saveAccount()
- 访问修饰符可以省略
- 返回值可以使用通配符,表示任意返回值
- 包名可以使用通配符,表示任意包,但是有几级包就需要写几个
*.
- 包名可以使用
..
表示当前包及其子包 - 类名和方法名都可以使用
*
来实现通配 - 参数列表可以直接写数据类型(基本类型写名称,引用类型写
包名.类名的方式
),也可以写通配符表示任意类型,但是必须有参数,一个参数就一个*
,也可以使用..
表示任意参数 - 全通配写法:
* *..*.*(..)
- 实际开发中通常写法:切到业务层实现类的所有方法
四种通知类型
- 配置前置通知:在切入点方法执行之前执行
- 配置后置通知:在切入点方法正常执行之后值。它和异常通知永远只能执行一个
- 配置异常通知:在切入点方法执行产生异常之后执行。它和后置通知永远只能执行一个
- 配置最终通知:无论切入点方法是否正常执行它都会在其后面执行
- 配置切入点表达式
- id属性用于指定表达式的唯一标识。expression属性用于指定表达式内容
- 此标签写在aop:aspect标签内部只能当前切面使用。
- 它还可以写在aop:aspect外面,此时就变成了所有切面可用
- 配置环绕通知 详细的注释请看Logger类中
<?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">
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>
<bean id="logger" class="com.itheima.utils.Logger"></bean>
<aop:config>
<aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"></aop:pointcut>
<aop:aspect id="logAdvice" ref="logger">
<aop:before method="beforePrintLog" pointcut-ref="pt1" ></aop:before>
<aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning>
<aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing>
<aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>
<aop:around method="aroundPringLog" pointcut-ref="pt1"></aop:around>
</aop:aspect>
</aop:config>
</beans>
public class Logger {
public void beforePrintLog(){
System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。");
}
public void afterReturningPrintLog(){
System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");
}
public void afterThrowingPrintLog(){
System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");
}
public void afterPrintLog(){
System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");
}
public Object aroundPringLog(ProceedingJoinPoint pjp){
Object rtValue = null;
try{
Object[] args = pjp.getArgs();
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");
rtValue = pjp.proceed(args);
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");
return rtValue;
}catch (Throwable t){
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");
throw new RuntimeException(t);
}finally {
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");
}
}
}
- 问题:
- 当我们配置了环绕通知之后,切入点方法没有执行,而通知方法执行了。
- 分析:
- 通过对比动态代理中的环绕通知代码,发现动态代理的环绕通知有明确的切入点方法调用,而我们的代码中没有。
- 解决:
- Spring框架为我们提供了一个接口:
ProceedingJoinPoint
。该接口有一个方法proceed()
,此方法就相当于明确调用切入点方法。 - 该接口可以作为环绕通知的方法参数,在程序执行时,spring框架会为我们提供该接口的实现类供我们使用。(说白了就会直接用就行)
- spring中的环绕通知:
- 它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。
基于注解的AOP配置
- xml开启AOP功能
@Aspect
注解表示当前类是一个切面类
<?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"
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/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">
<context:component-scan base-package="com.itheima"></context:component-scan>
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
package com.itheima.utils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Component("logger")
@Aspect
public class Logger {
@Pointcut("execution(* com.itheima.service.impl.*.*(..))")
private void pt1(){}
@Before("pt1()")
public void beforePrintLog(){
System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。");
}
@AfterReturning("pt1()")
public void afterReturningPrintLog(){
System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");
}
@AfterThrowing("pt1()")
public void afterThrowingPrintLog(){
System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");
}
@After("pt1()")
public void afterPrintLog(){
System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");
}
@Around("pt1()")
public Object aroundPringLog(ProceedingJoinPoint pjp){
Object rtValue = null;
try{
Object[] args = pjp.getArgs();
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");
rtValue = pjp.proceed(args);
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");
return rtValue;
}catch (Throwable t){
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");
throw new RuntimeException(t);
}finally {
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");
}
}
}
纯注解
@Configuration
@ComponentScan(basePackages="com.itheima")
@EnableAspectJAutoProxy
public class SpringConfiguration {
}