通过spring来配置某个命令号和执行方法之间的映射

整理的内容

1.手动获取spring的ApplicationContext和bean对象

写一个工具类实现ApplicationContextAware接口

2.反射的知识整理

3.前后端协议交互的时使用命令号，可以方便调用后端的执行方法

定义一个对象：ActionDefine，表示消息编号与消息处理类的映射定义

package com.youxigu.dynasty2.core.flex;

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

import com.youxigu.dynasty2.util.StringUtils;
import com.youxigu.wolf.net.codec.IAMF3Message;

/**
 * 消息编号与消息处理类的映射定义
 *
 * @author Administrator
 *
 */
public class ActionDefine {
    /**
     * 消息编号
     */
    private int cmd;

    /**
     * 消息处理类
     */
    private Object bean;
    /**
     * 消息处理类的处理方法
     */
    private String methodName;

    /**
     * 传入参数的类型
     */
    private Class<? extends IAMF3Message> inParmClass;

    /**
     * 返回参数的类型
     */
    private Class<? extends IAMF3Message> outParmClass;

    /**
     * 缓存Method实例，避免每次都查找Method
     */
    private transient Method method;
    private transient Method prevMethod;

    public Method getMethod() {
        return method;
    }

    public void setMethod(Method method) {
        this.method = method;
    }

    public Method getPrevMethod() {
        return prevMethod;
    }

    public void setPrevMethod(Method prevMethod) {
        this.prevMethod = prevMethod;
    }

    public int getCmd() {
        return cmd;
    }

    public void setCmd(int cmd) {
        this.cmd = cmd;
    }

    public Object getBean() {
        return bean;
    }

    public void setBean(Object bean) {
        this.bean = bean;
    }

    public String getMethodName() {
        return methodName;
    }

    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }

    public Class<? extends IAMF3Message> getInParmClass() {
        return inParmClass;
    }

    public void setInParmClass(Class<? extends IAMF3Message> inParmClass) {
        this.inParmClass = inParmClass;
    }

    public Class<? extends IAMF3Message> getOutParmClass() {
        return outParmClass;
    }

    public void setOutParmClass(Class<? extends IAMF3Message> outParmClass) {
        this.outParmClass = outParmClass;
    }

}

spring配置文件中增加配置

<beans xmlns="http://www.springframework.org/schema/beans"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:aop="http://www.springframework.org/schema/aop"
         xmlns:tx="http://www.springframework.org/schema/tx"
         xmlns:flex="http://www.springframework.org/schema/flex"
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
           http://www.springframework.org/schema/flex http://www.springframework.org/schema/flex/spring-flex-1.0.xsd">
    <!-- 11001命令代表要执行friendAction类中findUser方法-->
    <bean class="com.youxigu.dynasty2.core.flex.ActionDefine">
       <property name="cmd" value="11001"/>
       <property name="bean" ref="friendAction"/>
       <property name="methodName" value="findUser"/>
    </bean>

    <!-- 申请好友-11002-->
    <bean class="com.youxigu.dynasty2.core.flex.ActionDefine">
       <property name="cmd" value="11002"/>
       <property name="bean" ref="friendAction"/>
       <property name="methodName" value="appFriend"/>
    </bean>

     ...略

</beans>

手动初始化所有的actio定义，创建cmd和method的映射

实现类接口ApplicationContextAware 就要实现他的方法setApplicationContext(ApplicationContext ctx)

package com.youxigu.dynasty2.core.protobuf;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeoutException;

import org.apache.mina.core.session.IoSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

import com.google.protobuf.Message;
import com.manu.core.ServiceLocator;
import com.youxigu.dynasty2.chat.EventMessage;
import com.youxigu.dynasty2.chat.MessageFilter;
import com.youxigu.dynasty2.chat.MessageFilter.FilterMessages;
import com.youxigu.dynasty2.chat.client.IChatClientService;
import com.youxigu.dynasty2.core.flex.ActionDefine;
import com.youxigu.dynasty2.core.flex.amf.AMF3WolfService;
import com.youxigu.dynasty2.core.flex.amf.IAMF3Action;
import com.youxigu.dynasty2.user.service.IAccountService;
import com.youxigu.dynasty2.util.BaseException;
import com.youxigu.wolf.net.IInitListener;
import com.youxigu.wolf.net.IWolfService;
import com.youxigu.wolf.net.OnlineUserSessionManager;
import com.youxigu.wolf.net.Response;
import com.youxigu.wolf.net.ResultMgr;
import com.youxigu.wolf.net.SocketContext;
import com.youxigu.wolf.net.SyncWolfTask;
import com.youxigu.wolf.net.UserSession;

/**
 * 接收并处理所有Flex客户端的请求
 *
 * @author Administrator
 *
 */
public class ProtobufWolfService implements IWolfService, IInitListener, ApplicationContextAware {

    public static Logger log = LoggerFactory.getLogger(AMF3WolfService.class);

    private Map<Integer, ActionDefine> actions = new HashMap<Integer, ActionDefine>();
    private List<ActionDefine> actionDefines;

    public void setActionDefines(List<ActionDefine> actionDefines) {
        this.actionDefines = actionDefines;
    }

    @Override
    public void setApplicationContext(ApplicationContext ctx) throws BeansException {
        if (actionDefines == null) {
            actionDefines = new ArrayList<ActionDefine>();

            while (ctx != null) {
                //遍历所有的配置文件
                //取出bean的类型为ActionDefine的所有bean
                Map<String, ActionDefine> maps = ctx.getBeansOfType(ActionDefine.class);
                if (maps.values() != null && maps.values().size() > 0) {
                    actionDefines.addAll(maps.values());
                }
                ctx = ctx.getParent();

            }
        }
        if (actionDefines != null) {
            // 初始化ActionDefine
            //声明方法的传入值类型数组，后面会强制修改
            Class[] paramsType = { Object.class, Response.class };
            for (ActionDefine ad : actionDefines) {
                int cmd = ad.getCmd();//命令号
                if (actions.containsKey(cmd)) {
                    throw new BaseException("重复的命令号:" + cmd);
                }
                if (ad.getSubActionIds() == null) {try {
                        //用方法名和传入值类型反射取到方法声明
                        Method m = ad.getBean().getClass().getDeclaredMethod(ad.getMethodName(), paramsType);
                        ad.setMethod(m);//有了method声明就可以invoke来调用方法了
                        String beforeMethodName = ad.getPrevMethodName();
                        if (beforeMethodName != null && !"".equals(beforeMethodName)) {
                            m = ad.getBean().getClass().getDeclaredMethod(beforeMethodName, paramsType);
                            ad.setPrevMethod(m);
                        }

                    } catch (NoSuchMethodException e) {
                        e.printStackTrace();
                        log.error("action mapping is error : cmd={}", cmd);
                    }
                }
                actions.put(cmd, ad);
            }
            actionDefines.clear();
            actionDefines = null;
        }
    }

    public void init() {

    }

    @Override
    public Object handleMessage(Response response, Object message) {
        if (message instanceof com.google.protobuf.Message) {
            com.google.protobuf.Message params = (com.google.protobuf.Message) message;
            try {
                //用名称反射取得字段声明
                Field cmdF = params.getClass().getDeclaredField("cmd_");
                if(cmdF != null) {
                    cmdF.setAccessible(true);
                    //用Filed取得字段值
                    int cmd_ = cmdF.getInt(params);

                    //取得缓存中方法声明
                    ActionDefine ad = actions.get(cmd_);
                    Method m = null;

                    int cmd = ad.getCmd();
                    if (actions != null) {
                        ad = actions.get(cmd);
                        if (ad != null)
                            m = ad.getMethod();
                    }
                    if (m == null) {
                        throw new BaseException("错误的命令号:" + cmd);
                    }

                    //调用方法
                    Object retu_ = m.invoke(ad.getBean(), new Object[] { message, response });

//                    ........
                }

            } catch (Exception e) {
                e.printStackTrace();
            }

        }
        return null;
    }
}