jdk的动态代理和cglib的动态代理区别

两者的区别

• jdk动态代理是只能对实现了接口的类生成代理，不能针对类。
• cglib动态代理是针对类实现代理，也就是实现该类的一个子类，来重写该方法。
• spring中根据类的具体情况来自由切换。

如何强制使用CGLIB实现AOP？
 （1）添加CGLIB库，SPRING_HOME/cglib/*.jar
 （2）在spring配置文件中加入<aop:aspectj-autoproxy proxy-target-class="true"/>

jdk和cglib一个是需要接口，一个不需要接口。jdk为什么需要接口？

https://blog.youkuaiyun.com/zxysshgood/article/details/78684229

主要是在Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

这个方法中，该方法实现如下：

@CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * Look up or generate the designated proxy class.
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }

            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

 

动态代理常见的实现场景：

• AOP

1.JDK动态代理

• 接口

public interface JDKObjcetInerface {
    void request(String str);
}

• 实现类

public class JDKObject implements JDKObjcetInerface{
    @Override
    public void request(String str) {
        System.out.println("this is target request()");
    }
}

• 动态代理

public class JDKObjectInvocationHandler implements InvocationHandler {
    private Object target;

    public JDKObjectInvocationHandler(Object target){
        this.target = target;
    }


    public <T>T getProxy(){
        return (T)Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //传递过来的method = Class.forName("JDKObject").getMethod("request", new Class[] { Class.forName("java.lang.String") })
        //根据反射机制，method.invoke(target,args);调用的就是request方法。
        return method.invoke(target,args);
    }
}

• 测试类

    public static void main(String[] args){
        //动态代理，不会说去重新实现一个接口来代理，完全不需要。
        //还有需要生成代理类对象（proxy），通过反射的方式来实现。
        //通过proxy调用方法request，实际你会发现，调用的还是目标类的request方法。
        //反编译发现
        // public void request(String str){
        // return (String)this.h.invoke(this, m4, new Object[] { str });
        // }
        //发现调用的过程中还是调用了JDKObjectInvocationHandler的invoke()
        // m4 = Class.forName("JDKObject").getMethod("request", new Class[] { Class.forName("java.lang.String") })
        JDKObjcetInerface jdkObjcetInerface = new JDKObject();
        JDKObjectInvocationHandler handler = new JDKObjectInvocationHandler(jdkObjcetInerface);

        JDKObjcetInerface proxy = handler.getProxy();
        proxy.request("");

    }

2.CGLIB的动态代理

（需要导入两个jar包，asm-5.2.jar,cglib-3.2.5.jar）

//Cglib动态代理，实现MethodInterceptor接口
public class CglibProxy implements MethodInterceptor {
    private Object target;//需要代理的目标对象
    
    //重写拦截方法
    @Override
    public Object intercept(Object obj, Method method, Object[] arr, MethodProxy proxy) throws Throwable {
        System.out.println("Cglib动态代理，监听开始！");
        Object invoke = method.invoke(target, arr);//方法执行，参数：target 目标对象 arr参数数组
        System.out.println("Cglib动态代理，监听结束！");
        return invoke;
    }
    //定义获取代理对象方法
    public Object getCglibProxy(Object objectTarget){
        //为目标对象target赋值
        this.target = objectTarget;
        Enhancer enhancer = new Enhancer();
        //设置父类,因为Cglib是针对指定的类生成一个子类，所以需要指定父类
        enhancer.setSuperclass(objectTarget.getClass());
        enhancer.setCallback(this);// 设置回调 
        Object result = enhancer.create();//创建并返回代理对象
        return result;
    }
    
    public static void main(String[] args) {
        CglibProxy cglib = new CglibProxy();//实例化CglibProxy对象
        StudyInterface study =  (StudyInterface) cglib.getCglibProxy(new Study());//获取代理对象
        user.studyEnglish("admin");//执行学习英文方法
    }
    
}