应用场景
对于这篇文章，如果有什么地方简述有误，还请多多指教！！！
概述
假设用户发送一个登录请求，那么服务器该如何处理呢？
- 首先，用户在发送请求的时候向服务器发送：动作、和对应的参数（账户，密码）。
- 那么，这里我们就需要明白，用户发送不同动作，服务器就会有不同的响应，这时我们就需要根据不同的响应执行相应的方法。
- 但是，问题来了，我们在编写服务器端的时候是不知道用户会有哪些动作的，因此我们需要用到注解或者配置XML。
- 对于第二个参数，动作不同，参数也就不一样，因此我们需要一个对象，将所需的参数写在一个类里，然后将该类的对象传过去。但是Java里是值传递，没有引用传递。因此我们需要用到Json这个工具（可以将对象转换成字符串，也可以将反转成对象）这里，所用方法是以参数名为键，参数值为对象的字符串存放到一个Map里，然后再将Map利用Json转换为字符串。
- 此外，我们还需用到包扫描和反射机制。因为我们不知道处理用户动作的方法在哪个类里，而且用反射机制执行方法的时候，我们需要知道方法名，参数类型，参数名。但是，反射机制提供的Parameter类里不能得到对应的参数名，因此需要给参数也加上注解，最后通过注解得到参数名，然后根据参数名在Map里找到对应的字符串值，再将该值转换成对应的对象。因此，需要在有该方法的类上加一个注解，通过包扫描找到该类然后通过注解找到Action对应的方法和参数名。
- 最后再根据反射机制执行该方法，这样就可以动态的解决问题了。
下面我们从代码角度考虑该问题
//这是服务器端的方法
protected void dealNetMessage(NetMessage netMessage) {
ENetCommand command = netMessage.getCommand();
//客户端发送一个REQUEST命令，服务器端获得该命令，然后执行相应的方法。
if (command.equals(ENetCommand.REQUEST)) {
//action（动作）由request 以及 & 和response三部分组成，根据不同的动作服务器有不同的响应
String action = netMessage.getAction();
int colonIndex = action.indexOf('&');
//获得请求命令
String request = action.substring(0, colonIndex);
try {
//根据请求和参数，利用注解包扫描，并且利用反射机制，反射执行
String result = server.getActioner()
.executeRequest(request, netMessage.getPara());
send(new NetMessage()
.setCommand(ENetCommand.RESPONSE)
.setAction(action)
//把执行完的结果当成参数传给客户端
//这里的result是执行完动作对应的方法的结果的返回值
.setPara(result));
} catch (Exception e) {
e.printStackTrace();
}
return;
}
try {
CommandDispatcher.dispatcherCommand(this, netMessage);
} catch (Exception e) {
e.printStackTrace();
}
}
//根据Action对应出相应的方法
public class ActionDefinition {
//对应的方法在哪个类里
private Class<?> klass;
//该action对应的方法
private Method method;
//要反射执行一个方法必须要一个对象
private Object object;
//需要若干个参数，所以需要一个List来存储参数
private List<ActionParameter> parameterList;
ActionDefinition() {
parameterList = new ArrayList<>();
}
List<ActionParameter> getParameterList() {
return parameterList;
}
Class<?> getKlass() {
return klass;
}
void setKlass(Class<?> klass) {
this.klass = klass;
}
Method getMethod() {
return method;
}
/**
* 将包扫描时扫描到的方法设置给该类，并且将该方法的参数保存到List列表里面
* @param method
* @throws Exception
*/
void setMethod(Method method) throws Exception {
this.method = method;
Parameter[] parameters = method.getParameters();
for (int i = 0; i < parameters.length; i++) {
Parameter parameter = parameters[i];
//扫描该方法的注解
//注释Para是否在parameter上，是返回true,否返回false
if (!parameter.isAnnotationPresent(Para.class)) {
throw new Exception("方法[]的第" + (i+1) + "个参数无注解！");
}
Para para = parameter.getAnnotation(Para.class);
parameterList.add(new ActionParameter()
.setName(para.name())
.setType(parameter.getType()));
}
}
Object getObject() {
return object;
}
void setObject(Object object) {
this.object = object;
}
}
//解决action反射对应的方法的参数问题
public class ActionParameter {
//参数名称
private String name;
//参数类型
private Class<?> type;
ActionParameter() {
}
ActionParameter setName(String name) {
this.name = name;
return this;
}
String getName() {
return name;
}
ActionParameter setType(Class<?> type) {
this.type = type;
return this;
}
//将字符串json转换为对象
Object getValue(Gson gson, String json) {
return gson.fromJson(json, type);
}
}
//这里我们需要定义一个接口，给定一个方法
public interface IActionFactory {
String executeRequest(String action, String para) throws Exception;
}
//这和类需要实现上面那个接口，实现定义的方法
public class ActionFactory implements IActionFactory {
private static final Type type;
//map存放的是action所对应的方法名和ActionDefinition对象
private static final Map<String, ActionDefinition> actionMap;
private static final Gson gson;
//静态块是线程安全的
static {
actionMap = new HashMap<>();
//将Map的字符串转换为Map类型所需的类型
type = new TypeToken<Map<String, String>>() {}.getType();
gson = new GsonBuilder().create();
}
//根据包扫描得到想要找的类，然后处理该类
private static void processClass(Class<?> klass) {
try {
//根据类，实例化一个对象
Object object = klass.newInstance();
//得到该类里所有的方法，包括private修饰的方法
Method[] methods = klass.getDeclaredMethods();
for (Method method : methods) {
//如果该方法没有注解，就继续
if (!method.isAnnotationPresent(Actioner.class)) {
continue;
}
//根据注解得到相应的动作
Actioner actioner = method.getAnnotation(Actioner.class);
ActionDefinition ad = new ActionDefinition();
ad.setKlass(klass);
ad.setObject(object);
//保存方法和参数
ad.setMethod(method);
//以action动作为键，以ActionDefinition对象为值保存到Map里
actionMap.put(actioner.action(), ad);
}
} catch (Exception e) {
e.printStackTrace();
}
}
//包扫描方法
public static void scanActioner(String packageName) {
//实例化包扫描那个类
new PackageScanner() {
@Override
public void dealClass(Class<?> klass) {
//包扫描的时候只扫描带有注解的类，其余的类不扫描
if (klass.isInterface() || klass.isPrimitive()
|| klass.isArray() || klass.isAnnotation()
|| klass.isEnum()
|| !klass.isAnnotationPresent(MecAction.class)) {
return;
}
try {
//扫描到该类调用处理类方法
processClass(klass);
} catch (Exception e) {
e.printStackTrace();
}
}
//将要扫描的包当作实参传递过去
}.scannerPackage("com.mec");
}
/**
* 根据action的取值，映射出对应的method
*/
//这里的参数para是一个map,保存了用户的账号和密码，键为参数名，值为对象类型的字符串
@Override
public String executeRequest(String action, String para) throws Exception {
ActionDefinition ad = actionMap.get(action);
if (ad == null) {
throw new Exception("action:[" + action + "]没有配置！");
}
Object object = ad.getObject();
Method method = ad.getMethod();
//用反射机制提供的parameter方法只能得到参数的类型，不能得到参数的名称，因此这里需要对参数另做处理
List<ActionParameter> paras = ad.getParameterList();
//将Map字符串转换成对应的Map类型
Map<String, String> paraMap = gson.fromJson(para, type);
Object result = null;
//反射机制调用无参的方法
if (paras.size() <= 0) {
result = method.invoke(object);
} else {
Object[] values = new Object[paras.size()];
int i = 0;
for (ActionParameter parameter : paras) {
//根据参数名在map里找到字符串类型的参数对象类型的字符串，
//然后利用getValue方法将参数对象类型字符串类型转换为对象，得到该参数值
values[i] = parameter.getValue(gson,
paraMap.get(parameter.getName()));
}
result = method.invoke(object, values);
}
//将反射机制调用执行的方法后的结过通过字符串的形式返回
return gson.toJson(result);
}
}
//带有注解的类和方法，方便包扫描能找到
@MecAction
public class UserAction {
public UserAction() {
}
//给方法带注解
@Actioner(action="login")
public UserModel userLogin(
//给参数带注解
@Para(name="user") String user,
@Para(name="password") String password) {
UserModel stu = new UserModel();
return stu;
}
}
总结
- 上述是解决该问题的核心代码，主要就是通过注解配置将来要执行的方法，然后通过包扫描找到该方法，利用反射机制执行该方法，并且将执行后的结果返回。
- 这种方法主要用于动态的执行未知方法的场景中。
4216
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
