1. 정적 에이전트

프록시 모드는 대상에게 프록시 대상을 제공하고 프록시 대상이 원래 대상에 대한 인용을 제어합니다.
좋은 점

프록시 대상을 도입하여 간접적으로 목표 대상에 접근하여 시스템에 직접 접근하는 불필요한 복잡성을 방지한다

프록시를 통한 액세스 제어

결점

일대일은 정적 프록시 대상의 양이 많고 코드의 양이 많아 코드가 복잡하고 유지보수성이 떨어지는 문제가 발생하고 일대일이 많으면 프록시 대상의 확장 능력이 떨어지는 문제가 발생한다.

대리 3대 역할

추상적 역할

대리 역할과 실제 역할이 대외적으로 제공하는 공공 방법은 일반적으로 하나의 인터페이스이다

에이전트 역할

추상적인 역할 인터페이스를 실현하고 진정한 역할 인용을 가지며 진실한 역할의 대리이다. 진실한 역할의 업무 논리 방법을 통해 추상적인 방법을 실현하고 자신의 조작을 추가할 수 있다.통일된 절차 제어를 모두 대리 역할에서 처리하다

실제 캐릭터

추상적인 역할 인터페이스를 실현하고 실제 역할이 실현하고자 하는 업무 논리를 정의하여 대리 역할이 호출될 수 있도록 해야 한다.진정한 업무 논리가 여기에 있다는 것이다.

2. 동적 에이전트

실행할 때 프록시 클래스와 실례를 다시 만들기 때문에 효율이 훨씬 낮습니다.이 장면을 완성하려면 운행 기간에 클래스를 동적으로 만들어야 합니다.JDK가 Proxy를 제공해서 이 일을 완성했습니다.

사례는 다음과 같다

//     
interface Api {
    void test(String a);
}
//     
class ApiImpl{
@Override
public void test(String a) {
   System.out.println("    :" + a);
} }
//        
ApiImpl api = new ApiImpl();
//JDK    : 
Proxy.newProxyInstance(getClass().getClassLoader(),new Class[]{Api.class}, //JDK         
  new InvocationHandler() {
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throwsThrowable { 
//        
        return method.invoke(api, args); }
});

참고: Proxy.New Proxy Instance에서 클래스를 만들 것입니다. 정적 에이전트와 달리, 이 클래스는 구체적인 것이 아닙니다.자바 원본 파일은 실제 파일이 없고 메모리에 클래스 형식에 따라 클래스를 생성합니다.

public interface Api {

    String getString();

}

String name = Api.class.getName()+"$Proxy0";
//         Class  
byte[] bytes = ProxyGenerator.generateProxyClass(name, new Class[]{Api.class}); 
FileOutputStream fos = new FileOutputStream("lib/" + name+".class"); 
fos.write(bytes);
fos.close();
//   class    
public final class Api$Proxy0 extends Proxy implements Api {
    private static Method m1;
    private static Method m2;
    private static Method m0;
    private static Method m3;

    public Api$Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String getString() throws  {
        try {
            return (String)super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m3 = Class.forName("com.example.lib.Api").getMethod("getString");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

이곳의 h는 사실 InvocationHandler 인터페이스이기 때문에 우리가 동적 에이전트를 사용할 때 전달하는 InvocationHandler는 하나의 감청이고 대리 대상에서 실행하는 방법은 모두 이 감청에서 되돌아온다.