spring-AOP动态代理，以及aspectJ的xml配置或注解配置方法，各个拦截器的使用顺序
package com.itheima.aspect;
public class MyAspect {
public void check_Permissions(){
System.out.println("模拟检查权限...");
}
public void log() {
// TODO Auto-generated method stub
System.out.println("记录日志");
}
}
package com.itheima.aspect;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import com.itheima.jdk.UserDao;
public class JdkProxy implements InvocationHandler{
private UserDao userDao;
public Object createProxy(UserDao userDao){
this.userDao=userDao;
ClassLoader classLoader=JdkProxy.class.getClassLoader();
Class[]clazz = userDao.getClass().getInterfaces();
return Proxy.newProxyInstance(classLoader, clazz, this);
}
@Override
public Object invoke(Object proxy,Method method,Object[]args)
throws Throwable{
MyAspect myAspect = new MyAspect();
myAspect.check_Permissions();
Object obj = method.invoke(userDao,args);
myAspect.log();
return obj;
}
}
package com.itheima.aspect;
import com.itheima.jdk.UserDao;
import com.itheima.jdk.UserDaoImpl;
public class JdkTest {
public static void main(String[] args) {
JdkProxy jdkProxy= new JdkProxy();
UserDao userDao = new UserDaoImpl();
UserDao userDao1= (UserDao)jdkProxy.createProxy(userDao);
userDao1.addUser();
userDao1.deleteUser();
}
}
AOP动态代理方法的实现如上，不过总体来说还是比较麻烦，要修改的地方也太多。
后来有人开发了aspectJ工具，通过aspectJ，可以方便的使用切面，把代理类和实现类与代理类之间的耦合解除。
aspectJ有两种实现方式，一种是xml，一种是注解。
这里要注意需要导入aspectJ的相关包
方式1：通过xml实现
将代理类和实现类与代理类之间的调用关系，全部写进xml中：
即以上的代码修改一下：
切面：
package com.itheima.aspectj.xml;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
public class MyAspect {
public void myBefore(JoinPoint joinPoint){
System.out.println("前置通知");
System.out.println("目标类是："+joinPoint.getTarget());
System.out.println(",被植入增强处理的目标方法位："+joinPoint.getSignature());
}
public void myAfterReturning(JoinPoint joinPoint){
System.out.println("后置通知");
System.out.println(",被植入增强处理的目标方法位："+joinPoint.getSignature());
}
public Object myAround(ProceedingJoinPoint joinPoint)
throws Throwable{
System.out.println("环绕开始：执行方法之前，模拟开启事务");
Object object=joinPoint.proceed();
System.out.println("环绕结束：执行方法之后，模拟关闭事务");
return object;
}
public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
System.out.println("异常通知："+"出错了"+e.getMessage());
System.out.println("目标类是："+joinPoint.getTarget());
System.out.println(",被植入增强处理的目标方法位："+joinPoint.getSignature());
}
public void myAfter(JoinPoint joinPoint){
System.out.println("最终通知：模拟方法结束后释放资源");
}
}
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:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.1.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd"> <bean id = "userDao" class = "com.itheima.jdk.UserDaoImpl"/> <bean id = "myAspect" class = "com.itheima.aspectj.xml.MyAspect"/> <aop:config> <aop:aspect id = "aspect" ref = "myAspect"> <aop:pointcut expression = "execution(* com.itheima.jdk.*.*(..))" id = "myPointCut"/> <aop:before method = "myBefore" pointcut-ref="myPointCut"/> <aop:after-returning method="myAfterReturning" pointcut-ref = "myPointCut" returning = "returnVal"/> <aop:around method="myAround" pointcut-ref="myPointCut"/> <aop:after-throwing method = "myAfterThrowing" pointcut-ref = "myPointCut" throwing="e"/> <aop:after method="myAfter" pointcut-ref="myPointCut"/> </aop:aspect> </aop:config> </beans>
测试类：
package com.itheima.aspectj.xml;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.itheima.jdk.UserDao;
public class AspectjXmlTest {
public static void main(String[] args) {
ClassPathXmlApplicationContext applicationContext =
new ClassPathXmlApplicationContext("com/itheima/aspectj/xml/applicationContext.xml");
UserDao userDao= (UserDao) applicationContext.getBean("userDao");
userDao.addUser();
userDao.deleteUser();
}
}
执行结果：
前置通知 目标类是：com.itheima.jdk.UserDaoImpl@59309333 ,被植入增强处理的目标方法位：void com.itheima.jdk.UserDao.addUser() 环绕开始：执行方法之前，模拟开启事务 添加用户 最终通知：模拟方法结束后释放资源 环绕结束：执行方法之后，模拟关闭事务 后置通知 ,被植入增强处理的目标方法位：void com.itheima.jdk.UserDao.addUser() 前置通知 目标类是：com.itheima.jdk.UserDaoImpl@59309333 ,被植入增强处理的目标方法位：void com.itheima.jdk.UserDao.deleteUser() 环绕开始：执行方法之前，模拟开启事务 删除用户 最终通知：模拟方法结束后释放资源 环绕结束：执行方法之后，模拟关闭事务 后置通知 ,被植入增强处理的目标方法位：void com.itheima.jdk.UserDao.deleteUser()
aspectJ减少了动态代理实现中出现的代码臃肿，但是，需要修改spring的配置文件，不是很好。
于是衍生了注解方式实现AOP，完美解决了修改spring配置文件的问题。
package com.itheima.aspectj.annotation;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class MyAspect {
//defined the pointcut
@Pointcut("execution(* com.itheima.jdk.*.*(..))")
private void myPointCut(){}
//pre-notification
@Before("myPointCut()")
public void myBefore(JoinPoint joinPoint){
System.out.println("前置通知");
System.out.println("目标类是："+joinPoint.getTarget());
System.out.println(",被植入增强处理的目标方法位："+joinPoint.getSignature());
}
//after-notification
@AfterReturning(value="myPointCut()")
public void myAfterReturning(JoinPoint joinPoint){
System.out.println("后置通知");
System.out.println(",被植入增强处理的目标方法位："+joinPoint.getSignature());
}
//around-notification
@Around("myPointCut()")
public Object myAround(ProceedingJoinPoint joinPoint)
throws Throwable{
System.out.println("环绕开始：执行方法之前，模拟开启事务");
Object object=joinPoint.proceed();
System.out.println("环绕结束：执行方法之后，模拟关闭事务");
return object;
}
@AfterThrowing(value="myPointCut()",throwing="e")
public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
System.out.println("异常通知："+"出错了"+e.getMessage());
System.out.println("目标类是："+joinPoint.getTarget());
System.out.println(",被植入增强处理的目标方法位："+joinPoint.getSignature());
}
@After("myPointCut()")
public void myAfter(JoinPoint joinPoint){
System.out.println("最终通知：模拟方法结束后释放资源");
}
}
<context:component-scan base-package="com.itheima" /> <aop:aspectj-autoproxy />
public class AspectjXmlTest {
public static void main(String[] args) {
ClassPathXmlApplicationContext applicationContext =
new ClassPathXmlApplicationContext("com/itheima/aspectj/annotation/applicationContext.xml");
UserDao userDao= (UserDao) applicationContext.getBean("userDao");
userDao.addUser();
userDao.deleteUser();
}
}
