【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());
    }

}

运行结果