实现两个独立服务器之间的通信

在实施项目的过程中，一个项目一般是不会只是架构在一个服务器上，针对项目的各个部分分布在各自独立的服务器中。

例如手机网游的服务器架构：

     

其中架构这些服务器是一个复杂且技术含量相当高的工作，其中各个服务器之间的通信是一个很重要的部分，登录服务器与游戏服务器，log服务器之间采用socket通信。

而GM服务器与游戏服务器之间的通信科采用Http通信。本文主要介绍GM服务器与游戏服务器之间的跨服通信：

以GM服务器获取游戏服务器中角色的信息的过程为例。

游戏服务器中执行查找角色并返回角色信息的类和方法为：PlayerController.getPlayerInfo(long uid);

那么GM服务器只需通过PostCall(String serverName, String className, String methodName, Map<ClassType,Value> params);方法即可调用游戏服务器的业务逻辑处理.PostCall的过程通过配置表读取serverName的地址，并将类名，方法名和参数名通过ObjectOutStream读到流中发送对应服务器中并接受服务器返回的Object。

PostCall具体实现如下：

        HttpURLConnection conn = null;
        ObjectOutputStream os = null;
        ObjectInputStream in=null;
        try {
            String path = GmtoolXml.getInstance().getServerPath(server);
            System.out.println("connect server: " + server + "  :   " + path);
            List<Map> params = GetParamBuffer();

            URL url = new URL(path);
            conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("POST");
            conn.setReadTimeout(2000);    
            conn.setDoOutput(true);
            
            ByteArrayOutputStream oss = new ByteArrayOutputStream();
            os = new ObjectOutputStream(oss);
            os.writeUTF(className);
            os.writeUTF(methodName);
            os.write(params.size());
            for (int i = 0; i < params.size(); i++) {
                Map param = (Map) params.get(i);
                Object key = param.keySet().toArray()[0];
                os.writeObject(key);
                os.writeObject(param.get(key));
            }
            os.flush();

            OutputStream outStrm = conn.getOutputStream();
            outStrm.write(oss.toByteArray());

            if (conn.getResponseCode() == 500) {
                // DataInputStream di = new
                // DataInputStream(conn.getInputStream());
                // System.out.println(di.readUTF());
                return null;
            } else {
                in = new ObjectInputStream(conn.getInputStream());
                return in.readObject();
            }
        } catch (Exception ex) {
            try {
                in.close();
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            conn.disconnect();
            ex.printStackTrace();
            Logger.getLogger(Net.class.getName()).log(Level.SEVERE, null, ex);
            return null;
        } finally {
            try {
                in.close();
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            conn.disconnect();
        }

至于游戏服务如何来接受和处理GM服务器传递的数据流，你可以使用Netty做架构，启用一个端口用来监听来自GM服务器的请求，解析数据，并执行对应的方法。

以下是我解析来自GM服务器的数据流，并执行对应方法的代码：

public void exec(HttpRequest request, HttpResponse response) {
        // TODO Auto-generated method stub
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        try {
            ChannelBuffer cb = request.getContent();
            byte[] b = cb.array();
            ByteArrayInputStream bis = new ByteArrayInputStream(b);
            ObjectInputStream data = new ObjectInputStream(bis);
            String className = data.readUTF();
            String methodName = data.readUTF();
            int count = data.read();
            Class c = Class.forName(className);
            //#debug
            System.out.println(className + "." + methodName);
            List<Class> cl = new ArrayList<Class>();
            List<Object> vl = new ArrayList<Object>();
            for (int i = 0; i < count ; i++) {
                cl.add((Class) data.readObject());
                vl.add(data.readObject());
            }
            Class[] cls = new Class[cl.size()];
            cl.toArray(cls);
            String mk = toMethodKey(className, methodName, cls);
            Method m = methods.get(mk);
            if (m == null) {
                m = c.getMethod(methodName, cls);
                methods.put(mk, m);
            }
            Object[] values = new Object[vl.size()];
            vl.toArray(values);
            Object o = m.invoke(c, values);
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(o);
            oos.flush();
            response.getContent().writeBytes(bos.toByteArray());
            cl.clear();
            vl.clear();
        } catch (Exception e) {
            e.printStackTrace();
            try {
                response.setStatus(HttpResponseStatus.INTERNAL_SERVER_ERROR);//.setStatus(HttpStatus.SC_INTERNAL_SERVER_ERROR);
                bos = new ByteArrayOutputStream();
                DataOutputStream dos = new DataOutputStream(bos);
                dos.writeUTF(e.getClass() + "." + e.getMessage());
                bos.flush();
                response.getContent().writeBytes(bos.toByteArray());
                bos.close();
            } catch (IOException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
        } finally {
            if (oos != null)
                try {
                    oos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
        }
    }

本人技术水平不足，希望各位朋友予以指点，共同进步，Eamil:zhong678*yeah.net , QQ:982925115