【Java】用注解实现分发器

在C/S中，客户端会向服务器发出各种请求，而服务器就要根据请求做出对应的响应。
实际上就是客户机上执行某一个方法，将方法返回值，通过字节流的方式传输给服务器，服务器找到该请求对应的响应方法，并执行，将结果再次通过字节流的方式传输给客户机！
下面搭建一个简单的Request和Response分发器：

类标识的注解，只有带有该标识，才进行之后方法的扫描，否则不进行：

 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;

 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.TYPE)
 public @interface Service {
 }

方法的注解， 必须对注解中的action赋值，往后我们是要将action的值作为map中的键：

 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;

 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.METHOD)
 public @interface Actioner {
     String action();
 }

方法参数的注解，同样要对其name赋值，为了以后能够找到对应的参数，完成赋值：

 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;

 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.PARAMETER)
 public @interface AParameter {
     String name();
 }

我们需要将方法抽象成一个类，封装起来：

 import java.lang.reflect.Method;
 import java.lang.reflect.Parameter;
 import java.util.List;

 public class ActionDefination {
     private Class<?> klass;                　　　　 // 该方法所对应的类
     private Object object;                         // 执行该方法的对象
     private Method method;               　　　　　　// 该方法
     private List<Parameter> paramerterList;        // 该方法的所有参数

     protected ActionDefination(Class<?> klass, Object object, Method method, List<Parameter> paramerterList) {
         this.klass = klass;
         this.object = object;
         this.method = method;
         this.paramerterList = paramerterList;
     }

     protected Class<?> getKlass() {
         return klass;
     }

     protected Object getObject() {
         return object;
     }

     protected Method getMethod() {
         return method;
     }

     protected List<Parameter> getParamerterList() {
         return paramerterList;
     }

 }

所有准备工作都做好了，我们就需要通过包扫描的方式，找到带有Service 注解的类，然后找到其中带有Actioner 注解的方法，并且得到带有注解的所有参数，若其某一参数没有带注解，则应该异常处理！

扫描包下符合要求的所有内容，最后形成一张map

 import java.lang.reflect.Method;
 import java.lang.reflect.Parameter;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 public class ActionFactory {
     private static final Map<String, ActionDefination> actionDefinationMap = new HashMap<String, ActionDefination>();

     // 单例模式
     private ActionFactory() {
     }
     public static ActionFactory newInstance() {
         return creatNewInstance.actionFactory;
     } 

     private static class creatNewInstance {
         private static final ActionFactory actionFactory = new ActionFactory();
     }

     // 通过类，扫描其所在包下的所有文件
     public void scanAction(Class<?> klass) {
         scanAction(klass.getPackage().getName());
     }

     //  通过包名称，扫描其下所有文件
     public void scanAction(String packageName) {
         // 包扫描，在我的上一篇博客有该方法的实现
         new PackageScanner() {

             @Override
             public void dealClass(Class<?> klass) {
                 // 只处理带有Service注解的类
                 if (!klass.isAnnotationPresent(Service.class)) {
                     return;
                 }
                 try {
                     // 直接由反射机制产生一个对象，将其注入
                     Object object = klass.newInstance();
                     // 扫描改类下的所有方法
                     scanMethod(klass, object);
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
             }
         }.scanPackage(packageName);
     }

     // 通过对象，扫描其所有方法
     public void scanAction(Object object) {
         try {
             scanMethod(object.getClass(), object);
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

     private void scanMethod(Class<?> klass, Object object) throws Exception {
         // 得到所有方法
         Method[] methods = klass.getDeclaredMethods();

         // 遍历所有方法，找到带有Actioner注解的方法，并得到action的值
         for (Method method : methods) {
             if (!method.isAnnotationPresent(Actioner.class)) {
                 continue;
             }
             Actioner actioner = method.getAnnotation(Actioner.class);
             String action = actioner.action();

             // 判断action是否已经定义
             if (actionDefinationMap.get(action) != null) {
                 throw new ActionHasDefineException("方法" + action + "已定义！");
             }

             // 得到所有参数，并判断参数是否满足要求
             Parameter[] parameters = method.getParameters();
             List<Parameter> parameterList = new ArrayList<Parameter>();
             for (int i = 0; i < parameters.length; i++) {
                 Parameter parameter = parameters[i];
                 if (!parameters[i].isAnnotationPresent(AParameter.class)) {
                     throw new MethodParameterNotDefineException("第" + (i+1) + "个参数未定义！");
                 }

                 parameterList.add(parameter);
             }
             // 将得到的结果添加到map中
             addActionDefination(action, klass, object, method, parameterList);
         }
     }

         private void addActionDefination(String action, Class<?> klass, Object object, Method method, List<Parameter> parameterList) {
         ActionDefination actionDefination = new ActionDefination(klass, object, method, parameterList);
         actionDefinationMap.put(action, actionDefination);
     }

     protected ActionDefination getActionDefination(String action) {
         return actionDefinationMap.get(action);
     }

 }

上述的ActionFactory可以帮助我们扫描到包下所有符合要求的方法，接下来就是通过传递参数执行这些方法。
要注意，这套工具的出发点是搭载在网络上，所以传递的参数就只能是字符串或者字节流的形式，所以，我们应该对传递的参数进行处理，将其生成能供我们识别的形式。
这里我们将参数转换为字符串的形式，我会用到gson，方便我们将对象转换为gson字符串：

 import java.util.HashMap;
 import java.util.Map;

 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;

 public class ArgumentMaker {
     // 注解AParameter中name的值 +  参数对象转换成的gson字符串所形成的map
     private Map<String, String> argumentMap;
     private Gson gson;

     public ArgumentMaker() {
         gson = new GsonBuilder().create();
         argumentMap = new HashMap<String, String>();
     }

     // 其name就是注解AParameter中name的值，value就是参数的具体值
     public ArgumentMaker add(String name, Object value) {
         // 通过gson将参数对象转换为gson字符串
         argumentMap.put(name, gson.toJson(value));
         return this;
     }

     // 将得到的name + 参数对象转换成的gson字符串map再次转换成gson字符串，以便于进行传输
     public String toOgnl() {
         if (argumentMap.isEmpty()) {
             return null;
         }

         return gson.toJson(argumentMap);
     }

 }

接下来就是处理具体的action

 import java.lang.reflect.Method;
 import java.lang.reflect.Parameter;
 import java.lang.reflect.Type;
 import java.util.List;
 import java.util.Map;

 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.reflect.TypeToken;

 public class Addition {
     private static final Gson gson;
     private static final Type type;

     static {
         gson = new GsonBuilder().create();
         // 可以得到带有泛型的map类型
         type = new TypeToken<Map<String, String>>(){}.getType();
     }

     public String doRequest(String action, String parameter) throws Exception {
         ActionDefination ad = ActionFactory.newInstance().getActionDefination(action);

         if (ad == null) {
             throw new ActionNotDefineException("方法" + action + "未定义！");
         }

         Object object = ad.getObject();
         Method method = ad.getMethod();

         Object[] parameters = getParameterArr(parameter, ad.getParamerterList());
         Object result = method.invoke(object, parameters);

         return gson.toJson(result);
     }

     private Object[] getParameterArr(String parameterString, List<Parameter> parameterList) {
         Object[] results = new Object[parameterList.size()];
         // 将字符串形式的参数，转换成map
         Map<String, String> parameterStringMap = gson.fromJson(parameterString, type);

         int index = 0;
         for (Parameter parameter : parameterList) {
             // 得到参数的注解AParameter中name的值
             String key = parameter.getAnnotation(AParameter.class).name();

             // 以name的值为键，找到参数map中value，再通过gson将其从字符串转换成具体的对象
             Object value = gson.fromJson(parameterStringMap.get(key),
                     // 得到参数的具体类型
                     parameter.getParameterizedType());

             results[index++] = value;
         }

         return results;
     }

演示如何使用

 @Service
 public class Demo {

     @Actioner(action="one")
     public void fun() {
         System.out.println("执行无参的fun方法");
     }

     @Actioner(action="two")
     public void fun(@AParameter(name="1")int parameter) {
         System.out.println("执行单参的fun方法： parameter = " + parameter);
     }

     @Actioner(action="three")
     public void fun(@AParameter(name="1")int one,
             @AParameter(name="2")String two,
             @AParameter(name="3")boolean three) {
         System.out.println("执行三参的fun方法： one = " + one + " two = " + two + " three = " + three);
     }

     private static class Student {
         private String name;
         private int age;
         private boolean sex;

         private Student(String name, int age, boolean sex) {
             this.name = name;
             this.age = age;
             this.sex =sex;
         }

         @Override
         public String toString() {
             return "name = " + name + ", age = " + age + ", sex = " + (sex ? "男" : "女");
         }
     }

     @Actioner(action="four")
     public void fun(@AParameter(name="1")Student student) {
         System.out.println("执行复杂类型参数的fun方法 ：" + student);
     }

     public static void main(String[] args) throws Exception {
         // 扫描包，这里直接扫描Demo所在的包
         ActionFactory.newInstance().scanAction(Demo.class);

         Addition addition = new Addition();

         addition.doRequest("one", null);

         addition.doRequest("two", new ArgumentMaker()
                 .add("1", 3)
                 .toOgnl());

         addition.doRequest("three",new ArgumentMaker()
                 .add("3", true)
                 .add("1", 3)
                 .add("2", "这是第二个参数")
                 .toOgnl());

         Student student = new Student("小明", 15, true);
         addition.doRequest("four", new ArgumentMaker()
                 .add("1", student)
                 .toOgnl());
     }

 }

运行结果