关于java:动态代理

JDK动静代理的实现原理
1、依据传入的类的接口和InvocationHandler为接口创立代理类的字节码文件。通过反射创立method。method就是接口外面的办法，通过method就能够调用实现类重写的办法。
2、应用ClassLoader将字节码文件加载到JVM（定义了一个类，相似于$Proxy0、$Proxy1之类的）
3、通过反创立代理类实例对象
4、当调用代理对象办法时，就会进入到InvocationHandler的invoke办法中，这里就是用户编写的代理逻辑。通过method.invoke调用被代理对象的实现逻辑。

通过反射生成method，而后定义一个ProxyX的类，而后反射实例化这个类生成代理对象。代理对象的办法都会进入InvocationHandler的invoke办法

ps：jdk代理只能代理接口外面实现的类以及equals、hashCode、toString办法。

jdk代理不反对对实现类的代理，只反对接口的代理，因为生成的类曾经继承了Proxy，java不能多继承。

  

https://www.gaodaima.com/mhmyqn/…

cglib的实现代理的逻辑。
1、首先咱们通过Enhancer实例设置被代理类，
2、而后设置该代理类的回调，也就是在拜访代理类办法的时候会首先转向该回调，
3、在回调中咱们调用invokeSuper办法以fastclass这种非反射机制疾速的调用到代理类中的办法，其中代理类中办法又调用原类型的对应办法。

总结一下JDK动静代理和Gglib动静代理的区别：
1.JDK动静代理是实现了被代理对象的接口，Cglib是继承了被代理对象。
2.JDK和Cglib都是在运行期生成字节码，JDK是间接写Class字节码，Cglib应用ASM框架写Class字节码，Cglib代理实现更简单，生成代理类比JDK效率低。
3.JDK调用代理办法，是通过反射机制调用，Cglib是通过FastClass机制间接调用办法，Cglib执行效率更高。
https://www.cnblogs.com/monke…

通过Enhancer能够生成代理类，传入CallBack使代码执行时进入CallBack代码中，从而执行用户自定义代码；
用户自定义代码能够决定应用指标类调用还是代理类调用
指标类应用$$FastClass1进行调用
代理类应用$$FastClass2进行调用
$$FastClass都在调用时触发生成
$$FastClass为动静生成类，通过index与办法签名一一映射产生switch case 语句来进步调用效率
代理类是通过继承形式实现，不能对final类和办法应用CGLIB代理。

因而 CGLB代理调用效率高，然而生成效率慢，至多3个文件，1个代理类，2个FastClass类。所有生成的类都会加载到JVM堆中。

package proxy;

public class BigCar implements Car{
    @Override
    public void start() {
        System.out.println("big car start");
    }
    public void start(int a) {
        System.out.println("big car start");
    }
}

package proxy;

public interface Car {
    void start();
}

package proxy;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibInvocationHandler implements MethodInterceptor {
    Object target;

    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }

    /**
     调用过程：
     代理对象调用 this.被代理的办法
     ->调用拦截器intercept
     ->methodProxy.invokeSuper
     ->CGLIB$setPerson$0
     ->被代理对象setPerson办法
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("cglib proxy start");
        // o是代理对象，methodProxy.invoke会调用o的办法，而后再进入intercept办法会造成死循环
        Object result = methodProxy.invokeSuper(o, objects);
        // 原生cglib能够实现外部办法代理，
        // spring的cglib实现的aop不能切到外部调用的办法，除非特意设置
        // spring aop的写法
        // spring 会保留实在对象的 bean 。
        //    Object result = methodProxy.invoke(target, objects);
        System.out.println("cglib proxy end");
        return result;
    }
}

package proxy;

import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Enhancer;

public class CglibProxyFactory {
    public static Object createProxy(Class c,Callback callback){
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(c);
        enhancer.setCallback(callback);
        return enhancer.create();
    }
}

package proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class JdkProxyFactory {
    public static Object getJDKProxy(Object targetObject, InvocationHandler handler) {
        // JDK动静代理只能针对实现了接口的类进行代理，newProxyInstance 函数所需参数就可看出
        // 依据接口类
        return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
                targetObject.getClass().getInterfaces(),
                handler);
    }
}

package proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//JDK动静代理实现InvocationHandler接口
public class JdkProxyInvocationHandler implements InvocationHandler {
    private Object target;//须要代理的指标对象

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("JDK动静代理，监听开始！");
        System.out.println(proxy.getClass()+"   111");
        Object result = method.invoke(target, args);
        System.out.println("JDK动静代理，监听完结！");
        return result;
    }
}

package proxy;

import net.sf.cglib.core.DebuggingClassWriter;

import java.lang.reflect.Method;

public class Test {
    public static void main(String[] args) {
        UserManager target = new UserManagerImpl();
//        JdkProxyInvocationHandler handler = new JdkProxyInvocationHandler(target);
//        UserManager userManager = (UserManager) JdkProxyFactory.getJDKProxy(target, handler);
//        userManager.addUser("1", "1");

        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\Users\\YEZHENGWU839\\Desktop\\xiaoxi");
        CglibInvocationHandler handler1 = new CglibInvocationHandler();
        handler1.setTarget(target);
        UserManager userManager2 = (UserManager) CglibProxyFactory.createProxy(target.getClass(), handler1);
        userManager2.addUser("2","@");
        System.out.println(userManager2.getClass().getName());
    }
}

package proxy;

public interface UserManager {
    //新增用户形象办法
    void addUser(String userName, String password);

    //删除用户形象办法
    void delUser(String userName);

    default void find(){
        System.out.println("super interface find");
    }
}

package proxy;

//用户治理实现类,实现用户治理接口
public class UserManagerImpl implements UserManager {
    //重写新增用户办法
    @Override
    public void addUser(String userName, String password) {
        System.out.println("调用了新增的办法！");
        System.out.println("传入参数为 userName: " + userName + " password: " + password);
        delUser("111");
    }

    //重写删除用户办法
    @Override
    public void delUser(String userName) {
        System.out.println("调用了删除的办法！");
        System.out.println("传入参数为 userName: " + userName);
    }

    // 不是接口的类 没方法代理
    public void show() {
        System.out.println("this impl method not super method");
    }

}

喜欢 (0)赏

[搞代码]

分享 (0)