annotation与httpClient(3) -- Annotation与动态代理（Proxy）

Annotation与动态代理（Proxy）
本文是作者个人总结，如有纰漏请指正
在阅读下面内容前，希望读者有动态代理和Annotation方面的相关知识。

 

像mybatis这样的开源框架，在接口上进行标记，之后框架在运行时会生成实际的逻辑代码，执行后将结果返回给用户。例如：

publicinterfaceUserMapper{
 
@Select("SELECT * FROM users WHERE id = #{userId}")
 
User getUser(@Param("userId")String userId);
}

本文主要是探讨这个使用Annotation和Proxy如何达到mybatis这种效果。

本文以weather获取为例，weather的接口定义如下：

@URL("http://m.weather.com.cn/data/{city}.html")
publicinterface WeatherHttp {
    public String getWeather(@ParamUrl("city")
String city);
}

接口中定义了两个Annotation分别是URL和ParamUrl，URL表示接口要访问的网站，而ParamUrl表示访问网站Url中需要替换的参数。

两个Annotation定义如下：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public@interfaceURL {
      publicabstract String value();
}

 

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
public@interfaceParamUrl {
    publicabstract String value();
}

现在，我期望用动态代理的形式为这个类生成一个远程的访问，对于客户端，可以使用如下的方式获取信息：

publicclass WeatherTest {
   
    publicstaticvoid main(String[] args) {
       WeatherHttp weatherHttp = MapperProxy.newMapperProxy(WeatherHttp.class);
       System.out.println(weatherHttp.getWeather("101010100"));
    }
}

通过MapperProxy获取一个代理实例，然后执行这个代理实例，最终获取期望的结果。

动态代理的代码如下：

publicclass MapperProxy
implements InvocationHandler {
    privatestaticfinal Set<String>
OBJECT_METHODS =
new
HashSet<String>() {
       {
           add("toString");
           add("getClass");
           add("hashCode");
           add("equals");
           add("wait");
           add("notify");
           add("notifyAll");
       }
    };
 
    public Object invoke(Object proxy, Method method, Object[] args)
           throws Throwable {
       try {
           if (!OBJECT_METHODS.contains(method.getName()))
{
              final Class<?> declaringInterface = findDeclaringInterface(proxy,
                     method);
              if (declaringInterface ==
null) {
                  thrownew Exception(
                         "Could not find interface with the given method "
                                + method);
              }
 
              MapperMethod mapMethod =
new MapperMethod(declaringInterface,method);
              return mapMethod.execute(args);
           }
       } catch (Exception e) {
           e.printStackTrace();
       }
       returnnull;
    }
 
    private Class<?> findDeclaringInterface(Object proxy, Method method) {
       Class<?> declaringInterface =
null;
       for (Class<?> iface : proxy.getClass().getInterfaces()) {
           try {
              Method m = iface.getMethod(method.getName(),
                     method.getParameterTypes());
              if (declaringInterface !=
null) {
                  thrownew Exception(
                         "Ambiguous method mapping. 
Two mapper interfaces contain the identical method signature for "
                               
+ method);
              } elseif (m !=
null) {
                  declaringInterface = iface;
              }
           } catch (Exception e) {
             
           }
       }
       if (declaringInterface ==
null) {
       }
       return declaringInterface;
    }
 
   
     
@SuppressWarnings("unchecked")
    publicstatic <T> T newMapperProxy(Class<T> mapperInterface) {
           ClassLoader classLoader = mapperInterface.getClassLoader();
           Class<?>[] interfaces =
new Class[]{mapperInterface};
           MapperProxy proxy =
new MapperProxy();
           return (T) Proxy.newProxyInstance(classLoader, interfaces, proxy);
         }
 
   
}

动态代理实现了InvocationHandler接口，这样当用户调用接口时，会调用invoke方法，在invoke方法中会创建MapperMethod实例，并调用其中的excute方法，MapperMethod方法定义如下：

publicclass MapperMethod {
   
    private Class<?>
declaringInterface;
    private Method
method;
    private String
url;
    private Map<String,Integer>
paramUrl =
new HashMap<String, Integer>();
    private RestTemplate
template =
new RestTemplate();
   
    public MapperMethod(Class<?> declaringInterface, Method method) {
       this.declaringInterface =declaringInterface;
       this.method = method;
      
       prepareUrl();
      
       prepareParam();
    }
 
    privatevoid prepareParam() {
       for (int i = 0; i <
method.getParameterTypes().length; i++) {
           Object[] paramAnnos =
method.getParameterAnnotations()[i];
           for (int j = 0; j < paramAnnos.length;
j++) {
              if (paramAnnos[j]
instanceofParamUrl) {
               
                  paramUrl.put(((ParamUrl) paramAnnos[j]).value(), i);
              }
           }
       }     
    }
 
    privatevoid prepareUrl() {
       Annotation[] annotations =
declaringInterface.getAnnotations();      

       for(Annotation anno: annotations){
           if(anno
instanceofURL){
              url = ((URL)anno).value();
           }
       }  
 
    }
 
    public
Object execute(Object[] args) {
       Map<String,Object> newMap =
new HashMap<String, Object>();;
       if(paramUrl !=
null & !paramUrl.isEmpty()){
           for(Map.Entry<String, Integer> e :
paramUrl.entrySet()){
              newMap.put(e.getKey(), args[e.getValue()]);
           }
       }
       returntemplate.getForObject(url,
String.class,newMap);
    }
}

可见，最终MapperMethod方法，根据Annotation的标记信息，最终执行需要的逻辑。

简要回顾：用户使用Annotation标记其使用的接口，通过MapperProxy获取接口的实例，当调用接口的方法后会触发MapperProxy的invoke方法的调用，在invoke方法中创建了MapperMethod对象，并调用了其excute方法，在MapperMethod中最终解析Annotation，并组织远程访问。

因此MapperProxy实现了动态代理，而MapperMethod最终解释Annotation并执行相应的处理程序。