SpringAOP笔记

百度定义：
在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
AOP思想：横向重复，纵向抽取。
为什么学习AOP？
AOP可以进行权限校验、日志记录、事务管理、性能监测等。
AOP思想体现：
1、乱码处理

2、事务管理
每一个service进行事务管理（开启事务、回滚事务、提交事务)
…

spring能帮我们生成代理对象，不用手写代理对象代码。
Spring 的 AOP 的底层用到两种代理机制：

• JDK 的动态代理 :针对实现了接口的类产生代理.（优先）
• Cglib 的动态代理 :针对没有实现接口的类产生代理. 应用的是底层的字节码增强的技术生成当前类的子类对象

JDK动态代理代码实现：

//接口
public interface UserService {
 void save();
 void delete();
 void update();
 void find();
}

//实现类
public class UserServiceImpl implements UserService {
 @Override
 public void save() {
  System.out.println("保存用户!");
  //int i = 1/0;
 }
 @Override
 public void delete() {
  System.out.println("删除用户!");
 }
 @Override
 public void update() {
  System.out.println("更新用户!");
 }
 @Override
 public void find() {
  System.out.println("查找用户!");
 }
}
**//原始进行事务管理时，要对上面方法中，都要进行开启事务、提交事务**

//动态代理（生成代理对象）
public class UserServiceProxyFactory implements InvocationHandler {
 
 public UserServiceProxyFactory(UserService us) {
  super();
  this.us = us;
 }
 
 private UserService us;
 
 public UserService getUserServiceProxy(){
  //生成动态代理对象
  UserService usProxy = (UserService) Proxy.newProxyInstance(UserServiceProxyFactory.class.getClassLoader(),
  UserServiceImpl.class.getInterfaces(), this);
  //返回
  return usProxy;
  
 }
 @Override
 public Object invoke(Object arg0, Method method, Object[] arg2) throws Throwable {
  System.out.println("打开事务!");
  Object invoke = method.invoke(us, arg2);
  System.out.println("提交事务!");
  return invoke;
 }
 }

//测试
public class Demo {
 
 @Test
 //动态代理
 public void fun1(){
  UserService us = new UserServiceImpl();
  
  UserServiceProxyFactory factory = new UserServiceProxyFactory(us);
  
  UserService usProxy = factory.getUserServiceProxy();
  //代理对象调用方法，已经进行增强
  usProxy.save();
  usProxy.delete();
  
  //代理对象与被代理对象实现了相同的接口
  //代理对象 与 被代理对象没有继承关系
  System.out.println(usProxy instanceof UserServiceImpl );//false
 }
 }

//测试结果
打开事务!
保存用户!
提交事务!
打开事务!
删除用户!
提交事务!
false

以上实现动态代理进行事务管理

Cglib 的动态代理：

public class UserServiceProxyFactory2 implements MethodInterceptor {
public UserService getUserServiceProxy(){
  
  Enhancer en = new Enhancer();//帮我们生成代理对象
  
  en.setSuperclass(UserServiceImpl.class);//设置对谁进行代理
  
  en.setCallback(this);//代理要做什么
  
  UserService us = (UserService) en.create();//创建代理对象
  
  return us;
 }
 @Override
 public Object intercept(Object prxoyobj, Method method, Object[] arg, MethodProxy methodProxy) throws Throwable {
  //打开事务
  System.out.println("打开事务!");
  //调用原有方法
  Object returnValue = methodProxy.invokeSuper(prxoyobj, arg);
  //提交事务
  System.out.println("提交事务!");
  
  return returnValue;
  }
  }

//测试cglib代理
@Test
 public void fun2(){
  
  UserServiceProxyFactory2 factory = new UserServiceProxyFactory2();
  
  UserService usProxy = factory.getUserServiceProxy();
  
  usProxy.delete();
  
  //判断代理对象是否属于被代理对象类型
  //代理对象继承了被代理对象=>true
  System.out.println(usProxy instanceof UserServiceImpl );//true
 }
}

//测试结果
打开事务!
删除用户!
提交事务!
true

AOP 的开发中的相关术语
此处结合上面的代码进行解释，不使用官方定义

1、Spring 使用 AspectJ 进行 AOP 的开发：XML 的方式
目标对象：使用上面的UserServiceImpl
切面类（通知类）：

//通知类
public class MyAdvice {
 
 //前置通知 
//  |-目标方法运行之前调用
 //后置通知(如果出现异常不会调用)
//  |-在目标方法运行之后调用
 //环绕通知
//  |-在目标方法之前和之后都调用
 //异常拦截通知
//  |-如果出现异常,就会调用
 //后置通知(无论是否出现 异常都会调用)
//  |-在目标方法运行之后调用
//----------------------------------------------------------------
 //前置通知
 public void before(){
  System.out.println("这是前置通知!!");
 }
 //后置通知
 public void afterReturning(){
  System.out.println("这是后置通知(如果出现异常不会调用)!!");
 }
 //环绕通知
 public Object around(ProceedingJoinPoint pjp) throws Throwable {
  System.out.println("这是环绕通知之前的部分!!");
  Object proceed = pjp.proceed();//调用目标方法
  System.out.println("这是环绕通知之后的部分!!");
  return proceed;
 }
 //异常通知
 public void afterException(){
  System.out.println("出事啦!出现异常了!!");
 }
 //后置通知
 public void after(){
  System.out.println("这是后置通知(出现异常也会调用)!!");
 }
}

XML配置完成增强

//省略头部
<!-- 准备工作: 导入aop(约束)命名空间 -->
<!-- 1.配置目标对象 -->
 <bean name="userService" class="cn.yuwen.service.UserServiceImpl" ></bean>
<!-- 2.配置通知对象 -->
 <bean name="myAdvice" class="cn.yuwen.d_springaop.MyAdvice" ></bean>
<!-- 3.配置将通知织入目标对象 -->
 <aop:config>
  <!-- 配置切入点 
   public void cn.yuwen.service.UserServiceImpl.save() 
   void cn.yuwen.service.UserServiceImpl.save()
   * cn.yuwen.service.UserServiceImpl.save()
   * cn.yuwen.service.UserServiceImpl.*()
   
   * cn.yuwen.service.*ServiceImpl.*(..)
   * cn.yuwen.service..*ServiceImpl.*(..)
  -->
  <aop:pointcut expression="execution(* cn.yuwen.service.*ServiceImpl.*(..))" id="pc"/>
  <aop:aspect ref="myAdvice" >
   <!-- 指定名为before方法作为前置通知 -->
   <aop:before method="before" pointcut-ref="pc" />
   <!-- 后置 -->
   <aop:after-returning method="afterReturning" pointcut-ref="pc" />
   <!-- 环绕通知 -->
   <aop:around method="around" pointcut-ref="pc" />
   <!-- 异常拦截通知 -->
   <aop:after-throwing method="afterException" pointcut-ref="pc"/>
   <!-- 后置 -->
   <aop:after method="after" pointcut-ref="pc"/>
  </aop:aspect>
 </aop:config>
</beans>

测试

public class Demo {
 @Resource(name="userService")
 private UserService us;
 
 @Test
 public void fun1(){
  us.save();
 }
 
}
//结果
这是前置通知!!
这是环绕通知之前的部分!!
保存用户!
这是后置通知(出现异常也会调用)!!
这是环绕通知之后的部分!!
这是后置通知(如果出现异常不会调用)!!

2、使用注解形式的AOP开发

<!-- 准备工作: 导入aop(约束)命名空间 -->
<!-- 1.配置目标对象 -->
 <bean name="userService" class="cn.itcast.service.UserServiceImpl" ></bean>
<!-- 2.配置通知对象 -->
 <bean name="myAdvice" class="cn.itcast.e_annotationaop.MyAdvice" ></bean>
<!-- 3.开启使用注解完成织入 -->
 <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
 

注解配置通知类

//通知类
@Aspect
//表示该类是一个通知类
public class MyAdvice {
 @Pointcut("execution(* cn.itcast.service.*ServiceImpl.*(..))")
 public void pc(){}
 //前置通知
 //指定该方法是前置通知,并制定切入点
 @Before("MyAdvice.pc()")
 public void before(){
  System.out.println("这是前置通知!!");
 }
 //后置通知
 @AfterReturning("execution(* cn.itcast.service.*ServiceImpl.*(..))")
 public void afterReturning(){
  System.out.println("这是后置通知(如果出现异常不会调用)!!");
 }
 //环绕通知
 @Around("execution(* cn.itcast.service.*ServiceImpl.*(..))")
 public Object around(ProceedingJoinPoint pjp) throws Throwable {
  System.out.println("这是环绕通知之前的部分!!");
  Object proceed = pjp.proceed();//调用目标方法
  System.out.println("这是环绕通知之后的部分!!");
  return proceed;
 }
 //异常通知
 @AfterThrowing("execution(* cn.itcast.service.*ServiceImpl.*(..))")
 public void afterException(){
  System.out.println("出事啦!出现异常了!!");
 }
 //后置通知
 @After("execution(* cn.itcast.service.*ServiceImpl.*(..))")
 public void after(){
  System.out.println("这是后置通知(出现异常也会调用)!!");
 }
}

测试

public class Demo {
 @Resource(name="userService")
 private UserService us;
 
 @Test
 public void fun1(){
  us.delete();
 }
 
}
//测试结果
这是环绕通知之前的部分!!
这是前置通知!!
删除用户!
这是环绕通知之后的部分!!
这是后置通知(出现异常也会调用)!!
这是后置通知(如果出现异常不会调用)!!

可看事务管理篇！