java的三种代理

earthchen

发布于 2020-09-24 15:57:45

2270

发布于 2020-09-24 15:57:45

文章被收录于专栏：earthchen的专栏earthchen的专栏

java的三种代理

代理

静态代理

编写需要目标对象实现的接口

/**
 * 接口
 */
public interface Action {

    /**
     * dosomething
     */
    void doSomething();
}

编写目标类，实现接口

/**
 * @author earthchen
 * @date 2018/8/10
 **/
public class RealObject implements Action {

    @Override
    public void doSomething() {
        System.out.println(this.getClass().getName()+"dosomething....");
    }
}

编写静态代理类，也需要实现该接口

/**
 * 代理类
 *
 * @author earthchen
 * @date 2018/8/10
 **/
public class Proxy implements Action {

    private Action realObject;

    public Proxy(Action realObject) {
        this.realObject = realObject;
    }

    @Override
    public void doSomething() {
        System.out.println("proxy do");
        realObject.doSomething();
    }
}

需要维护一个接口的对象

编写main方法进行测试

public class Main {

    public static void main(String[] args) {
        Action action = new RealObject();
        Proxy proxy = new Proxy(action);
        proxy.doSomething();
    }
}

优缺点

这种代理方式需要代理对象和目标对象实现一样的接口。

优点：可以在不修改目标对象的前提下扩展目标对象的功能。
缺点：

冗余。由于代理对象要实现与目标对象一致的接口，会产生过多的代理类。
不易维护。一旦接口增加方法，目标对象与代理对象都要进行修改。

jdk动态代理

和静态代理一样，编写一个接口

/**
 * @author earthchen
 * @date 2018/8/10
 **/
public interface Action {

    void doSomeThing();

}

编写多个目标类，实现接口

/**
 * @author earthchen
 * @date 2018/8/10
 **/
public class RealObject1 implements Action {

    @Override
    public void doSomeThing() {
        System.out.println(this.getClass().getName()+"do someThing...");
    }
}

/**
 * @author earthchen
 * @date 2018/8/10
 **/
public class RealObject2 implements Action {

    @Override
    public void doSomeThing() {
        System.out.println(this.getClass().getName()+"do someThing...");
    }
}

编写动态代理类，

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

/**
 * @author earthchen
 * @date 2018/8/10
 **/
public class DynamicProxyHandler implements InvocationHandler {

    private Action testAction;

    public DynamicProxyHandler(Action testAction) {
        this.testAction = testAction;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //代理扩展逻辑
        System.out.println("proxy do");

        return method.invoke(testAction, args);
    }
}

编写main方法进行测试

public class Main {

    public static void main(String[] args) {
        RealObject1 realObject1 = new RealObject1();
        Action proxy1 = (Action) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),
                new Class[]{Action.class}, new DynamicProxyHandler(realObject1));
        proxy1.doSomeThing();


        RealObject2 realObject2 = new RealObject2();
        Action proxy2 = (Action) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),
                new Class[]{Action.class}, new DynamicProxyHandler(realObject2));
        proxy2.doSomeThing();
    }
}

静态代理与动态代理的区别

静态代理在编译时就已经实现，编译完成后代理类是一个实际的class文件
动态代理是在运行时动态生成的，即编译完成后没有实际的class文件，而是在运行时动态生成类字节码，并加载到JVM中

特点：

动态代理对象不需要实现接口，但是要求目标对象必须实现接口，否则不能使用动态代理。

cglib代理

在pom.xml中引入cglib的依赖

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.5</version>
</dependency>

直接编写需要代理的目标类

public class RealObject {

    public void doSomeThing(){
        System.out.println(this.getClass().getName()+"do someThing...");
    }
}

编写cglib代理类

import java.lang.reflect.Method;

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

/**
 * @author earthchen
 * @date 2018/8/10
 **/
public class CglibProxy implements MethodInterceptor {

    private Object target;

    public CglibProxy(Object object) {
        this.target = object;
    }

    /**
     * 为目标对象生成代理对象
     *
     * @return
     */
    public Object getProxyInstance() {
        //工具类
        Enhancer en = new Enhancer();
        //设置父类
        en.setSuperclass(target.getClass());
        //设置回调函数
        en.setCallback(this);
        //创建子类对象代理
        return en.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before do someThing.....");
        // 执行目标对象的方法
        Object returnValue = method.invoke(target, objects);
        System.out.println("after do someThing....");
        return returnValue;
    }
}

cglib与动态代理的区别

使用动态代理的对象必须实现一个或多个接口
使用cglib代理的对象则无需实现接口，达到代理类无侵入。

cglib特点

JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类，就可以使用CGLIB实现
CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）
CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它需要你对JVM内部结构包括class文件的格式和指令集都很熟悉