Java 동적 에이전트의 응용 상세 정보

동적 에이전트는 사실java입니다.lang.reflect.Proxy 클래스는 지정한 모든 인터페이스에 따라classbyte를 동적으로 생성합니다. 이class는 Proxy 클래스를 계승하고 지정한 모든 인터페이스를 실현합니다. (인자에 전송된 인터페이스 그룹)그리고 지정한classloader를 이용하여classbyte를 시스템에 불러옵니다. 마지막에 이런 종류의 대상을 생성하고 이 대상의 일부 값, 예를 들어invocationHandler, 즉 모든 인터페이스에 대응하는 Method 구성원을 초기화합니다.초기화한 후 호출된 클라이언트에게 대상을 되돌려줍니다.이렇게 클라이언트가 얻은 것은 당신의 모든 인터페이스를 실현하는 Proxy 대상입니다.실례 분석을 보십시오:

package com.fans.common.proxy;

public interface BusinessProcessor {
  public void processBusiness();
}


package com.fans.common.proxy;
/**
 *
 * @author fanshadoop
 *
 */
public class BusinessProcessorImpl implements BusinessProcessor {

 @Override
 public void processBusiness() {
  System.out.println("processing business.....");

 }

}


package com.fans.common.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
 *
 * @author fanshadoop
 *
 */
public class BusinessProcessorHandler implements InvocationHandler {

 private Object target = null;

 BusinessProcessorHandler(Object target) {
  this.target = target;
 }

 public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable {
  System.out
    .println("You can do something here before process your business");
  Object result = method.invoke(target, args);
  System.out
    .println("You can do something here after process your business");
  return result;
 }

}


package com.fans.common.proxy;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;

public class Test {

 /**
  * @param args
  */
 public static void main(String[] args) {
  BusinessProcessorImpl bpimpl = new BusinessProcessorImpl();
  BusinessProcessorHandler handler = new BusinessProcessorHandler(bpimpl);
  BusinessProcessor bp = (BusinessProcessor) Proxy.newProxyInstance(
    bpimpl.getClass().getClassLoader(), bpimpl.getClass()
      .getInterfaces(), handler);
  bp.processBusiness();

  System.out.println(bp.getClass().getName());
  printClassDefinition(bp.getClass());
 }

 public static String getModifier(int modifier) {
  String result = "";
  switch (modifier) {
  case Modifier.PRIVATE:
   result = "private";
  case Modifier.PUBLIC:
   result = "public";
  case Modifier.PROTECTED:
   result = "protected";
  case Modifier.ABSTRACT:
   result = "abstract";
  case Modifier.FINAL:
   result = "final";
  case Modifier.NATIVE:
   result = "native";
  case Modifier.STATIC:
   result = "static";
  case Modifier.SYNCHRONIZED:
   result = "synchronized";
  case Modifier.STRICT:
   result = "strict";
  case Modifier.TRANSIENT:
   result = "transient";
  case Modifier.VOLATILE:
   result = "volatile";
  case Modifier.INTERFACE:
   result = "interface";
  }
  return result;
 }

 public static void printClassDefinition(Class clz) {

  String clzModifier = getModifier(clz.getModifiers());
  if (clzModifier != null && !clzModifier.equals("")) {
   clzModifier = clzModifier + " ";
  }
  String superClz = clz.getSuperclass().getName();
  if (superClz != null && !superClz.equals("")) {
   superClz = "extends " + superClz;
  }
  Class[] interfaces = clz.getInterfaces();
  String inters = "";
  for (int i = 0; i < interfaces.length; i++) {
   if (i == 0) {
    inters += "implements ";
   }
   inters += interfaces[i].getName();
  }
  System.out.println(clzModifier + clz.getName() + " " + superClz + " "
    + inters);
  System.out.println("{");
  Field[] fields = clz.getDeclaredFields();
  for (int i = 0; i < fields.length; i++) {
   String modifier = getModifier(fields[i].getModifiers());
   if (modifier != null && !modifier.equals("")) {
    modifier = modifier + " ";
   }
   String fieldName = fields[i].getName();
   String fieldType = fields[i].getType().getName();
   System.out.println("    " + modifier + fieldType + " " + fieldName
     + ";");
  }

  System.out.println();

  Method[] methods = clz.getDeclaredMethods();
  for (int i = 0; i < methods.length; i++) {
   Method method = methods[i];

   String modifier = getModifier(method.getModifiers());
   if (modifier != null && !modifier.equals("")) {
    modifier = modifier + " ";
   }
   String methodName = method.getName();
   Class returnClz = method.getReturnType();
   String retrunType = returnClz.getName();

   Class[] clzs = method.getParameterTypes();
   String paraList = "(";
   for (int j = 0; j < clzs.length; j++) {
    paraList += clzs[j].getName();
    if (j != clzs.length - 1) {
     paraList += ", ";
    }
   }
   paraList += ")";
   clzs = method.getExceptionTypes();
   String exceptions = "";
   for (int j = 0; j < clzs.length; j++) {
    if (j == 0) {
     exceptions += "throws ";
    }
    exceptions += clzs[j].getName();
    if (j != clzs.length - 1) {
     exceptions += ", ";
    }
   }
   exceptions += ";";
   String methodPrototype = modifier + retrunType + " " + methodName
     + paraList + exceptions;

   System.out.println("    " + methodPrototype);
  }
  System.out.println("}");
 }
}

실행 결과:

You can do something here before process your business
processing business.....
You can do something here after process your business
$Proxy0
$Proxy0 extends java.lang.reflect.Proxy implements com.fans.common.proxy.BusinessProcessor
{
    java.lang.reflect.Method m1;
    java.lang.reflect.Method m3;
    java.lang.reflect.Method m0;
    java.lang.reflect.Method m2;

    boolean equals(java.lang.Object);
    java.lang.String toString();
    int hashCode();
    void processBusiness();
}

클래스 Business Processor Handler는 Invocation Handler 인터페이스의 invoke 방법을 실현했다. 이 클래스는 바로 Proxy가 최종적으로 고정 인터페이스를 호출하는 방법이다.
분명해, 프록시.new Proxy Instance 방법은 다음과 같은 몇 가지 일을 할 수 있다. 1. 전송된 두 번째 매개 변수인interfaces 동태에 따라 하나의 클래스를 생성하고 인터페이스의 인터페이스를 실현한다. 이 예는 바로 Business Processor 인터페이스의process Business 방법이다.그리고 Proxy 클래스를 계승하고hashcode,toString,equals 등 세 가지 방법을 다시 썼다.구체적인 구현은 ProxyGenerator를 참조하십시오.generateProxyClass(...); 이 예에서는 $Proxy0 클래스 2가 생성되었습니다. 전송된 첫 번째 인자classloder를 통해 방금 생성된 클래스를 jvm에 불러옵니다.$Proxy0 클래스load3를 시작합니다. 세 번째 파라미터를 이용하여 $Proxy0의 $Proxy0 구조 함수를 호출하여 $Proxy0의 대상을 만들고 인터페이스 파라미터로 모든 인터페이스를 훑어보는 방법을 사용하며 Method 대상 초기화 대상의 몇 개의 Method 구성원 변량 4를 생성하여 $Proxy0의 실례를 클라이언트에게 되돌려줍니다.이제 됐어.우리는 클라이언트가 어떻게 조정하는지 다시 보면 분명히 알 수 있다.1, 클라이언트는 $Proxy0의 실례 대상을 받았습니다. $Proxy0은 Business Processor를 계승했기 때문에 Business Processor로 전환하는 데 아무런 문제가 없습니다.         BusinessProcessor bp = (BusinessProcessor)Proxy.newProxyInstance(....);    2,bp.processBusiness();실제로 호출된 것은 $Proxy0입니다.processBusiness();그럼 $Proxy 0.processBusiness()의 실현은 InvocationHandler를 통해 invoke 방법을 호출하는 것입니다!

좋은 웹페이지 즐겨찾기