动态代理
我们在日常开发过程中是否会遇到下图中的这种状况
红框中的是我们要输出的日志，你是否发现，日志中大部分信息都是相同的，并且如果我们要修改一个地方，所有的地方都需要改，而且代码看起来还比较冗余
下面我们就可以通过动态代理的方式解决这个问题
看下代码
public interface Calculation {
public int add(int x, int y);
public int sub(int x, int y);
public int mul(int x, int y);
public int dev(int x, int y);
}定义接口，加减乘除方法。
public class CalculationImpl implements Calculation {
@Override
public int add(int x, int y) {
int result = x + y;
return result;
}
@Override
public int sub(int x, int y) {
int result = x - y;
return result;
}
@Override
public int mul(int x, int y) {
int result = x * y;
return result;
}
@Override
public int dev(int x, int y) {
int result = x / y;
return result;
}
}
具体实现类，这里我们看到，没有植入日志。
public class CalculationProxy {
private Calculation calculation = null;
CalculationProxy(Calculation calculation) {
this.calculation = calculation;
}
public Calculation getCalculationLog() {
Calculation proxy = null;
ClassLoader loader = calculation.getClass().getClassLoader();
Class[] interfaces = new Class[] { Calculation.class };
InvocationHandler h = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out
.println("GP-->invoke begin , execute method is "
+ method.getName() + ", args is "
+ Arrays.asList(args));
Object obj = method.invoke(calculation, args);
return obj;
}
};
proxy = (Calculation) Proxy.newProxyInstance(loader, interfaces, h);
return proxy;
}
}动态代理类的实现，在实现invoke方法的时候，我们输出日志在调用目标方法之前。
测试
public class Main {
public static void main(String[] args) {
Calculation calculation = new CalculationImpl();
CalculationProxy calculationProxy = new CalculationProxy(calculation);
Calculation cal = calculationProxy.getCalculationLog();
System.out.println(cal.add(1, 3));
System.out.println(cal.mul(1, 5));
}
}
输出结果
GP–>invoke begin , execute method is add, args is [1, 3]
4
GP–>invoke begin , execute method is mul, args is [1, 5]
5
看起来是不是要清晰多了，我们将日志单独提取到动态代理的方法中，对核心的业务方法没有侵入，而且还便于我们的维护。
AOP简介
AOP(Aspect-Oriented Programming, 面向切面编程): 是一种新的方法论, 是对传统 OOP(Object-Oriented Programming, 面向对象编程) 的补充.
AOP 的主要编程对象是切面(aspect), 而切面模块化横切关注点.
在应用 AOP 编程时, 仍然需要定义公共功能, 但可以明确的定义这个功能在哪里, 以什么方式应用, 并且不必修改受影响的类. 这样一来横切关注点就被模块化到特殊的对象(切面)里.
AOP 的好处:
- 每个事物逻辑位于一个位置, 代码不分散, 便于维护和升级
- 业务模块更简洁, 只包含核心业务代码.
AOP术语
切面(Aspect): 横切关注点(跨越应用程序多个模块的功能)被模块化的特殊对象
通知(Advice): 切面必须要完成的工作
目标(Target): 被通知的对象
代理(Proxy): 向目标对象应用通知之后创建的对象
连接点（Joinpoint）：程序执行的某个特定位置：如类某个方法调用前、调用后、方法抛出异常后等。连接点由两个信息确定：方法表示的程序执行点；相对点表示的方位。例如 ArithmethicCalculator#add() 方法执行前的连接点，执行点为 ArithmethicCalculator#add()； 方位为该方法执行前的位置
切点（pointcut）：每个类都拥有多个连接点：例如 ArithmethicCalculator 的所有方法实际上都是连接点，即连接点是程序类中客观存在的事务。AOP 通过切点定位到特定的连接点。类比：连接点相当于数据库中的记录，切点相当于查询条件。切点和连接点不是一对一的关系，一个切点匹配多个连接点，切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。
基于Aspect的AOP – 前置通知
更多内容，参考：http://jinnianshilongnian.iteye.com/blog/1420689
涉及JAR包
com.springsource.net.sf.cglib-2.2.0.jar
com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
commons-logging-1.1.1.jar
spring-aop-4.1.7.RELEASE.jar
spring-aspects-4.1.7.RELEASE.jar
spring-beans-4.1.7.RELEASE.jar
spring-context-4.1.7.RELEASE.jar
spring-core-4.1.7.RELEASE.jar
spring-expression-4.1.7.RELEASE.jar
看下代码
public interface Calculation {
public int add(int x, int y);
public int sub(int x, int y);
public int mul(int x, int y);
public int dev(int x, int y);
}@Component
public class CalculationImpl implements Calculation {
@Override
public int add(int x, int y) {
int result = x + y;
return result;
}
@Override
public int sub(int x, int y) {
int result = x - y;
return result;
}
@Override
public int mul(int x, int y) {
int result = x * y;
return result;
}
@Override
public int dev(int x, int y) {
int result = x / y;
return result;
}
}实现接口，并且使用@Component标记为IOC容器中的组件。
<context:component-scan base-package="com.gp.spring.aop.impl"></context:component-scan>
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>加入扫描注解的包路径。
Spring默认不支持@AspectJ风格的切面声明，增加aspectj-autoproxy，这样Spring就能发现@AspectJ风格的切面并且将切面应用到目标对象。
@Aspect
@Component
public class CalculationAspect {
@Before("execution(public int com.gp.spring.aop.impl.Calculation.add(int, int))")
public void beforeMethod(JoinPoint joinPoint) {
String name = joinPoint.getSignature().getName();
List<Object> list = Arrays.asList(joinPoint.getArgs());
System.out.println("Method begin ... ,method=" + name + ", args = "
+ list);
}
}- CalculationAspect 标记为Component组件，注册到IOC容器中
- @Aspect标记，spring对其进行AOP相关的配置，生成相应的代理类
- @Before，为前置通知，方法执行前的通知
- “execution(public int com.gp.spring.aop.impl.Calculation.add(int,
int))”表达式，表示此通知要执行的包路径、方法的相关信息。此表达式可进行模糊匹配，比如”execution(public int
com.gp.spring.aop.impl.Calculation.*(*))”，表示Calculation类下的所有方法。
- 方法中的参数JoinPoint joinPoint，表示连接点，通过此参数可以获取到执行方法的相关信息，比如方法名、方法参数。
执行测试方法
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Calculation calculation = (Calculation)context.getBean("calculationImpl");
int result = calculation.add(3, 4);
System.out.println(result);
}输出结果
Method begin … ,method=add, args = [3, 4]
7
基于Aspect的AOP – 后置通知
后置通知与前置通知用法类似，区别就是在执行方法之后执行后置通知方法。
代码如下
@After("execution(public int com.gp.spring.aop.impl.Calculation.add(int, int))")
public void afterMethod(JoinPoint joinPoint) {
String name = joinPoint.getSignature().getName();
List<Object> list = Arrays.asList(joinPoint.getArgs());
System.out.println("Method end ... ,method=" + name + ", args = "
+ list);
}这里用的@After注解，其他都没变化。
测试输出结果如下
Method begin … ,method=add, args = [3, 4]
executeing …
Method end … ,method=add, args = [3, 4]
7
我在对add方法增加了一个输出，便于区分前置通知、后置通知
public int add(int x, int y) {
int result = x + y;
System.out.println("executeing ...");
return result;
}基于Aspect的AOP – 返回通知
方法执行成功后，调用返回通知，如果方法在运行过程中抛出异常，则不会调用。
代码
@AfterReturning(value = "execution(public int com.gp.spring.aop.impl.Calculation.add(int, int))", returning = "ret")
public void afterReturnMethod(JoinPoint joinPoint, Object ret) {
String name = joinPoint.getSignature().getName();
List<Object> list = Arrays.asList(joinPoint.getArgs());
System.out.println("@AfterReturning ... ,method=" + name + ", args = "
+ list + ", return = " + ret);
}与后置通知不同的是，后置通知在方法抛出异常，仍会被调用，这里我们可以使用try … catch … 进行类比。
输出结果
@Before … ,method=add, args = [3, 4]
executeing …
@After … ,method=add, args = [3, 4]
@AfterReturning … ,method=add, args = [1, 3], return = 4
7
基于Aspect的AOP – 异常通知
方法在运行过程中，如果抛出异常，则调用异常通知
代码
@AfterThrowing(value = "execution(public int com.gp.spring.aop.impl.Calculation.*(int, int))", throwing = "ex")
public void afterThrowMethod(JoinPoint joinPoint, Exception ex) {
System.out.println("@AfterThrowing ... ,ex = " + ex);
}此处与之前的用法有些却别，在注解的参数中增加了throwing，然后在方法中增加了要捕获的异常，此处类似于try…catch…的catch中代码块
输出结果
Exception in thread “main” @AfterThrowing … ,ex = java.lang.ArithmeticException: / by zero
java.lang.ArithmeticException: / by zero
at com.gp.spring.aop.impl.CalculationImpl.dev(CalculationImpl.java:29)
基于Aspect的AOP – 环绕通知
环绕通知，类似与我们最开始讲解的动态代理，在此通知中你可以去调用目标方法，并在目标方法的上下做各种通知（前置、返回、后置、异常等处理）
代码：
@Around("execution(public int com.gp.spring.aop.impl.Calculation.add(int, int))")
public Object aroundMethod(ProceedingJoinPoint pjd) {
String name = pjd.getSignature().getName();
List<Object> list = Arrays.asList(pjd.getArgs());
Object obj = null;
System.out.println("前置通知 ... ,method=" + name + ", args = "
+ list);
try {
obj = pjd.proceed();
System.out.println("返回通知 ... ,method=" + name + ", args = "
+ list);
} catch (Throwable e) {
System.out.println("异常通知 ... , exception = " + e);
e.printStackTrace();
}
System.out.println("后置通知 ... ,method=" + name + ", args = "
+ list);
return obj;
} 返回结果：
前置通知 … ,method=add, args = [1, 3]
executeing …
返回通知 … ,method=add, args = [1, 3]
后置通知 … ,method=add, args = [1, 3]
4
版权声明：本文为博主原创文章，未经博主允许不得转载。