JAVA与.NET的相互调用——TCP/IP相互调用基本架构

TCP/IP套接字的概念

　　TCP/IP（传输控制协议/网际协议）是网络互连的通信协议，通过它可以实现各种异构网络或异种机之间的互联通信。TCP/IP是Transmission Control Protocol/Internet Protocol的简写，中文译名为传输控制协议/因特网互联协议，又叫网络通讯协议，这个协议是Internet最基本的协议、Internet国际互联网络的基础，简单地说，就是由网络层的IP协议和传输层的TCP协议组成的。TCP/IP 定义了电子设备（比如计算机）如何连入因特网，以及数据如何在它们之间传输的标准。TCP/IP是一个四层的分层体系结构。高层为传输控制协议，它负责聚集信息或把文件拆分成更小的包。低层是网际协议，它处理每个包的地址部分，使这些包正确的到达目的地。 TCP/IP已成为当今计算机网络最成熟、应用最广的互联协议。Internet采用的就是 TCP/IP协议，网络上各种各样的计算机上只要安装了TCP/IP协议，它们之间就能相互通信。

　　TCP/IP套接字通讯的开发

　　在众多的开发语言中，绝大部分的开发语言都支持TCP/IP协议通讯，开发过程也十分相像，先设置好Socket，然后由客户端发送请求信息，服务器连接客户端接收到请求后再返还信息。而在.NET系统当中则稍有不同，系统把Socket对象包装在TcpClient对象内，对Socket对象的生命周期进行管理。在开发过程当中，服务器与客户端的开发语言有所不同的情况经常发生，服务器是在JDK1.6的环境下进行开发的，客户却要求使用.NET开发客户端，这往往会令开发人员感到困惑！下面在下使用JAVA为服务器，.NET为客户端为例子，为大家介绍一下如何使用TCP/IP协议进行JAVA  .NET之间的相互调用。像TCP/IP实现聊天室这样的例子很多，开发起来也比较简单，因为通讯双方都是使用String来传送信息。而在真正建立ERP、OA、CRM等系统的时候，通讯双方都必须先建立一套统一的通讯契约，才能实现TCP/IP通讯，下面将为大家介绍一个比较典型的企业信息通讯实例。

　　信息传送方式

　　因为.NET与JAVA各有不同的特性，双方不可能直接通过的序列化对象来传输信息，常用的信息交换方式有以下三种：

　　1. 最 笨拙也是最复杂的一种传息方式，就是直接使用“头文件说明+字段属性”的方式。  这是一个既原始又麻烦的通讯方式，因为每个契约都要以二进制的方式发送一个请求，就算是同一类契约，随着参数的不同，每个请求的长度也会发生改变。这样的 传息方式虽然是麻烦，但在不同开发语言相互调用的时候却经常会看到，这可能是因为开发人员对两种开发语言未能完全熟悉，所以倒置使用这最原始最简单的开发 方式。

　　2. 使用XML的信息传送方式，这是最常见，使用最广的信息传递方式。在绝大多数的开发平台都会支持XML，所以XML在Web网络传讯过程中最为常见。但XML最大的一个缺点就是过于堪舆，耗费大量的传输流量。

　　3. 对 于XML的缺点，JSON应运而生而且发展迅速，JSON本是源于Javascript的，多数只用于B/S的页面开发，但随着技术的发展和多个开发语言 的支持，现今到处都可以看JSON的身影。因为JSON既提供一套跨平台的通讯方式，也免去XML复杂特性，受到各类型开发人员的欢迎。

　　服务器端开发

• 通讯契约

　　首先建立一套服务器与客户端同时接受通讯契约, Contract 的name特性是契约的名称，服务器会通过此名称在Contracts.xml文件中找到该契约，然后根据output的package属性，class属性，method属性找到该契约的包名称，类名，调用的方法等属性。

  //name为契约名，服务器与客户端必须同时遵守此契约
  
     获取Age等于此值的People对象集  //说明此契约内容
 
   
   Manager   //接收到GetPersonByAge请求时所调用的包名称
   PersonManager     //接收到GetPersonByAge请求时所调用的类名称
   GetListByAge  //接收到GetPersonByAge请求时所调用的处理方法名称



  
     获取ID等于此值的People对象
 

     Manager
   PersonManager
   GetListByID

• 以JSON方式实现信息传送

　　尽管目前在C/S的开发当中大部分还是使用序列化对象和分节字段的方式进行双方通讯，但在这个实例当中，在下想以JSON通讯方式为例子来实现。首先，客户端会使用额定格式的JSON向服务器发送请求:

{“ContractName”：“GetPeopleByAge”，“Params”：[23]}

　　ContractName代表着契约名称，系统会根据此名称在Contracts.xml文件中找到Name等于GetPeopleByAge的Contract项。然后在对应Output的子项Package,Class,Method中查找到对应的包，类型和方法。

　　Params是客户端传输过来的参数，服务器端会调用对象的方法输入参数23后，得到计算结果，最后把结果返还到客户端。

　　在 这里有两点是值得注意的，第一点是JSON中的契约格式是固定的，服务器与客户端都必须遵守此契约，在ContractName中输入是必须对应的契约名 称，而在Params中输入的必输是一个参数的集合，哪怕里面只包含有一个参数。第二点是在Contracts.xml文件，Output里面的 Package,Class,Method是服务器端自定义的，它只是绑定了服务器端实现GetPersonByAge契约的方法，而这些方法并不是固 定，服务器可以根据系统的需要而修改。这个做法有点像Struts里面的Struts.xml文件,其意义就是在于使服务器的处理方法与客户端发送的请求实现分离。

• 基本结构

　　系统的基本结构如图，客户端会以JSON方式{“ContractName”：“GetPeopleByAge”，“Params”：[23]}发送请求到服务器，服务器会利用“数据转换层”把接收到的请求转换成Contract对象。然后逻辑转换层会根据该Contract对象调用对应的方法，最后把计算结果以JSON方式返回到客户端。

　　注意在服务器与客户端信息交换的过程中，都是使用JSON格式。

• JSON数据转换

　　在服务器端，当接到到客户端请求后，Transfer类负责把接收到的JSON数据转换成Contract对象。在Transfer里面使用org.json工具包作为JSON的转化工具，org.json工具包可于以下网址下载http://www.json.org/java/index.html。

　　而Implement类包含GetResult(Contract contract )方法，其作就是根据contract对象Package，Class，Method等属性，调用“逻辑转换层”的对应方法，最后把计算结果返还给InputControl。

　　服务器端接收请求后就会直接调用InputControl对输入的数据进行处理。

package Model;

import org.json.JSONArray;

  Contract {
     String package1;
     String class1;
     String method;
     JSONArray ;
      setPackage1(String package1) {
        .package1 = package1;
    }
     String getPackage1() {
         package1;
    }
      setClass1(String class1) {
        .class1 = class1;
    }
     String getClass1() {
         class1;
    }
      setMethod(String method) {
        .method = method;
    }
     String getMethod() {
         method;
    }
      setParams(JSONArray ) {
        . = ;
    }
     JSONArray getParams() {
         ;
    }
    
}

package Common;
import java.io.File;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import Model.Contract;
import org.json.*;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

  Transfer {
    Transfer(){}

     String contractName=;
     Contract contract= Contract();
     JSONObject jsonObject=;
   
     Contract GetContract(String data) throws Exception, JSONException, ParserConfigurationException, SAXException, IOException{
       jsonObject= JSONObject(data);         GetContractName();         GetProperty();             GetParams();                contract;
   }
   
   
      GetProperty() throws Exception{
           File file =  File();
           DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
           DocumentBuilder builder = factory.newDocumentBuilder();
           Document doc = builder.parse(file);
           NodeList nodeList = doc.getElementsByTagName();
           Element contractElement=;
            ( i = ; i < nodeList.getLength(); i++) {
               (nodeList.item(i).getAttributes().item().getNodeValue().equals(contractName)){
                   contractElement=(Element)nodeList.item(i);
                   ;
               }
           }
           (contractElement!=){
                  Element outputElement=(Element)contractElement.getElementsByTagName().item();
                  contract.setPackage1(outputElement.getElementsByTagName().item().getTextContent());
                                    contract.setClass1(outputElement.getElementsByTagName().item().getTextContent());
                                    contract.setMethod(outputElement.getElementsByTagName().item().getTextContent());
                             }
           
                 Exception();
   }
   
   
      GetContractName() throws JSONException{
       contractName=jsonObject.getString();
   }
   
   
      GetParams() throws JSONException{
       contract.setParams(jsonObject.getJSONArray());
   }
}

package Common;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import org.json.JSONArray;
import Model.*;

  Implement {
     Contract contract;
     String fullName;
      Map<String,Object> objects= HashMap<String,Object>();       Map<String,Class> classes= HashMap<String,Class>();       
    
     Object GetResult(Contract contract){
        .contract=contract;
        .fullName=contract.getPackage1()++contract.getClass1();    
        
         {
            Object manager=GetObject();
            Class theClass=classes.(fullName);
            Method method=theClass.getDeclaredMethod(contract.getMethod(),JSONArray.);
                method.invoke(manager, contract.getParams());       
        }  (Exception e) {
                          e.printStackTrace();
              ;
         }     
    }
    
    
     Object GetObject() throws InstantiationException, IllegalAccessException, ClassNotFoundException{
        (!objects.containsKey(fullName)){
               Class theClass = Class.forName(fullName);
               classes.put(fullName,theClass);
                Object manager=theClass.newInstance();
                objects.put(fullName, manager);
         }
         objects.(fullName);
    }
}

package Common;
 
import java.io.DataInputStream;
import Model.Contract;

  InputControl {
     DataInputStream inputStream;
    
     InputControl(DataInputStream inputStream){
        .inputStream=inputStream;    
    }
    
     Object GetResult(){
          [] byteMessage= [];            {
               n=inputStream.read(byteMessage);
              String message= String(byteMessage,); 
              Contract contract=Transfer.GetContract(message);
              Implement implement= Implement();
              Object result=implement.GetResult(contract);
               result;
          }
          (Exception ex){
              ex.printStackTrace();
               ;
          }
    }
}

　　最后，系统通过OutputControl类把计算结果返还给客户端。

package Common;

import java.io.DataOutputStream;

  OutputControl {
     DataOutputStream outputStream;
    
     OutputControl(DataOutputStream outputStream){
        .outputStream=outputStream;
    }
    
      Output(Object data){ 
        {
            outputStream.writeBytes(data.toString());
            outputStream.flush();
        }(Exception ex){
            ex.printStackTrace();
        }
    }
}

package Common;

import java.io.*;
import java.net.*;

  Program {
      ServerSocket serverSocket;
    
       main(String[] args) throws ClassNotFoundException {
                Socket socket;
         {       
            serverSocket= ServerSocket();              (){                                      socket=serverSocket.accept();
            DataOutputStream outStream= DataOutputStream(socket.getOutputStream());              DataInputStream inputStream= DataInputStream(socket.getInputStream());               InputControl inputControl= InputControl(inputStream);    
            Object result=inputControl.GetResult();
                        OutputControl outputControl= OutputControl(outStream);
            outputControl.Output(result);
            }
        }  (Exception e) {
                        e.printStackTrace();
         
        }
    } 
}

• 逻辑转换层

　　现在先开发一个例子作为参考，在完成客户端开发的时候就可以进行测试。这个例子是先在Manager包里面设置好一个类PersonManager，PersonManager类中包含一个名为GetListByAge的方法。在Contracts.xml文件设置一个名为GetPersonByAge的契约，客户端就可以通过这个契约在远程调用此方法获取计算结果。

package Model;

  Person {
      id;
     String name;
      age;
      setId( id) {
        .id = id;
    }
      getId() {
         id;
    }
      setName(String name) {
        .name = name;
    }
     String getName() {
         name;
    }
      setAge( age) {
        .age = age;
    }
      getAge() {
         age;
    }
}

package Manager;
import java.util.ArrayList;
import java.util.List;
import org.json.JSONArray;
import org.json.JSONException;
import Model.*;

  PersonManager {
    
     List<Person> GetList(){
        List<Person> personList= ArrayList<Person>();
        Person person1= Person();
        person1.setId();
        person1.setAge();
        person1.setName();
        personList.add(person1);
        
        Person person2= Person();
        person2.setId();
        person2.setAge();
        person2.setName();
        personList.add(person2);
        
        Person person3= Person();
        person3.setId();
        person3.setAge();
        person3.setName();
        personList.add(person3);
        
        Person person4= Person();
        person4.setId();
        person4.setAge();
        person4.setName();
        personList.add(person4);    
         personList;
    }
    
    
     JSONArray GetListByAge(JSONArray jsonList) throws JSONException{
         age=jsonList.getInt();           List<Person> personList=GetList();
        List<Person> resultList= ArrayList<Person>();
        
        ( n=;n<personList.size();n++){
            (personList.(n).getAge()==age)
                resultList.add(personList.(n));
        }
        
        JSONArray jsonArray= JSONArray(resultList);
         jsonArray;
    }
}

　　然后在Contracts.xml设置绑定：

  //契约名称
  
     获取Age等于此值的People对象集  //文字说明
 

   Manager      //绑定包
   PersonManager    //绑定类
   GetListByAge   //绑定处理方法

　　绑定以后，在完成客户端开发的时候就可以进行测试。使用这开发模式的好处在于利用JSON作用数据传输的桥梁，解决不同开发平台之间数据难以同步的问题。使用JSON比XML更容易操作，可以减少传输流量，而且受到各开发语言的支持。使用Contracts.xml在服务器绑定处理方式，使服务器的处理方法与客户端发送的请求实现分离。下面开始介绍一下客户端的开发。

　　客户端开发

　　客户端的开发的开发相对简单，因为契约是使用   {“ContractName”：“GetPeopleByAge”，“Params”：[23]}    JSON方式进行传送，所以先开发一个MessageEntity实体类来承载契约。

 Model
{
    [DataContract]
      MessageEntity
    {
                [DataMember]
          ContractName
        {
            ;
            ;
        }

                [DataMember]
         IList<Object> Params
        {
            ;
            ;
        }
    }
}

　　然后开发一个MessageManager信息管理器来管理契约的传送过程，因为Framework4.0里面，未能对JSON数据中集合的转换提供一个简单函数，所以在MessageManager里面使用了一个Newtonsoft.Json工具包，该工具包里面对JSON的操作有着强大支持，可以在http://www.codeplex.com/官方网站下载：

 System;
 System.Collections.Generic;
 System.Linq;
 System.Text;
 System.Net.Sockets;
 System.Runtime.Serialization.Json;
 System.IO;
 System.Threading;
 Model;
 Newtonsoft.Json;

 Common
{
      MessageManager
    {
          TcpClient _tcpClient;

                  TcpClient TcpClient
        {
             { _tcpClient = value; }
        }

                   GetMessage(MessageEntity message, Type type)
        {
            NetworkStream networkStream = _tcpClient.GetStream();
                        DataContractJsonSerializer jsonSerializer =  DataContractJsonSerializer((MessageEntity));
             (networkStream)
            {
                jsonSerializer.WriteObject(networkStream, message);
                networkStream.Flush();
            }
            Thread.Sleep();

                        [] messageByte =  [];
             n = ;
             (networkStream)
                n = networkStream.Read(messageByte, , );
             (n == )
                 ;

                         jsonMessage = Encoding.ASCII.GetString(messageByte);
                         returnValue = JavaScriptConvert.DeserializeObject(jsonMessage, type);
             returnValue;
        }
    }
}

　　下面开发一个GetPersonByAge 契约作为例子：

 System;
 System.Collections.Generic;
 System.Text;
 Model;
 Common;

 DAL
{
      PersonDAL
    {
                 IList<Person> GetPersonByAge( age)
        {
                        MessageEntity messageEntity =  MessageEntity();
            messageEntity.ContractName = ;
            messageEntity.Params =  List<Object> { age };
                        IList<Person> personList = (List<Person>)MessageManager.GetMessage(messageEntity, (List<Person>));
             personList;
        }
    }
}

　　PersonDAL类中的GetPersonByAge方法就是把契约封装在MessageEntity当中，再利用MessageManager把契约发送到服务器端获取运行结果，然后把结果转换为JSON，最后利用Netonsoft.Json工具集的JavaScriptConvert类，把JSON转换成Person对象。

　　测试

 Model
{
      Person
    {
          _id;
          _name;
          _age;
 
          id
        {
             {  _id; }
             { _id = value; }
        }
      
          age
        {
             {  _age; }
             { _age = value; }
        }
       
          name
        {
             {  _name; }
             { _name = value; }
        }

    }
}

　　直接调用DAL层

  BLL
{
      PersonBLL
    {
         PersonDAL personDal;

         PersonBLL()
        {
            personDal =  PersonDAL();
        }

         IList<Person> GetPersonByAge( age)
        {
            IList<Person> personList=personDal.GetPersonByAge(age);
             (personList.Count != )
                 personList;
            
                  List<Person>();
        }
    }
}

　　测试

 Program
{
      TcpClient tcpClient =  TcpClient();

      Main([] args)
    {
        tcpClient.Connect(, );
        MessageManager.TcpClient = tcpClient;

        PersonBLL personBll =  PersonBLL();
        IList<Person> personList=personBll.GetPersonByAge();
         (personList.Count != )
        Console.WriteLine(personList.Count.ToString());
        Console.ReadKey();
    }
}

　　注意测试是输入的查询条件转换成JSON后是  {“ContractName”：“GetPeopleByAge”，“Params”：[23]}，而这种  “ContractName":  "契约名"，"Params": {参数，参数，...}    传送格式是固定不可改变的。当获取查询结果  "[{\"id\":0,\"age\":23,\"name\":\"Mike\"},{\"id\":3,\"age\":23,\"name\":\"Rose\"}] 后 ，MessageManager将通过Newtonsoft.Json把返还值转换为List<Person>。

　　到此处，在下为大家介绍了利用JSON数据实现JAVA与.NET之间TCP/IP相互调用，其实以JSON的方式实现并不是唯一的选择，只是在下想在惯常的用法之上，利用一下这个另类的方法，至于在开发结构上有不够周全的地方敬请各位点评。至于以.NET为服务器，JAVA为客户端的TCP/IP通讯实例与此例子极为相像，在此就不作介绍了。

　　原代码 ： （由于上传空间有限，未能将JAVA项目的.metadata一并上传，请运行时先建立JAVA Project项目，再加入原代码即可以成功运行）下载