Java에서 동적 프록시 구현에 대한 튜토리얼

다음 내용은 일부 인터넷에 있는 내용을 바탕으로 작성되었으며 원작자에게 감사의 말씀을 전하고 싶습니다!

Java에서 동적 프록시 구현의 핵심은 Proxy와 InvocationHandler라는 두 가지입니다. InvocationHandler 인터페이스의 호출 메소드부터 시작하여 Java가 동적 프록시를 구현하는 방법을 간략하게 설명하겠습니다. N i 먼저 Invoke 메소드의 무결성은 다음과 같습니다. java code

Public Object Invoke (Object Proxy, Method Method, Object [] ARGS)

Throws Throwable

{

1. method.invoke(obj, args);      

   return
null;                               즉, ARGS를 실행해야 하는 메서드는 다음과 같습니다. 메소드의 매개변수입니다. 이 매개변수는 무엇인가요? 위의 Invoke() 메소드 구현은 상대적으로 표준적인 형식입니다. 여기서는 프록시 매개변수가 사용되지 않습니다. 다음과 같이 JDK 문서에서 프록시에 대한 설명을 확인하세요.

4. Java code

6. pr oxy 인터페이스 중 하나를 통해 프록시 인스턴스에 대한 메서드 호출은 다음과 같습니다. 인스턴스 호출 핸들러의 호출 메소드로 전달되어 프록시 인스턴스, 호출된 메소드를 식별하는 java.lang.reflect.Method 객체 및 인수를 포함하는 Object 유형 배열을 전달합니다. 이를 통해 위의 추측이 정확하다는 것을 알 수 있으며 프록시 매개변수가 프록시 클래스의 인스턴스로 전달된다는 것도 알 수 있습니다.

7. 설명의 편의를 위해 동적 프록시를 구현하는 간단한 예를 들어보겠습니다. ㅋㅋ           

public

interface 제목 {

public void request()

}

Java 코드

1. //실제 역할: Subject의 request() 메소드 구현

2. public class RealSubject implements Subject{

4. 공개 요청 취소(){

5. System.out.println("실제 주제에서.")

6. }

7. }

Java 코드

1. //구현된 InvocationHandler

2. public class DynamicSubject 구현 vocationHandler

3. {

4. 개인 개체 obj; //이것은 캡슐화된 개체가 개체 유형이며 모든 유형의 개체를 허용합니다. 공개 동적 주제 (객체 obj)

5. {

6. this.obj = ob j;

7. }

9. // 우리가 명시적으로 부르는 것이 아닙니다

10. public Object Invoke(Object Proxy, Method method, Object[] args)

    throwable
12. {
    System.out.println(
"호출하기 전 " + 메소드)
15. method.invoke(obj, args); //------> 이 단계에 대한 자세한 내용은 다음 문서를 참조하세요. Java는 리플렉션 메커니즘을 통해 특정 함수를 호출합니다. 읽은 후에.

16. System.out.println("" + 메소드 호출 후)

18. return

19. }

21. )

1. //클라이언트: 프록시 인스턴스를 생성하고 request() 메서드를 호출했습니다.

2. public class Client {

4. public static void main(String [ ] args) Throwable 던지기{

5.                                                                         ​Subject rs=new RealSubject();//여기서 프록시를 지정하세요. 클래스

InvocationHandler ds=
7. new DynamicSubject(rs)

   클래스> cls=rs.getClass();

​​​​
9. //다음은 일회용 프록시 생성

+                             Interfaces(), ds);

12. /여기서 주체가 프록시의 인스턴스임을 증명할 수 있습니다.

    시스템아웃 .println(subject
instanceof Proxy);
15.        

    //여기서 주체의 Class 클래스가 $Proxy0임을 알 수 있습니다. 이 클래스는 Proxy를 상속하고

16. toString());

System.out.print(
18. "제목의 속성은 다음과 같습니다: ")

Field [] field=subject.getClass () .getDeclaredFields();
21.                                                 

22.           System.out.print("n"+" 주제의 메소드는 다음과 같습니다: ") ().getDeclaredMethods( ); ㅠㅠ

23. System.out.println(

    "n"+

    "subject의 상위 클래스는 "+subject.getClass().getSuperclass());

25. System.out.print("n"+

    "주제에 의해 구현된 인터페이스: "); subject.getClass().getInterfaces();
27.                                                   ~ 8                                                           

28. }

30. System.out.println("nn"+"작업 결과: "); Subject.request()

}
)

33. 실행 결과는 다음과 같습니다. 여기서 패키지 이름은 생략됩니다. * **

true 대신 subject의 클래스 클래스는 다음과 같습니다. class $Proxy0
subject의 속성 m1, m3, m0, m2, 주제의 메서드는 request , hashCode, equals, toString,

주체의 상위 클래스: class java.lang.reflect.Proxy

subject Implements 인터페이스: cn.edu.ustc.dynamicproxy.Subject,

1. 실행 결과는 다음과 같습니다.

2. public abstract void를 호출하기 전 ***.Subject.request()

3. 실제에서 subject. . 동적 프록시에 대한 혼란의 근본 원인은 위의 subject.request()를 오해했기 때문입니다. 적어도 표면적으로는 혼란스러웠습니다. 나는 마지막 호출에서 얽혀 있었습니다. request()는 Invoke()와 연결되어 있으며, Invoke는 요청이 존재한다는 것을 어떻게 알 수 있습니까? 실제로 위의 true 및 클래스 $Proxy0은 아래에 언급된 $Proxy0의 소스 코드와 함께 동적 프록시에 대한 의문을 완전히 해결할 수 있습니다.

4. 위의 코드와 결과에서 볼 수 있듯이, Invoke() 메소드를 명시적으로 호출하지 않았으나, 실제로 이 메소드가 실행되었습니다. 전체 프로세스를 분석해 보겠습니다.

5. 클라이언트의 코드에서 newProxyInstance 메서드를 획기적인 방법으로 사용할 수 있습니다. 먼저 Proxy 클래스에 있는 newProxyInstance 메서드의 소스 코드를 살펴보겠습니다.

9. Java 코드

10. 1. public static Object newProxyInstance(ClassLoader loader,  

    2.          Class>[] 인터페이스,  

    3.         InvocationHandler h) 

    4. IllegalArgumentException이 발생함  

    5. {  

    6.     if (h == null) {  

    7.         throw new NullPointerException();  

    8.     }  

    10.     /* 

    11.      * 지정된 프록시 조회 또는 생성 수업. 

    12.      */  

    13.     클래스 cl = getProxyClass(로더, 인터페이스);  

    15.     /* 

    16.      * 지정된 호출 핸들러를 사용하여 생성자를 호출합니다. ㅋㅋㅋ

                    * Proxy源码开始有这样적정义： 

    17.            * 비공개 최종 정적 클래스 [] constructorParams = { InvocationHandler.class }; ㅋㅋㅋ

    18.         생성자 단점 = cl.getConstructor(constructorParams);  

            
    19. return(객체) cons.newInstance(

        new Object[] { h });  

    20.     } catch (NoSuchMethodException e) {  

    21.         throw new InternalError(e.toString());  

    22.     } 

        catch(IllegalAccessException e) {  

    23.        

        throw 
    new InternalError(e.toString());  

    25.     } catch (InstantiationException e) {  

           
    26. throw 

        new InternalError(e.toString());  

    27.     } catch(InvocationTargetException e) {  

            
    28. throw 

        new InternalError(e.toString());  

    29.     }  }  

    30. 
        
        Proxy.newProxyInstance(ClassLoader loader, Class>[] 인터페이스, InvocationHandler h)는 다음 작업을 수행합니다.
        (1) 매개변수 로더 및 인터페이스 호출 메서드에 따라 getProxyClass(loader, 인터페이스)는 $Proxy0 프록시 클래스를 생성합니다. $Proxy0 클래스는 인터페이스 인터페이스를 구현하고 Proxy 클래스를 상속합니다.
                              (2) $Proxy0을 인스턴스화하고 생성자에 DynamicSubject를 전달한 다음 $Proxy0을 호출합니다. 상위 클래스의 프록시는 다음과 같이 h에 값을 할당합니다.
        클래스 프록시{ InvocationHandler h=null; protected Proxy(InvocationHandler h) {

        }

        1. ...
           }
        Proxy를 상속하는 $Proxy0의 소스 코드를 살펴보겠습니다.

        5. Java 코드
        ​

        1. public final class $Proxy0 extends Proxy implements Subject {  

        2.     private static Method m1;  

        3.     비공개 정적 메소드 m0;  

        4.     비공개 정적 방법 m3;  

        5.     비공개 정적 방법 m2;  

        7.     정적 {  

        8.         시도해보세요 {  

        9.             m1 = Class.forName("java.lang.Object").getMethod("equals",  

        10.                    new Class[] { Class.forName("java.lang.Object") });  

        12.             m0 = Class.forName("java.lang.Object").getMethod("hashCode",  

        13.                     새 수업[0]);  

        15.             m3 = Class.forName("***.RealSubject").getMethod("요청",  

        16.                     새 수업[0]);  

        18.             m2 = Class.forName("java.lang.Object").getMethod("toString",  

        19.                    

            새 수업[0]);  

        21.         } 

            catch (NoSuchMethodException nosuchmethodexception) {  

        22.            

            throw new NoSuchMethodError(nosuchmethodexception.getMessage());  

        23.         } 

            catch (ClassNotFoundException classnotfoundException) {  

        24.            

            throw new NoClassDefFoundError(classnotfoundException.getMessage() );  

        25.         }  

        26.     } 

            //static  

        28.     

            public $Proxy0(Invoca tionHandler 호출 처리기) {  

        29.         

            super(invocationhandler);  

        30.     }  

        32.     

            @Override  

        33.     

            public final 부울 같음(객체 obj) {  

        34.         

            시도해 보세요 {  

        35.            return((Boolean) super.h.invoke(this, m1, new Object[] { obj })) .booleanValue();  

        36.         } catch(Throwable throwable) {  

        37.            throw new UndeclaredThrowableException(throwable);  

        38.         }  

        39.     }  

        41.     @Override  

        42.     public final int hashCode() {  

        43.         시도해 보세요 {  

        44.            return((정수) super.h.invoke(this, m0, null)).intValue();  

        45.         } catch(Throwable throwable) {  

        46.            throw new UndeclaredThrowableException(throwable);  

        47.         }  

        48.     }  

        50.     public final void request() {  

        51.         시도해 보세요 {  

        52.            super.h. 호출(this, m3, null);  

        53.             반품;  

        54.         } catch(오류 e) {  

        55.         } catch(던지기 가능) {  

        56.             throw new UndeclaredThrowableException(throwable);  

        57.         }  

        58.     }  

        60.     @Override  

        61.     public final String toString() {  

        62.         try {  

        63.             return(문자열) super.h.invoke(this, m2, null);  

        64.         } catch(Throwable throwable) {  

        65.            throw new UndeclaredThrowableException(throwable);  

        66.         }  

        67.     }  

        68. }  

        
        
        그런 다음 얻은 $Proxy0 인스턴스를 Subject로 캐스팅하고 참조를 subject에 할당합니다. subject.request() 메소드가 실행되면 $Proxy0 클래스의 request() 메소드가 호출된 후 상위 클래스 Proxy에 있는 h의 호출() 메소드, 즉 InvocationHandler.invoke()가 호출된다.
        
        PS: 1. 설명해야 할 한 가지는 Proxy 클래스의 getProxyClass 메서드가 Proxy 클래스 클래스를 반환한다는 것입니다. 이렇게 설명하는 이유는, 반환된 것이 "프록시된 클래스의 클래스"라고 생각하고 처음에 저레벨 실수를 했기 때문입니다--! getProxyClass의 소스 코드를 살펴보는 것이 좋습니다. 코드가 매우 깁니다. =
        2. $Proxy0의 소스 코드를 보면 동적 프록시 클래스가 명시적으로 정의된 인터페이스의 메서드를 프록시할 뿐만 아니라 Java 루트 클래스 Object에서 상속받은 equals() 및 hashcode()도 프록시하는 것을 볼 수 있습니다. , toString() 및 이 세 가지 메서드만 있습니다.
        
        Q: 지금까지 여전히 의문점이 있습니다. Invoke 메소드의 첫 번째 매개변수는 Proxy의 인스턴스(정확히 말하면 $Proxy0의 인스턴스가 최종적으로 사용됩니다)인데, 그 용도는 무엇인가요? 즉, 프로그램이 그 효과를 어떻게 나타내는가?
        A: 현재 수준에서 이 프록시 매개변수는 전체 동적 프록시 메커니즘에서 InvocationHandler의 호출 메소드의 프록시 매개변수가 사용되지 않습니다. 전달된 매개변수는 실제로 프록시 클래스의 인스턴스입니다. 프로그래머가 호출 메서드에서 리플렉션을 사용하여 프록시 클래스에 대한 일부 정보를 얻을 수 있도록 하는 것일 수도 있다고 생각합니다.

위 내용은 Java에서 동적 프록시 구현에 대한 튜토리얼의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!