栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

手撸spring12: 基于JDK、Cglib 实现AOP切面 动态代理生成对象

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

手撸spring12: 基于JDK、Cglib 实现AOP切面 动态代理生成对象

AOP的代理其实很简单, 配一下对应的表达式, 然后一刀砍在识别后的方法头上, 在执行这个方法的时候, AOP砍到了, 就执行一下.

借用一下小付哥的图,后面自己画一个

Pointcut

首先是切点入口,需要提供两个方法

package com.linnine.spring.aop;

public interface Pointcut {

    ClassFilter getClassFilter();

    MethodMatcher getMethodMatcher();
}

然后这里的两个get方法,返回的两个对象安排一下

ClassFilter

package 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;
}

方法匹配类

MethodMatcher

package 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();
}

两种实现方式

JdkDynamicAopProxy

package 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());
        }

    }
}

需要的一个类

ReflectiveMethodInvocation

package 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];
}

}


然后改造一下测试类

IUserService

package 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,导致会报这个错!

所以改动一下就好了



结果如下

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/951257.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号