Spring-AOP
什么是AOP，为Aspect Oriented Programming
（1）面向切面编程（方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，
提高程序的可重用性，同时提高了开发的效率。 （2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能
AOP的底层原理
AOPJDK 动态代理）
使用JDK动态代理，使用Proxy类里面的方法创建代理对象 Class Proxy java.lang.Object java.lang.reflect.Proxy 里面有个方法 newProxyInstance: static Object newProxyInstance(ClassLoader loader, 类<?>[] interfaces, InvocationHandler h) 返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。 参数解析： 第一参数，类加载器 第二参数，增强方法所在的类，这个类实现的接口，支持多个接口 第三参数，实现这个接口InvocationHandler，创建代理对象，写增强的部分
列子：
接口：
public interface UserDao { public int add(int a,int b); public String update(String id); }
接口的实现类：
public class UserDaoImpl implements UserDao { @Override public int add(int a, int b) { return a+b; } @Override public String update(String id) { return id; } }
动态代理：
public class JDKProxy { public static void main(String[] args) { //创建接口实现类的代理对象 Class[] inter = {UserDao.class}; //为传递给InvocationHandler的实现类的参数new一个需要代理的对象 UserDaoImpl userDao = new UserDaoImpl(); UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), inter, new UserDaoProxy(userDao)); int add = dao.add(1, 2); System.out.println(add); } //实现必须的接口InvocationHandler的实现类 static class UserDaoProxy implements InvocationHandler{ //需要传递过来：创建谁的代理对象，把谁传递过来，通过构造函数 private Object object; public UserDaoProxy(Object object){ this.object = object; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //写入增强的逻辑 // 方法之前 System.out.println("方法之前" + method.getName() + "传递参数" + Arrays.toString(args)); // 被增强的方法执行 Object res = method.invoke(object, args); // 之后 System.out.println("方法之后。。"+object); return res; } } }
那个实现InvacationHandler接口的类，也可以不单独出来，直接使用匿名内部类
public class JDKProxy { public static void main(String[] args) { //创建接口实现类的代理对象 Class[] inter = {UserDao.class}; //为传递给InvocationHandler的实现类的参数new一个需要代理的对象 UserDaoImpl userDao = new UserDaoImpl(); UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), inter, new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //写入增强的逻辑 // 方法之前 System.out.println("方法之前" + method.getName() + "传递参数" + Arrays.toString(args)); // 被增强的方法执行 Object res = method.invoke(userDao, args); // 之后 System.out.println("方法之后。。"+userDao); return res; } }); dao.add(1,2); } }
结果都是一样的：
方法之前add传递参数[1, 2]
方法之后。。com.quan.hlll.UserDaoImpl@66d3c617
AOP当中的术语
1连接点 类里面那些方法可以被增强，这些方法成为接入点 2切入点 实际被真正增强的方法，成为切入点 3通知（增强） 实际增强的逻辑部分成为通知 通知有多种类型 1前置通知 切入点之前 2后置通知 切入点之后 3环绕通知 切入点之前和之后 4异常通知 当切入点出现异常 5最终通知 类似try-catch里面的finally,无论有没有异常都执行 4切面 是动作 把通知应用到切入点的过程 例如，在登陆方法中加入权限判断
AOP操作的准备工作
Spring框架中一般都是基于AspectJ实现AOP操作
注意：AspectJ不是Spring组成部分，是一个独立的AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作
基于AspentJ实现AOP操作
1）基于XML配置文件实现
2）基于注解方式实现（一般使用）
需要在项目工程里面引入AOP相关的依赖
切入点表达式
（1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强
（2）语法结构： execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )
举例1：对com.atguigu.dao.BookDao类里面的add进行增强 execution(* com.atguigu.dao.BookDao.add(..)) 举例2：对com.atguigu.dao.BookDao类里面的所有的方法进行增强 execution(* com.atguigu.dao.BookDao.* (..)) 举例3：对com.atguigu.dao包里面所有类，类里面所有方法进行增强 execution(* com.atguigu.dao.*.* (..))
AOP操作——AspectJ注解
选定要增强的类：
public class User { public void add(){ System.out.println("add...."); } }
创建增强类：
//增强的类
public class UserProxy {
public void before() {
System.out.println("before......");
}
}
修改spring配置文件，开启注解扫描和开启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: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.quan.hlll.aop"/> <!-- 开启 Aspect生成代理对象 它会指定去前面组件扫描包里面进行Aspect注解的烧苗，如果有则生成他的代理类--> <aop:aspectj-autoproxy></aop:aspectj-autoproxy> </beans>
类中加入@Component注解和@Aspect
@Component public class User { public void add(){ System.out.println("add...."); } }
@Component @Aspect public class UserProxy {
配置不同类型的通知：
在增强类的里面，在作为通知方法上面加入通知类型注解，使用切入点表达式进行配置
通知类型注解有：
@Before
@After
@AfterReturning
@AfterThrowing
@Around
加入以上个类注解：
@Component @Aspect public class UserProxy { //前置通知 //Before注解表示前置通知 @Before(value = "execution(* com.quan.hlll.aop.User.add(..))") public void before(){ System.out.println("before..."); } //最终通知 @After(value = "execution(* com.quan.hlll.aop.User.add(..))") public void after(){ System.out.println("After..."); } @AfterReturning(value = "execution(* com.quan.hlll.aop.User.add(..))") public void afterReturning(){ System.out.println("AfterReturning..."); } //异常通知 @AfterThrowing(value = "execution(* com.quan.hlll.aop.User.add(..))") public void afterThrowing(){ System.out.println("AfterThrowing..."); } //环绕通知 @Around(value = "execution(* com.quan.hlll.aop.User.add(..))") public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{ System.out.println("Around之前..."); proceedingJoinPoint.proceed();//让被增强的方法在这里执行 System.out.println("Around之后..."); } }
测试类：
public class TestAop { @Test public void testAopAnno(){ ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml"); User user = ac.getBean("user",User.class); user.add(); } }
结果
Around之前...
before...
add....
Around之后...
After...
AfterReturning...
公共接入点抽取
就是我们上面所有的通知都是对同一个切入点的，所以是公共切入点，我们可以做提取
1在增强类当中编写提取公共切入点的方法，并加上公共切入点注解@Pointcut
2在通知注解，调用该方法即可
@Component @Aspect public class UserProxy { //提取相同的切入点 @Pointcut("execution(* com.quan.hlll.aop.User.add(..))") public void pointCutDemo(){ } //前置通知 //Before注解表示前置通知 @Before(value = "pointCutDemo()") public void before(){ System.out.println("before..."); } //最终通知 @After(value = "pointCutDemo()") public void after(){ System.out.println("After..."); } @AfterReturning(value = "pointCutDemo()") public void afterReturning(){ System.out.println("AfterReturning..."); } //异常通知 @AfterThrowing(value = "pointCutDemo()") public void afterThrowing(){ System.out.println("AfterThrowing..."); } //环绕通知 @Around(value = "pointCutDemo()") public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{ System.out.println("Around之前..."); proceedingJoinPoint.proceed(); System.out.println("Around之后..."); } }
有多个增强类多同一个方法进行增强，设置增强类优先级
在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高
@Component @Aspect @Order(1) public class PersonProxy { //提取相同的切入点 @Pointcut("execution(* com.quan.hlll.aop.User.add(..))") public void pointCutDemo(){ } //Before注解表示前置通知 @Before(value = "pointCutDemo()") public void before(){ System.out.println("Person---before..."); } }
@Component @Aspect @Order(3) public class UserProxy {
结果：
Person---before...
Around之前...
before...
add....
Around之后...
After...
AfterReturning...
AOP操作-AspectJ配置文件
浙公网安备 33010602011771号