Java 동적 프록시 및 정적 프록시 분석 예

1. 정적 프록시

정적 프록시 사용

정적 프록시, 프록시 클래스 및 프록시 클래스는 동일한 인터페이스를 구현하고 프록시 클래스도 프록시 클래스에 대한 참조를 보유하므로 프록시 클래스 메서드를 호출해야 할 때 , 프록시 클래스의 메서드를 호출하여 이를 수행할 수 있습니다.

예: 리더의 업무가 회의를 열고 직원을 평가하는 것이라고 가정해 보겠습니다.

먼저 인터페이스 정의:

package com.sharpcj;
public interface IWork {
    void meeting();
    int evaluate(String name);
}

그런 다음 리더십 클래스 정의:

package com.sharpcj;
import java.util.Random;
public class Leader implements IWork {
    @Override
    public void meeting() {
        System.out.println("领导早上要组织会议");
    }
    @Override
    public int evaluate(String name) {
        int score = new Random(System.currentTimeMillis()).nextInt(20) + 80;
        System.out.println(String.format("领导给%s的考评为%s分", name, score));
        return score;
    }
}

비서 클래스:

package com.sharpcj;
public class Secretary implements IWork {
    private Leader mLeader;
    public Secretary(Leader mLeader) {
        this.mLeader = mLeader;
    }
    @Override
    public void meeting() {
        System.out.println("秘书先给老板准备材料");
        mLeader.metting();
    }
    @Override
    public int evaluate(String name) {
        return mLeader.evaluate(name);
    }
}

테스트 클래스:

package com.sharpcj;
public class TestApp {
    public static void main(String[] args) {
        Leader leader = new Leader();
        Secretary secretary = new Secretary(leader);
        secretary.meeting();
        secretary.evaluate("Joy");
    }
}

실행 결과:

이것은 code Secretary 클래스의 미팅 메소드를 호출할 때 Leader 클래스의 미팅 메소드도 호출했다는 점에 유의하세요. 이 시점에서 일부 사람들은 약간의 데코레이터 패턴인 것처럼 보일 수 있습니다. 무슨 일이야? Secretary类的 meeting 方法时，我们调用了Leader类的 meeting 的方法，在此之前，我们还扩充了该方法。这时有的人可能有疑惑了，这看起来有点是装饰者模式了。这到底怎么回事？

与装饰者模式的区别

实际上，在装饰器模式和代理模式之间还是有很多差别的。装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。换句话说，用代理模式，代理类（proxy class）可以对它的客户隐藏一个对象的具体信息。因此，当使用代理模式的时候，我们常常在一个代理类中创建一个对象的实例。并且，当我们使用装饰器模式的时候，我们通常的做法是将原始对象作为一个参数传给装饰者的构造器。

我们可以用另外一句话来总结这些差别：使用代理模式，代理和真实对象之间的的关系通常在编译时就已经确定了，而装饰者能够在运行时递归地被构造。

先看看两者的 UML 类图区别：

代理模式：

装饰者模式：

两者伪代码：

代理模式:

Interface Subject {
    void doAction()
}
public class RealSubject implements Subject{
    @Override
    public void doAction() {};
}
public class Proxy implements Subject{
       private RealSubject realSubject;

       public Proxy(RealSubject realSubject) {
             //关系在编译时确定
            this.realSubject = realSubject;
       }
       @Override
       public void doAction() {
             ….
             realSubject.doAction();
             ….
       }
}

装饰者模式;

Interface Component {
    void doAction()
}
public class ConcreteComponent implement Component {
    @Override
    public void doAction() {};
}
public class Decorator implements Component {
       private Component component;

       public Decorator(Component component) {
             //关系在编译时确定
            this.component = new component;
       }
       public void doAction() {
             ….
             component.doAction();
             ….
       }
}

其实代理模式和装饰者模式侧重点不一样，代理模式重点在于明确了被代理的类。如上例中，秘书很明确要代理的是的领导。而装饰者模式侧重于拓展类的方法，装饰类持有的实现Component接口的类的对象不是固定的，也就是说，装饰类可以根据在调用时传入的参数，装饰任意一个实现了 Component 接口的类。

二、动态代理

动态代理的根据实现方式的不同可以分为 JDK 动态代理和 CGlib 动态代理。

JDK 动态代理：利用反射机制生成一个实现代理接口的类，在调用具体方法前调用InvokeHandler来处理。
CGlib 动态代理：利用ASM（开源的Java字节码编辑库，操作字节码）开源包，将代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。
区别：JDK代理只能对实现接口的类生成代理；CGlib是针对类实现代理，对指定的类生成一个子类，并覆盖其中的方法，这种通过继承类的实现方式，不能代理final修饰的类。

JDK 动态代理

还是以上面的例子为例：
首先，定一个类实现 InvocationHandler 接口，并实现 invoke 方法：

package com.sharpcj;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class WorkInvocationHandler implements InvocationHandler {
    private Object object;
    public WorkInvocationHandler(Object object) {
        this.object = object;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("object: " + object.getClass().getSimpleName());
        System.out.println("proxy: " + proxy.getClass().getSimpleName());

        if ("meeting".equals(method.getName())) {
            System.out.println("代理先准备会议材料...");
            return method.invoke(object, args);
        } else if ("evaluate".equals(method.getName())) {
            if(args[0] instanceof String) {
                if ("James".equals(args[0])) {
                    System.out.println("James 犯过错误，所以考评分数较低...");
                    return 70;
                }
            }
            return method.invoke(object, args);
        }
        return null;
    }
}

然后通过 Proxy.newProxyInstance()

데코레이터 패턴과의 차이점

사실 데코레이터 패턴과 프록시 패턴에는 많은 차이점이 있습니다. 데코레이터 패턴은 객체에 메서드를 동적으로 추가하는 데 중점을 두는 반면, 프록시 패턴은 객체에 대한 액세스를 제어하는 ​​데 중점을 둡니다. 즉, 프록시 패턴을 사용하면 프록시 클래스는 클라이언트로부터 개체의 특정 정보를 숨길 수 있습니다. 따라서 프록시 패턴을 사용할 때 프록시 클래스에 객체의 인스턴스를 생성하는 경우가 많습니다. 그리고 데코레이터 패턴을 사용할 때 일반적인 접근 방식은 원본 개체를 데코레이터 생성자에 매개 변수로 전달하는 것입니다.

이러한 차이점을 다른 문장으로 요약할 수 있습니다. 프록시 패턴을 사용하면 프록시와 실제 개체 간의 관계는 일반적으로 컴파일 타임에 결정되는 반면 데코레이터는 런타임에 재귀적으로 구성될 수 있습니다.

먼저 두 UML 클래스 다이어그램의 차이점을 살펴보세요.

에이전트 모드:

데코레이터 모드:

두 의사 코드: 🎜🎜🎜에이전트 모드: 🎜🎜

package com.sharpcj;
import java.lang.reflect.Proxy;
public class TestApp {
    public static void main(String[] args) {
        /*Leader leader = new Leader();
        Secretary secretary = new Secretary(leader);
        secretary.meeting();
        secretary.evaluate("Joy");*/
        Leader leader = new Leader();
        IWork proxy = (IWork) Proxy.newProxyInstance(Leader.class.getClassLoader(),
                new Class[]{IWork.class}, new WorkInvocationHandler(leader));
        proxy.meeting();
        proxy.evaluate("Joy");
        proxy.evaluate("James");
    }
}

🎜🎜Decorator 모드; 🎜🎜

package com.sharpcj.proxytest;
public interface IWork {
    IWork work(String subject);
}

🎜사실 프록시 모드 데코레이터 패턴과 달리 프록시 패턴의 초점은 프록시되는 클래스를 명확히 하는 것입니다. 위의 예에서처럼 비서는 분명히 리더를 대신하여 행동하기를 원합니다. 데코레이터 패턴은 클래스의 메소드를 확장하는 데 중점을 둡니다. 데코레이팅된 클래스가 보유한 Component 인터페이스를 구현하는 클래스의 객체는 고정되어 있지 않습니다. 유형을 호출할 때 전달되는 매개변수입니다. 🎜🎜2. 동적 프록시🎜🎜동적 프록시는 구현 방법에 따라 JDK 동적 프록시와 CGlib 동적 프록시로 나눌 수 있습니다. 🎜🎜🎜JDK 동적 프록시: 🎜반사 메커니즘을 사용하여 프록시 인터페이스를 구현하는 클래스를 생성하고 특정 메서드를 호출하기 전에 InvokeHandler를 호출하여 이를 처리합니다.
🎜CGlib 동적 프록시:🎜ASM(오픈 소스 Java 바이트코드 편집 라이브러리, 운영 바이트코드) 오픈 소스 패키지를 사용하여 프록시 객체 클래스의 클래스 파일을 로드하고 해당 바이트코드 처리를 수정하여 하위 클래스를 생성합니다.
🎜차이점:🎜JDK 프록시는 인터페이스를 구현하는 클래스에 대해서만 프록시를 생성할 수 있습니다. CGlib는 클래스에 대한 프록시를 구현하고, 지정된 클래스에 대한 하위 클래스를 생성하며, 그 안에 있는 메서드를 재정의합니다. 이는 클래스를 상속함으로써 달성됩니다. 프록시 최종 수정 클래스. 🎜🎜JDK 동적 프록시🎜🎜🎜위의 예를 예로 들어 보겠습니다.🎜
먼저 InvocationHandler 인터페이스를 구현하는 클래스를 정의하고 호출 메서드를 구현합니다. 🎜

package com.sharpcj.proxytest;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class WorkInvocationHandler implements InvocationHandler {
    private Object object;
    public WorkInvocationHandler(Object object) {
        this.object = object;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if ("work".equals(method.getName())){
            System.out.println("--- work: " + args[0]);
            return proxy;
        }
        return null;
    }
}

🎜그런 다음 전달합니다. Proxy.newProxyInstance() 메소드는 프록시 객체를 생성합니다: 🎜

package com.sharpcj.proxytest;
import java.lang.reflect.Proxy;
public class TestApp {
    public static void main(String[] args) {
        IWork worker = (IWork) Proxy.newProxyInstance(IWork.class.getClassLoader(), new Class[]{IWork.class},
                new WorkInvocationHandler(new IWork() {
                    @Override
                    public IWork work(String subject) {
                        return null;
                    }
                }));
        worker.work("AAA").work("BBB").work("CCC");
    }
}

🎜🎜출력 결과: 🎜🎜🎜🎜🎜🎜WorkInvocationHandler 클래스를 통해 Leader 클래스 구현을 프록시할 수도 있음을 알 수 있습니다. 실제로 우리는 모든 메소드를 구현하지만 프록시 객체를 생성할 때 Iwork 인터페이스와 Leader 클래스 객체를 전달합니다. 🎜🎜🎜🎜여기서 주목해야 할 점은 다음과 같습니다. 🎜InvocationHandler 인터페이스의 호출 메소드에 있는 첫 번째 매개변수 프록시는 우리가 메소드를 호출하는 객체가 아닙니다. 코드에서 프록시의 클래스 이름을 인쇄하기 위해 특별히 해당 인쇄를 추가했습니다. 실제로 프록시는 프록시 개체 자체입니다. 그 의미는 호출 메서드에서 프록시 개체를 반환한 다음 연속 호출을 할 수 있다는 것입니다. 🎜🎜🎜다음 예를 살펴보세요. 🎜

... 
dependencies {
    // 引入 cglib 库
    compile 'cglib:cglib:3.1'
    testCompile group: 'junit', name: 'junit', version: '4.12'
}
...

package com.sharpcj;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class LeaderMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        if ("meeting".equals(method.getName())) {
            System.out.println("代理先准备会议材料...");
            return methodProxy.invokeSuper(o, objects);
        } else if ("evaluate".equals(method.getName())) {
            if(objects[0] instanceof String) {
                if ("James".equals(objects[0])) {
                    System.out.println("James 犯过错误，所以考评分数较低...");
                    return 70;
                }
            }
            return methodProxy.invokeSuper(o, objects);
        }
        return null;
    }
}

package com.sharpcj;
import net.sf.cglib.core.DebuggingClassWriter;
import net.sf.cglib.proxy.Enhancer;
import java.lang.reflect.Proxy;
public class TestApp {
    public static void main(String[] args) {
        // System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\temp\code");  //保存生成的 class 文件
        Enhancer enhancer = new Enhancer(); // 通过CGLIB动态代理获取代理对象的过程
        enhancer.setSuperclass(Leader.class); // 设置enhancer对象的父类
        enhancer.setCallback(new LeaderMethodInterceptor()); // 设置enhancer的回调对象
        Leader proxy= (Leader)enhancer.create(); // 创建代理对象

        // 通过代理对象调用目标方法
        proxy.meeting();
        proxy.evaluate("Joy");
        proxy.evaluate("James");
    }
}

🎜🎜결과는 다음과 같습니다. 🎜🎜🎜🎜🎜

CGlib 动态代理实现

首先添加 cglib 依赖

build.gradle 文件：

... 
dependencies {
    // 引入 cglib 库
    compile 'cglib:cglib:3.1'
    testCompile group: 'junit', name: 'junit', version: '4.12'
}
...

前面说了，cglib 针对类进行代理，我们以上面的 Leader 类为例，先创建一个类实现 MethodInterceptor接口：

package com.sharpcj;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class LeaderMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        if ("meeting".equals(method.getName())) {
            System.out.println("代理先准备会议材料...");
            return methodProxy.invokeSuper(o, objects);
        } else if ("evaluate".equals(method.getName())) {
            if(objects[0] instanceof String) {
                if ("James".equals(objects[0])) {
                    System.out.println("James 犯过错误，所以考评分数较低...");
                    return 70;
                }
            }
            return methodProxy.invokeSuper(o, objects);
        }
        return null;
    }
}

测试代码：

package com.sharpcj;
import net.sf.cglib.core.DebuggingClassWriter;
import net.sf.cglib.proxy.Enhancer;
import java.lang.reflect.Proxy;
public class TestApp {
    public static void main(String[] args) {
        // System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\temp\code");  //保存生成的 class 文件
        Enhancer enhancer = new Enhancer(); // 通过CGLIB动态代理获取代理对象的过程
        enhancer.setSuperclass(Leader.class); // 设置enhancer对象的父类
        enhancer.setCallback(new LeaderMethodInterceptor()); // 设置enhancer的回调对象
        Leader proxy= (Leader)enhancer.create(); // 创建代理对象

        // 通过代理对象调用目标方法
        proxy.meeting();
        proxy.evaluate("Joy");
        proxy.evaluate("James");
    }
}

结果如下：

MethodInterceptor 接口只有一个 intercept 方法，这个方法有4个参数：

• 1）obj表示增强的对象，即实现这个接口类的一个对象；

• 2）method表示要被拦截的方法；

• 3）args表示要被拦截方法的参数；

• 4）proxy表示要触发父类的方法对象；

需要注意的是:实际调用是 methodProxy.invokeSuper(), 如果使用 invoke() 方法，则需要传入被代理的类对象，否则出现死循环，造成 stackOverflow 。

위 내용은 Java 동적 프록시 및 정적 프록시 분석 예의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!