编程式实现Spring AOP

时间:2022-11-20 22:00:31

在我们使用Spring的过程中,经常会接触到AOP这个概念,但是在实际的项目使用过程中,大部分都是通过配置的方式来实现方法的增强,今天我们通过这篇文章来告诉大家,在Spring中如何通过编程的方式来实现方法的前置增强,后置增强和环绕增强。

1、前置增强(Before Advice)

所谓前置增强,就是在执行对应方法逻辑前,需要预先处理额外增加的逻辑,在某些特殊的情况下,如果我们仅仅只需要在执行方法逻辑前增加一些额外的逻辑,同时这些逻辑在同一个Bean的方法执行前都需要执行,例如在调用方法前,需要记录一下日志,如果在Bean的所有方法体中都加入一段记录日志的代码,这不但使得代码量增加,同时会造成代码难以维护。那假如我们使用前置增强,就可以单独写一个前置增强类,然后通过代理工厂将增强类添加进去,在调用方法时就可以自动执行前置增强逻辑,然后才执行方法体逻辑。

我们写一个接口,定义一个sayHello的方法

public interface Greeting {
void sayHello(String name);
}

再写一个实现类,让他实现以上接口

public class GreetingImpl implements Greeting {

@Override
public void sayHello(String name) {
System.out.println("Hello:"+name);
}
}
现在我们有一个需求,需要在执行sayHello方法的逻辑前,打印出一段文字,我们可以直接在方法体中打印,也可以是按照上一篇文章我们所说的静态代理、JDK动态代理、CGLib动态代理的方式实现,今天我们介绍的第三种通过Spring的面向切面的方式来实现。

首先我们定义一个前置增强类GreetingBeforeAdvice,让他实现Spring AOP的MethodBeforeAdvice接口。

public class GreetingBeforeAdvice implements MethodBeforeAdvice {

@Override
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println("Before");
}
}
在重写的before方法中,我们实现我们对应的前置逻辑。

public static void main(String[] args) {
//创建代理工厂
ProxyFactory proxyFactory = new ProxyFactory();

//设置目标类对象
proxyFactory.setTarget(new GreetingImpl());

//添加增强
proxyFactory.addAdvice(new GreetingBeforeAdvice());

//获取代理
Greeting greeting = (Greeting) proxyFactory.getProxy();
greeting.sayHello("Ron.Zheng");
}
在使用增强信息时,首先我们需要创建一个代理工厂,然后在代理工厂中设置需要增强的目标对象,添加对应的增强。执行以上代码,我们会得到如下结果。
Before
Hello:Ron.Zheng

2、后置增强(After Advice)

所谓后置增强,就是在执行对应方法逻辑后,需要处理额外增加的逻辑,在某些特殊的情况下,如果我们仅仅只需要在执行方法逻辑后增加一些额外的逻辑,同时这些逻辑在同一个Bean的方法执行前都需要执行,例如我们同样需要在方法执行完毕之后记录一下日志,我们就可以采用后置增强。

我们写一个后置增强类GreetingAfterAdvice,让他实现AfterReturningAdvice。

public class GreetingAfterAdvice implements AfterReturningAdvice {

@Override
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println("After");
}
}

然后我们在我们的调用方法中,我们往代理工厂加入对应的通知就可以了。

public static void main(String[] args) {
//创建代理工厂
ProxyFactory proxyFactory = new ProxyFactory();

//设置目标类对象
proxyFactory.setTarget(new GreetingImpl());

//添加增强
proxyFactory.addAdvice(new GreetingAfterAdvice());

//获取代理
Greeting greeting = (Greeting) proxyFactory.getProxy();
greeting.sayHello("Ron.Zheng");
}
执行结果

Hello:Ron.Zheng
After

3、环绕增强(Around Advice)

所谓环绕增强,就是在执行方法逻辑前后,都需要增加额外逻辑的增强,一般情况下,环绕增强会使用得多一些。

环绕增强需要实现org.aopalliance.intercept.MethodInterceptor接口,望文生义,环绕增强,可以当成一个方法拦截器来理解。

我们定义一个GreetingAroundAdvice类,然后实现MethodInterceptor接口。

public class GreetingAroundAdvice implements MethodInterceptor {

@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
before();

Object result = invocation.proceed();

after();
return result;
}

private void after() {
System.out.println("调用方法之后");
}

private void before() {
System.out.println("调用方法之前");
}
}

在我们的应用中,将增强类的对象添加到代理工厂中

public static void main(String[] args) {
//创建代理工厂
ProxyFactory proxyFactory = new ProxyFactory();

//设置目标类对象
proxyFactory.setTarget(new GreetingImpl());

//添加增强
proxyFactory.addAdvice(new GreetingAroundAdvice());

//获取代理
Greeting greeting = (Greeting) proxyFactory.getProxy();
greeting.sayHello("Ron.Zheng");
}
执行程序就能看到如下结果。

调用方法之前
Hello:Ron.Zheng
调用方法之后