在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());
}
}
运行结果
这样做,我们的这套工具就可以完全独立出来,只需要用户向我们的框架中注入规定的方法,而不去关心其具体实现,达到了解耦!主要在于找到其对应关系,也可以通过XML文件的方式形成对应关系,但是用XML文件对于其参数的处理就会比较麻烦,比如在structs2中,提供了带有无参方法的接口,让用户去实现这个接口,将方法和其成员的对应关系写入XML文件,其所需要的参数是利用其成员来完成的,要给其成员赋值,没有这种方式灵活。
我们可以在服务器和客户端分别写出请求和响应的方法,通过网络间字符串的传递,在服务器和客户端分别执行我们注入的方法!