CGLIB实现AOP代理的测试类，与Spring分离，加深对面向切面编程的理解

Love The Way You Lie 2022-06-06 10:43 77阅读 0赞

Sping整合了Cglib框架以实现AOP，我们用的时候基本都是借助Spring来实现的。但是每次使用的时候都要借助框架，很麻烦，而且AOP的很多东西和Spring耦合在一起，不利于清晰的了解Cglib实现动态代理的流程。所以我写了几个类，分离了Cglib与Spring的关系，可以很简单的实现AOP代理，也能很方便的看到动态代理生成的对象是什么，有什么特殊性，以及测试不同的切面注解如@After,@Before等，他们的使用方法和注意事项；以及切入点表达式比如args(),@args，within(),@within()等等的区别及使用方法和注意事项。  
.  
可以验证一些信息：代理对象和原始对象的关系；代理对象的类名是什么样的形式；是否包含$$；代理对象是否持有被代理对象作为其成员；如果多个切面织入同一个被代理对象，那么注解类型相同，比如两个@After，如何排序；当一个切面织入后生成代理对象，比如@After，那么执行原对象的任意方法是否均会执行@After标识的切面方法。  
.  
下面看这个测试框架的类结构图:  
![这里写图片描述][SouthEast]  
.

1.  AspectjAdviceTye：自定义枚举，里面包含了@Before，@After等这些切面注解相应的解析功能
2.  AspectPointcutConfig：切面定义类，里面使用@Before，@After这些注解定义了一些切面
3.  CglibProxyContextConfig：Cglib动态代理上下文配置，测试类继承此类
4.  CglibProxyTest：继承自CglibProxyContextConfig：Cglib，指定要被代理的对象及切面定义
5.  ProxiedModel：被代理对象类  
    .  
    下面开始看实际代码:  
    .

AspectjAdviceTye 枚举，针对每一类切面注解有相应的解析功能

/** * @since 2017年8月3日 上午9:05:15 * */
     enum AspectjAdviceTye {
    
        BEFORE(Before.class, "Before") {
    
            @Override
            public AbstractAspectJAdvice buildAdvice(Method adviceMethod, Object original) throws Exception {
                Before ann = findAdviceAnnotation(Before.class, adviceMethod);
                if (ann == null) {
                    return null;
                }
                AspectJExpressionPointcut expressionPointcut = generateExpressionPointcut(ann);
                checkPointcutMatching(original.getClass(), expressionPointcut);
                return new AspectJMethodBeforeAdvice(adviceMethod, expressionPointcut, new SimpleAspectInstanceFactory(adviceMethod.getDeclaringClass()));
            }
    
        },
    
        AROUND(Around.class, "Around") {
    
            @Override
            public AbstractAspectJAdvice buildAdvice(Method adviceMethod, Object original) throws Exception {
                Around ann = findAdviceAnnotation(Around.class, adviceMethod);
                if (ann == null) {
                    return null;
                }
                AspectJExpressionPointcut expressionPointcut = generateExpressionPointcut(ann);
                checkPointcutMatching(original.getClass(), expressionPointcut);
                return new AspectJAroundAdvice(adviceMethod, generateExpressionPointcut(ann), new SimpleAspectInstanceFactory(adviceMethod.getDeclaringClass()));
            }
        },
    
        AFTER(After.class, "After") {
    
            @Override
            public AbstractAspectJAdvice buildAdvice(Method adviceMethod, Object original) throws Exception {
                After ann = findAdviceAnnotation(After.class, adviceMethod);
                if (ann == null) {
                    return null;
                }
                AspectJExpressionPointcut expressionPointcut = generateExpressionPointcut(ann);
                checkPointcutMatching(original.getClass(), expressionPointcut);
                return new AspectJAfterAdvice(adviceMethod, expressionPointcut, new SimpleAspectInstanceFactory(adviceMethod.getDeclaringClass()));
            }
        },
    
        AFTERRETURNING(AfterReturning.class, "AfterReturning") {
    
            @Override
            public AbstractAspectJAdvice buildAdvice(Method adviceMethod, Object original) throws Exception {
                AfterReturning ann = findAdviceAnnotation(AfterReturning.class, adviceMethod);
                if (ann == null) {
                    return null;
                }
                AspectJExpressionPointcut expressionPointcut = generateExpressionPointcut(ann);
                checkPointcutMatching(original.getClass(), expressionPointcut);
                AspectJAfterReturningAdvice advice = new AspectJAfterReturningAdvice(adviceMethod, expressionPointcut,
                        new SimpleAspectInstanceFactory(adviceMethod.getDeclaringClass()));
                if (StringUtils.hasText(ann.returning())) {
                    advice.setReturningName(ann.returning());
                }
                return advice;
            }
        },
    
        AFTERTHROWING(AfterThrowing.class, "AfterThrowing") {
    
            @Override
            public AbstractAspectJAdvice buildAdvice(Method adviceMethod, Object original) throws Exception {
                AfterThrowing ann = findAdviceAnnotation(AfterThrowing.class, adviceMethod);
                if (ann == null) {
                    return null;
                }
                AspectJExpressionPointcut expressionPointcut = generateExpressionPointcut(ann);
                checkPointcutMatching(original.getClass(), expressionPointcut);
                AspectJAfterThrowingAdvice advice = new AspectJAfterThrowingAdvice(adviceMethod, expressionPointcut,
                        new SimpleAspectInstanceFactory(adviceMethod.getDeclaringClass()));
                if (StringUtils.hasText(ann.throwing())) {
                    advice.setThrowingName(ann.throwing());
                }
                return advice;
            }
        };
    
        private final Class<? extends Annotation> adviceClass;
        private final String label;
    
        private static final Map<Class<? extends Annotation>, AspectjAdviceTye> VALUES = new LinkedHashMap<Class<? extends Annotation>, AspectjAdviceTye>();
    
        static {
            for (AspectjAdviceTye ann : AspectjAdviceTye.values()) {
                VALUES.put(ann.adviceClass, ann);
            }
        }
    
        /** * @param adviceMethod * @return */
        public static AspectjAdviceTye valueOf(Method adviceMethod) {
            for (Entry<Class<? extends Annotation>, AspectjAdviceTye> entry : VALUES.entrySet()) {
                Annotation adviceAnn = findAdviceAnnotation(entry.getKey(), adviceMethod);
                if (adviceAnn != null) {
                    return entry.getValue();
                }
            }
            throw new IllegalArgumentException("指定的方法[" + adviceMethod + "]上不含有切面注解");
        }
    
        /** * @param annClass * @param method * @return */
        private static <A extends Annotation> A findAdviceAnnotation(Class<A> annClass, Method method) {
            return method.getDeclaredAnnotation(annClass);
        }
    
        /** * 根据{@code @Before}等注解生成切入点 * * @param aspectAnn * @return * @throws Exception */
        private static AspectJExpressionPointcut generateExpressionPointcut(Annotation aspectAnn) throws Exception {
            AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut(AspectPointcutConfig.class, new String[0], new Class<?>[0]);
            pointcut.setExpression(AnnotationUtils.getValue(aspectAnn).toString());
            return pointcut;
        }
    
        /** * 校验被代理类是否契合切入点 * * @param pointcut */
        private static void checkPointcutMatching(Class<?> proxyClass, AspectJExpressionPointcut pointcut) {
            Assert.state(pointcut.matches(proxyClass), "Pointcut的Expression必须契合被代理类[" + proxyClass.getName() + "]");
            List<Method> matchedMethod = new ArrayList<Method>();
            ReflectionUtils.doWithMethods(proxyClass, (method) -> {
                if (pointcut.matches(method, proxyClass)) {
                    matchedMethod.add(method);
                }
            });
            Assert.state(!matchedMethod.isEmpty(), "被代理类[" + proxyClass.getName() + "]没有方法契合ExpressionPointcut");
        }
    
        /** * 创建代理切面通知 * * @param adviceMethod * @return * @throws Exception */
        public abstract AbstractAspectJAdvice buildAdvice(Method adviceMethod, Object original) throws Exception;
    
        /** * @param annClass * @param label */
        private AspectjAdviceTye(Class<? extends Annotation> annClass, String label) {
            this.adviceClass = annClass;
            this.label = label;
        }
    
        /** * @return the adviceClass */
        public Class<? extends Annotation> getAdviceClass() {
            return adviceClass;
        }
    
        /** * @return the label */
        public String getLabel() {
            return label;
        }
    
    }

.  
AspectPointcutConfig：切面定义类，使用@After这些注解定义了一些切面，含有切入点及通知

/** * AOP切面方法定义 * * @since 2017年8月2日 上午9:23:05 * */
    public class AspectPointcutConfig { 
    
        /** * 匹配参数含有{@code BankUserGenerator}类型的方法 * * @param joinpoint */
        @Before("args(com.bob.mvc.model.BankUserGenerator)")
        public void argsOnBefore(JoinPoint joinpoint) {
            Object[] args = joinpoint.getArgs();
            for (int i = 0; i < args.length; i++) {
                if (args[i] instanceof User) {
                    User user = (User) args[i];
                    user.setUserName("PROXY_SET_NAME");
                }
            }
        }
    
        /** * @param joinpoint */
        @After("execution(public * com.bob.test.concrete.cglibproxy.ProxiedModel.*(..))")
        public void exeOnAfter(JoinPoint joinpoint) {
            System.out.println("在代理方法执行之后执行onAfter()方法");
        }
    
        /** * @param joinpoint */
        @Before("@args(com.bob.config.mvc.userenv.ann.UserEnv)")
        public void atArgsOnBefore(JoinPoint joinpoint) {
            System.out.println("在代理方法执行之后执行onAfter()方法");
        }
    
        /** * 匹配标识了指定注解{@code UserEnv} 的方法 * * @param pjp * @throws Throwable */
        @Around("@annotation(com.bob.config.mvc.userenv.ann.UserEnv)")
        public void atAnnOnAround(ProceedingJoinPoint pjp) throws Throwable {
            System.out.println("执行Around的前半部分");
            Object result = pjp.proceed();
            System.out.println("执行Around的后半部分,结果为[" + result + "]");
        }
    
        /** * 被代理类标识了{@code UserEnv}的类及其子类 * * @param joinpoint * @param result */
        @AfterReturning(value = "@within(org.springframework.context.annotation.Primary)", returning = "result")
        public void atWithinOnAfterReturnning(JoinPoint joinpoint, Object result) {
            System.out.println("atWithinOnAfterReturnning() == " + result);
        }
    
        /** * 被代理类是this指定的类(接口)或者子类,实现类 * * @param joinpoint * @param ex */
        @AfterThrowing(value = "this(com.bob.test.concrete.cglibproxy.ProxiedModel)", throwing = "ex")
        public void thisOnAfterThrowing(JoinPoint joinpoint, IllegalStateException ex) {
            System.out.println(ex.getMessage());
        }
    
    }

.  
CglibProxyContextConfig：Cglib代理测试配置类，配置上下文信息，测试类继承此类，重写init方法，指定被代理对象（泛型约束）及切面方法

/** * CGLIB代理测试配置 * * @since 2017年8月2日 下午4:14:59 * */
    public abstract class CglibProxyContextConfig<T> { 
    
        protected T originalBean; // 被代理对象
        protected Class<?> adviceDeclaredScope; // 定义Advice通知的类
        private ProxyFactory proxyFactory;
    
        @Before
        public void before() {
            init();
            configProxyFactory();
            Assert.notNull(originalBean, "必须指定被代理的对象");
            Assert.notNull(adviceDeclaredScope, "必须指定定义切面通知的Class");
        }
    
        private void configProxyFactory() {
            proxyFactory = new ProxyFactory();
            proxyFactory.setProxyTargetClass(true);
            proxyFactory.setOptimize(false);
            proxyFactory.setExposeProxy(false);
            proxyFactory.setFrozen(false);
            proxyFactory.setOpaque(false);
        }
    
        /** * 创建代理对象 * * @throws Exception */
        @SuppressWarnings("unchecked")
        protected final T createProxy(Method adviceMethod) throws Exception {
            proxyFactory.addAdvice(buildAdvice(adviceMethod));
            proxyFactory.addAdvisor(0, ExposeInvocationInterceptor.ADVISOR);
            proxyFactory.setTargetSource(new SingletonTargetSource(originalBean));
            return (T) proxyFactory.getProxy(originalBean.getClass().getClassLoader());
        }
    
        /** * 根据指定方法上的注解信息生成切面通知对象 * * @param adviceMethod * @return * @throws Exception */
        private AbstractAspectJAdvice buildAdvice(Method adviceMethod) throws Exception {
            return AspectjAdviceTye.valueOf(adviceMethod).buildAdvice(adviceMethod, originalBean);
        }
    
        /** * 查找指定切面类上的通知方法 * * @param name * @param paramTypes * @return */
        protected final Method findAspectMethod(String name, Class<?>... paramTypes) {
            return ReflectionUtils.findMethod(adviceDeclaredScope, name, paramTypes);
        }
    
        /** * 初始化被代理对象即指定切面通知所在的Class */
        protected abstract void init();
    
    }

.  
CglibProxyTest：测试类，继承CglibProxyContextConfig，指明被代理对象及切面方法，生成代理对象

/** * CGLIB动态代理测试 * * @since 2017年8月1日 下午8:27:21 * */
    public class CglibProxyTest extends CglibProxyContextConfig<ProxiedModel> { 
    
        private ProxiedModel proxyBean; // CGLIB代理生成的对象
        private Method adviceMethod; // Advice切面方法
    
        /* (non-Javadoc) * @see com.bob.test.concrete.cglibproxy.CglibProxyBaseConfig#init() */
        @Override
        protected void init() {
            super.originalBean = new ProxiedModel();
            super.adviceDeclaredScope = AspectPointcutConfig.class;
        }
    
        @Test
        public void testOnBefore() throws Exception {
            adviceMethod = findAspectMethod("argsOnBefore", JoinPoint.class);
            proxyBean = createProxy(adviceMethod);
            proxyBean.setMsgWithUser(new User());
            System.out.println(proxyBean.getMsg());
        }
    
        @Test
        public void testOnAfter() throws Exception {
            adviceMethod = findAspectMethod("exeOnAfter", JoinPoint.class);
            proxyBean = createProxy(adviceMethod);
            proxyBean.setMsg("lanboal");
        }
    
        @Test
        public void testOnAround() throws Exception {
            adviceMethod = findAspectMethod("atAnnOnAround", ProceedingJoinPoint.class);
            proxyBean = createProxy(adviceMethod);
            System.out.println(proxyBean.getClass().getName());
            proxyBean.invokeForAround(new User());
        }
    
        @Test
        public void testAfterReturning() throws Exception {
            adviceMethod = findAspectMethod("atWithinOnAfterReturnning", JoinPoint.class, Object.class);
            proxyBean = createProxy(adviceMethod);
            // proxyBean.invokeForAtWithin(new RequestScopeExample());
            // proxyBean.setMsg("sss");
            proxyBean.getUser();
        }
    
        @Test
        public void testAfterThrowing() throws Exception {
            adviceMethod = findAspectMethod("thisOnAfterThrowing", JoinPoint.class, IllegalStateException.class);
            proxyBean = createProxy(adviceMethod);
            proxyBean.invokeThrowing();
            /*try { proxyBean.invokeForThis(); } catch (Exception e) { }*/
        }
    
        @Test
        public void testEnum(){
            AspectjAdviceTye type =AspectjAdviceTye.BEFORE;
            System.out.println(type.name());
            System.out.println(type instanceof  Enum);
            System.out.println(type.getClass());
            System.out.println(type.getDeclaringClass());
            System.out.println(type.getClass().getSuperclass());
            System.out.println(type.ordinal());
        }
    
    }

.  
ProxiedModel：被代理对象类

/** * @since 2017年8月1日 下午8:28:49 * */
    @Primary
    public class ProxiedModel { 
    
        private String msg;
    
        /** * @return the msg */
        public String getMsg() {
            return msg;
        }
    
        /** * @param msg * the msg to set */
        public void setMsg(String msg) {
            this.msg = msg;
        }
    
        public void setMsgWithUser(User user) {
            this.msg = user.getUserName();
        }
    
        public User getUser() {
            return new User();
        }
    
        @UserEnv
        public String invokeForAround(User user) {
            System.out.println("执行Around方法");
            return user.getUserName();
        }
    
        public String invokeForAtWithin(RequestScopeExample example) {
            return "invokeForAtWithin";
        }
    
        public void invokeForThis() {
            throw new IllegalStateException("invokeForThis抛出异常");
        }
    
        public void invokeThrowing() {
            throw new IllegalArgumentException("invokeForThis抛出异常");
        }
    
    }

.  
以上就是测试框架的几个类，可以自己定义自己的切面及被代理对象，通过执行测试方法，查看生成的代理对象及日志输出，加深对Cglib的理解。

[SouthEast]: /images/20220606/37b364187163485bb5b064df86b6a021.png