背景：
需求：
给一个计算器计算函数执行前后添加日志。
实现：
1）直接在函数中修改代码；
IArithmeticCalculator.java接口类
package com.dx.spring.beans.aop; public interface IArithmeticCalculator { // Addition, subtraction, multiplication, and division int add(int i, int j); int sub(int i, int j); int multi(int i, int j); int div(int i, int j); }
实现类中添加日志：
package com.dx.spring.beans.aop; public class ArithmeticCalculatorImpl implements IArithmeticCalculator { @Override public int add(int i, int j) { System.out.println("method add before"); int result = i + j; System.out.println("method add after"); return result; } @Override public int sub(int i, int j) { System.out.println("method sub before"); int result = i - j; System.out.println("method sub after"); return result; } @Override public int multi(int i, int j) { System.out.println("method multi before"); int result = i * j; System.out.println("method multi after"); return result; } @Override public int div(int i, int j) { System.out.println("method div before"); int result = i / j; System.out.println("method div after"); return result; } }
2）Java动态代理，实现参考《Java中动态代理方式：》；
ArithmeticCalculatorImpl.Java实现：
package com.dx.spring.beans.aop; public class ArithmeticCalculatorImpl implements IArithmeticCalculator { @Override public int add(int i, int j) { int result = i + j; return result; } @Override public int sub(int i, int j) { int result = i - j; return result; } @Override public int multi(int i, int j) { int result = i * j; return result; } @Override public int div(int i, int j) { int result = i / j; return result; } }
ProxyFactory.java动态代理工厂：
package com.dx.spring.beans.aop; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class ProxyFactory { private Object target=null; public ProxyFactory(Object target) { this.target = target; } /** * 给目标对象生成代理对象 */ public Object getProxyInstance() { ClassLoader classLoader = target.getClass().getClassLoader(); Class<?>[] interfaces = target.getClass().getInterfaces(); InvocationHandler invocationHandler = new InvocationHandler() { public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { before(method); // 执行目标对象方法 Object returnValue = method.invoke(target, args); after(method); return returnValue; } }; return Proxy.newProxyInstance(classLoader, interfaces, invocationHandler); } private void before(Method method) { System.out.println("before " + method); } private void after(Method method) { System.out.println("after " + method); } }
调用测试Client.java:
package com.dx.spring.beans.aop; public class Client { public static void main(String[] args) { IArithmeticCalculator arithmeticCalculator = new ArithmeticCalculatorImpl(); // int result=arithmeticCalculator.add(1, 2); // System.out.println(result); IArithmeticCalculator arithmeticCalculatorProxyFactory = (IArithmeticCalculator) new ProxyFactory(arithmeticCalculator).getProxyInstance(); int result = arithmeticCalculatorProxyFactory.add(1, 2); System.out.println(result); } }
3）Spring AOP实现。
下边会举例，这里暂时不举例。
AOP：
AOP简介：
1）AOP（Aspect-Oriented Programming，面向切面编程）：是一种新的方法论，是对传统OOP(Object-Oriented Programming，面向对象编程)的补充。
2）AOP的主要编程对象是切面（aspect），而切面模块化横切关注点。
3）在应用AOP编程时，任然需要定义公共功能，但可以明确的定义这个功能在哪里，以什么方式应用，并且不必修改受影响的类。这样一来横切关注点就被模块化到特殊的对象（切面）里。
4）AOP的好处：
---- 每个事物逻辑位于一个位置，代码不分散，便于维护和升级；
---- 业务模块更简洁，只包含核心业务代码。
AOP术语：
1）切面（aspect）：横切关注点（跨越应用程序多个模块的功能）被模块化的特殊对象；
2）通知（advice）：切面必须要完成的工作；
3）目标（target）：被通知的对象；
4）连接点（Joinpoint）：程序执行的某个特定位置：如类某个方法调用前、调用后、方法抛出异常后等。
连接点由两个信息确定：方法表示的程序执行点、相对点表示的方位。
例如：ArithmethicCalculator#add()方法执行前的连接点执行点为ArithmethicCalculator#add()；方位为该方法执行前的位置。
5）切点（pointcut）：每个类都拥有多个连接点：例如ArithmethicCalculator的所有方法实际上都是连接点，即连接点是程序类中客观存在的事务。
AOP通过切点位置到特定的连接点。类比：连接点相当于数据库中的记录，切点相当于查询条件。切点和连接点不是一对一的关系，一个切点匹配多个连接点，切点通过org.springframework.aop.Pointcut接口进行描述，它使用类和方法作为连接点的查询条件。
Spring AOP
1）AspectJ：java社区里最完整最流行的AOP框架。在Spring2.0以上版本中，可以使用AspectJ注解或基于XML配置的AOP。
备注：先学习基于AspectJ注解的方式，接着再学习基于XML配置。
2） 在Spring中启动AspectJ注解支持：
- 要在Spring应用中使用AspectJ注解，必须在ClassPath下包含AspectJ类库：aopalliance.jar、aspectj.wearver.jar和spring-aspects.jar；
- 将aop schema添加到<beans>根元素中；
- 要在Spring IOC容器中启用AspectJ注解支持，只要在Bean配置文件中定义一个空的xml元素<aop:aspectj-auotproxy>；
- 当Spring IOC容器侦测到Bean配置文件中的<aop:aspectj-autoproxy>元素是，会自动为与aspectj切面匹配的bean创建代理。
Spring AOP实现需求：
第一步：导入spring aop依赖包&额外依赖包（aopalliance.jar、asm.jar、aspectjrt.jar、aspectjweaver.jar）；
Aop额外依赖包：aopalliance.jar、asm.jar、aspectjrt.jar、aspectjweaver.jar下载：链接：https://pan.baidu.com/s/1SjYtrfrUwPIZXikr4guXkg 密码：lowr
第二步：添加spring-aop.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: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/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"> <!-- 配置自动扫描的包 --> <context:component-scan base-package="com.dx.spring.beans.aop"></context:component-scan> <!-- 配置是AspectJ注解起作用 ：自动为匹配的类生成代理对象 --> <aop:aspectj-autoproxy></aop:aspectj-autoproxy> </beans>
第三步：添加Spring组件
IArithmeticCalculator.java组件接口
package com.dx.spring.beans.aop; /** * Description：Addition, subtraction, multiplication, and division */ public interface IArithmeticCalculator { int add(int i, int j); int sub(int i, int j); int multi(int i, int j); int div(int i, int j); }
ArithmeticCalculatorImpl.java组件
package com.dx.spring.beans.aop; import org.springframework.stereotype.Component; @Component("arithmeticCalculator") public class ArithmeticCalculatorImpl implements IArithmeticCalculator { @Override public int add(int i, int j) { int result = i + j; return result; } @Override public int sub(int i, int j) { int result = i - j; return result; } @Override public int multi(int i, int j) { int result = i * j; return result; } @Override public int div(int i, int j) { int result = i / j; return result; } }
第四步：给Spring组件添加LoggingAspect切面类：
LoggingAspect.java切面类
package com.dx.spring.beans.aop; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.springframework.stereotype.Component; //把这个类声明为一个切面：需要把该类放入到IOC容器中、再声明为一个切面。 @Aspect @Component public class LoggingAspect { // 声明该方法为一个前置通知：在目标方法开始之前执行 @Before("execution(public int com.dx.spring.beans.aop.IArithmeticCalculator.add(int, int))") public void beforeMethod() { System.out.println("before "); } }
第五步：添加测试类Client.java&测试
package com.dx.spring.beans.aop; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class Client { public static void main(String[] args) { // 1:创建Spring的IOC容器； ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-aop.xml"); // 2.从IOC容器中获取Bean的实例 IArithmeticCalculator arithmeticCalculator = (IArithmeticCalculator) ctx.getBean("arithmeticCalculator"); // 3.使用Bean int result = arithmeticCalculator.add(1, 3); System.out.println(result); } }
测试结果：
before
4
Spring AOP合并切入点表达式：
示例：
上边的LoggingAspect.java中的配置仅仅适用于接口IArithm*eticCalculator.java的add方法，如果想通过一个配置适用IArithmeticCalculator.java接口的四个方法，可以使用“*”占位符混匹方式。
第一步：修改LoggingAspect.java接口
package com.dx.spring.beans.aop; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.springframework.stereotype.Component; //把这个类声明为一个切面：需要把该类放入到IOC容器中、再声明为一个切面。 @Aspect @Component public class LoggingAspect { // 声明该方法为一个前置通知：在目标方法开始之前执行 @Before("execution(public int com.dx.spring.beans.aop.IArithmeticCalculator.*(int, int))") public void beforeMethod() { System.out.println("before "); } }
第二步：修改Client.java&测试
// 1:创建Spring的IOC容器； ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-aop.xml"); // 2.从IOC容器中获取Bean的实例 IArithmeticCalculator arithmeticCalculator = (IArithmeticCalculator) ctx.getBean("arithmeticCalculator"); // 3.使用Bean int result = arithmeticCalculator.add(1, 3); System.out.println(result); result = arithmeticCalculator.add(4, 2); System.out.println(result);
测试结果：
before
4
before
6
利用方法签名编写AspectJ切入点表达式：
最经典的切入点表达式是根据方法的签名来匹配各种方法：
- --- execution(* com.dx.spring.beans.aop.IArithmeticCalculator.*.(..))：匹配IArithmeticCalculator中声明的所有方。第一个"*"代表任意修饰符及任意返回值；第二个"*"代表任意方法；其中".."匹配任意数量的参数。若目标类与接口与该切面在同一个包中，可以省略报名。
- --- execution(public * IArithmeticCalculator.*.(..))：匹配IArithmeticCalculator接口的所有公有方法。
- --- execution(public double IArithmeticCalculator.*.(..))：匹配IArithmeticCalculator接口中返回double类型数据的方法。
- --- execution(public double IArithmeticCalculator.*.(double,..))：匹配IArithmeticCalculator接口中返回double类型数据且第一个参数参数为double类型的（".."匹配任意数量任意类型的参数）方法。
- --- execution(public double IArithmeticCalculator.*.(double,..))：匹配IArithmeticCalculator接口中返回double类型数据且有两个类型为double类型的参数的方法。
Spring AOP让通知访问当前连接点的细节：
通知方法支持接收参数，其中就允许接收JoinPoint，通过JointPoint参数对象，可以获取函数名称，和参数。
第一步：修改LoggingAspect.java类：
package com.dx.spring.beans.aop; import java.util.List; import java.util.Arrays; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.springframework.stereotype.Component; //把这个类声明为一个切面：需要把该类放入到IOC容器中、再声明为一个切面。 @Aspect @Component public class LoggingAspect { // 声明该方法为一个前置通知：在目标方法开始之前执行 @Before("execution(public int com.dx.spring.beans.aop.IArithmeticCalculator.*(int, int))") public void beforeMethod(JoinPoint joinpoint) { String methodName = joinpoint.getSignature().getName(); List<Object> args = Arrays.asList(joinpoint.getArgs()); System.out.println("before method " + methodName + " with " + args); } }
第二步：测试打印结果
before method add with [1, 3]
4
before method add with [4, 2]
6