AOP的代理其实很简单, 配一下对应的表达式, 然后一刀砍在识别后的方法头上, 在执行这个方法的时候, AOP砍到了, 就执行一下.
借用一下小付哥的图,后面自己画一个
首先是切点入口,需要提供两个方法
package com.linnine.spring.aop;
public interface Pointcut {
ClassFilter getClassFilter();
MethodMatcher getMethodMatcher();
}
然后这里的两个get方法,返回的两个对象安排一下
ClassFilterpackage com.linnine.spring.aop;
public interface ClassFilter {
boolean matches(Class> clazz);
}
MethodMatcher
package com.linnine.spring.aop;
public interface MethodMatcher {
boolean matches(Method method,Class> targetClass);
}
然后就是将这三个类整合起来
AspectJExpressionPointcut
主要是整合了两个匹配方法
package com.linnine.spring.aop.aspectj;
public class AspectJExpressionPointcut implements Pointcut, ClassFilter, MethodMatcher {
private static final Set SUPPORTED_PRIMITIVES = new HashSet<>();
static {
SUPPORTED_PRIMITIVES.add(PointcutPrimitive.EXECUTION);
}
private final PointcutExpression pointcutExpression;
public AspectJExpressionPointcut(String expression) {
PointcutParser pointcutParser = PointcutParser.getPointcutParserSupportingSpecifiedPrimitivesAndUsingSpecifiedClassLoaderForResolution(SUPPORTED_PRIMITIVES, this.getClass().getClassLoader());
this.pointcutExpression = pointcutParser.parsePointcutExpression(expression);
}
@Override
public ClassFilter getClassFilter() {
return this;
}
@Override
public MethodMatcher getMethodMatcher() {
return this;
}
@Override
public boolean matches(Class> clazz) {
return pointcutExpression.couldMatchJoinPointsInType(clazz);
}
@Override
public boolean matches(Method method, Class> targetClass) {
return pointcutExpression.matchesMethodExecution(method).alwaysMatches();
}
}
然后开始搞代理工具类
首先还是先整一个 代理支持,将代理需要用到的资源进行整合
AdvisedSupport
package com.linnine.spring.aop;
@Getter
@Setter
public class AdvisedSupport {
// 被代理的对象
private TargetSource targetSource;
// 方法拦截器
private MethodInterceptor methodInterceptor;
// 方法匹配器
private MethodMatcher methodMatcher;
}
TargetSource
被代理的对象类
package com.linnine.spring.aop;
@Getter
public class TargetSource {
private Object target;
public TargetSource(Object target) {
this.target = target;
}
public Class>[] getTargetClass() {
return target.getClass().getClasses();
}
}
MethodInterceptor
拦截器接口
package com.linnine.spring.aop;
public interface MethodInterceptor extends Callback {
Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable;
Object invoke(MethodInvocation methodInvocation) throws Throwable;
}
方法匹配类
MethodMatcherpackage com.linnine.spring.aop;
public interface MethodMatcher {
boolean matches(Method method,Class> targetClass);
}
然后就是开始实现代理
AopProxy代理接口
package com.linnine.spring.aop.framework;
public interface AopProxy {
Object getProxy();
}
两种实现方式
JdkDynamicAopProxypackage com.linnine.spring.aop.framework;
通过jdk实现代理
public class JdkDynamicAopProxy implements AopProxy, InvocationHandler {
private final AdvisedSupport advised;
public JdkDynamicAopProxy(AdvisedSupport advised) {
this.advised = advised;
}
@Override
public Object getProxy() {
return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), advised.getTargetSource().getTargetClass(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (advised.getMethodMatcher().matches(method,advised.getTargetSource().getTarget().getClass())){
MethodInterceptor methodInterceptor = advised.getMethodInterceptor();
return methodInterceptor.invoke(new ReflectiveMethodInvocation(advised.getTargetSource().getTarget(), method, args));
}
return method.invoke(advised.getTargetSource().getTarget(),args);
}
}
Cglib2AopProxy
通过cglib实现代理
package com.linnine.spring.aop.framework;
public class Cglib2AopProxy implements AopProxy {
private final AdvisedSupport advised;
public Cglib2AopProxy(AdvisedSupport advised) {
this.advised = advised;
}
@Override
public Object getProxy() {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(advised.getTargetSource().getTarget().getClass());
enhancer.setInterfaces(advised.getTargetSource().getTargetClass());
enhancer.setCallback(new DynamicAdvisedInterceptor(advised));
return enhancer.create();
}
private static class DynamicAdvisedInterceptor implements MethodInterceptor {
private final AdvisedSupport advised;
public DynamicAdvisedInterceptor(AdvisedSupport advisedSupport) {
this.advised = advisedSupport;
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
CglibMethodInvocation methodInvocation = new CglibMethodInvocation(advised.getTargetSource().getTarget(), method, objects, methodProxy);
if (advised.getMethodMatcher().matches(method,advised.getTargetSource().getTarget().getClass())){
return advised.getMethodInterceptor().invoke(methodInvocation);
}
return methodInvocation.proceed();
}
@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
return methodInvocation.proceed();
}
}
private static class CglibMethodInvocation extends ReflectiveMethodInvocation {
private MethodProxy methodProxy;
public CglibMethodInvocation(Object target, Method method, Object[] args, MethodProxy methodProxy) {
super(target, method, args);
this.methodProxy=methodProxy;
}
@Override
public Object proceed() throws Throwable {
return this.methodProxy.invoke(getTarget(), getArgs());
}
}
}
需要的一个类
ReflectiveMethodInvocationpackage com.linnine.spring.aop.framework;
import lombok.Data;
import org.aopalliance.intercept.MethodInvocation;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Method;
@Data
public class ReflectiveMethodInvocation implements MethodInvocation {
private Object target;
private Method method;
private Object[] args;
public ReflectiveMethodInvocation(Object target, Method method, Object[] args) {
this.target = target;
this.method = method;
this.args = args;
}
public Object proceed() throws Throwable{
return target;
}
@Override
public Object getThis() {
return null;
}
@Override
public AccessibleObject getStaticPart() {
return null;
}
@Override
public Object[] getArguments() {
return new Object[0];
}
}
然后改造一下测试类
IUserServicepackage com.linnine.spring.bean.service;
public interface IUserService {
String queryUserInfo();
String register(String userName);
}
UserService
package com.linnine.spring.bean.service;
@Getter
@Setter
public class UserService implements IUserService {
@Override
public String queryUserInfo() {
try {
Thread.sleep(new Random(1).nextInt(100));
} catch (InterruptedException e) {
e.printStackTrace();
}
return "小傅哥,100001,深圳";
}
@Override
public String register(String userName) {
try {
Thread.sleep(new Random(1).nextInt(100));
} catch (InterruptedException e) {
e.printStackTrace();
}
return "注册用户:" + userName + " success!";
}
}
自定义拦截类
UserServiceInterceptor
package com.linnine.spring.interceptor;
public class UserServiceInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
return null;
}
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
long start = System.currentTimeMillis();
try{
return invocation.proceed();
}finally {
System.out.println("监控 - Begin By AOP");
System.out.println("方法名称:" + invocation.getMethod());
System.out.println("方法耗时:" + (System.currentTimeMillis() - start) + "ms");
System.out.println("监控 - Endrn");
}
}
}
测试方法
@Test
public void test_aop() {
IUserService userService = new UserService();
AdvisedSupport advisedSupport = new AdvisedSupport();
advisedSupport.setTargetSource(new TargetSource(userService));
advisedSupport.setMethodInterceptor(new UserServiceInterceptor());
AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut("execution(* com.linnine.spring.bean.service.UserService.*(..))");
advisedSupport.setMethodMatcher(pointcut);
IUserService proxy_jdk = (IUserService) new JdkDynamicAopProxy(advisedSupport).getProxy();
System.out.println("测试结果"+proxy_jdk.queryUserInfo());
IUserService proxy_cglib = (IUserService) new Cglib2AopProxy(advisedSupport).getProxy();
System.out.println("测试结果"+proxy_cglib.register("花花"));
}
开始测试1
果然又很多毛病,一开始都直接跑不通
首先是一开始强转类都不行
看来一下源码,然后改了一下 一个主要的坑爹的地方就是拦截器接口类MethodInterceptor
在AdviceSupport是一个, 但是在Cglib中自己又实现了一个, 难怪串不到一块去
这也是为什么我的MethodInterceptor里面有两个方法,但是看源码 都是只有一个方法的奇怪之处!
这里直接干掉我们自己的MethodInterceptor
AdviceSupport 改成引入这个包
import org.aopalliance.intercept.MethodInterceptor;Cglib2AopProxy
这里的内部类DynamicAdvisedInterceptor实现的MethodInterceptor改成Cglib自己的,我真是服了这个老六啊!
import org.springframework.cglib.proxy.MethodInterceptor;JdkDynamicAopProxy
用aop提供的,也不用改什么 改成右边这样! 你改完AdviceSupport就不用管了!
TargetSource这里getTargetClass()小修正一下
public Class>[] getTargetClass() {
return target.getClass().getInterfaces();
}
其实在Cglib2AopProxy里面就有苗头了,前面就挺懵逼的getTarget().getClass()和getTargetClass()有什么区别. 原来
主要还是对java的反射了解的不深,这个getInterfaces()就是获取所有这个类实现的接口.
应该就是帮我们注册成这类接口.
比如UserService 帮我们注册IUserService这样.
UserServiceInterceptor这里改成实现aop的MethodInterceptor ,反正就只有Cglib自己用自己的MethodInterceptor,其他人就用aop的.
测试2
好像,差点意思,就是cglib的成功了,但是jdk的代理只是生成对象成功,但是aop没有切进去!
debug其实有进去执行的方法,但是判断的时候错了,是因为我测试方法中的表达式扫描的是UserService,这里转成IUserService后, 匹配不上类,所以就没切进去.
改完jdk的貌似可以,其实不行, 在输出的时候报错了!
难搞哦,先留个坑,后面再来填
跳出来冷静了一下就想通了.
debug的时候走到UserServiceInterceptor重写的invoke方法.
里面的流程主要是 自己做一下操作, 但还是要调用invocation.proceed();
就是为了执行一下原本的方法.
而jdk代理的时候用的是ReflectiveMethodInvocation里面的proceed()方法,而之前草率的做了一个,里面的proceed方法其实没有实现,而是草率的返回了target,导致会报这个错!
所以改动一下就好了
结果如下



