JAVA与.NET的相互调用——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各有不同的特性，双方不可能直接通过的序列化对象来传输信息，常用的信息交换方式有以下三种：

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

服务器端开发

• 通讯契约
  

1. <Contracts> 
2.  
3. <Contract name="GetPersonByAge"> //name为契约名，服务器与客户端必须同时遵守此契约 
4. <Input> 
5. <Description>获取Age等于此值的People对象集</Description> //说明此契约内容 
6. </Input> 
7. <Output> 
8. <Package>Manager</Package> //接收到GetPersonByAge请求时所调用的包名称 
9. <Class>PersonManager</Class> //接收到GetPersonByAge请求时所调用的类名称 
10. <Method>GetListByAge</Method> //接收到GetPersonByAge请求时所调用的处理方法名称 
11. </Output> 
12. </Contract> 
13.  
14. <Contract name="GetPersonByID"> 
15. <Input> 
16. <Description>获取ID等于此值的People对象</Description> 
17. </Input> 
18. <Output> 
19.   <Package >Manager</Package> 
20. <Class>PersonManager</Class> 
21. <Method>GetListByID</Method> 
22. </Output> 
23. </Contract> 
24.  
25. </Contracts> 

• 以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文件和Spring里面的Bean绑定，其意义就是要遵守 DIP依赖倒置原则，实现依赖注入。

• 基本结构

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

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

• JSON数据转换

1. //Contract实体类，包含契约的package,class,method,params等多个属性 
2. package Model; 
3.  
4. import org.json.JSONArray; 
5.  
6. public class Contract { 
7. private String package1; 
8. private String class1; 
9. private String method; 
10. private JSONArray params; 
11. public void setPackage1(String package1) { 
12. this.package1 = package1; 
13. } 
14. public String getPackage1() { 
15. return package1; 
16. } 
17. public void setClass1(String class1) { 
18. this.class1 = class1; 
19. } 
20. public String getClass1() { 
21. return class1; 
22. } 
23. public void setMethod(String method) { 
24. this.method = method; 
25. } 
26. public String getMethod() { 
27. return method; 
28. } 
29. public void setParams(JSONArray params) { 
30. this.params = params; 
31. } 
32. public JSONArray getParams() { 
33. return params; 
34. } 
35.  
36. } 
37.  
38. //把输入的String字符串转化为Contract对象 
39. //在这里使用org.json工具包作为JSON的转化工具，org.json工具包可于以下网址下载http://www.json.org/java/index.html 
40. package Common; 
41. import java.io.File; 
42. import java.io.IOException; 
43. import javax.xml.parsers.DocumentBuilder; 
44. import javax.xml.parsers.DocumentBuilderFactory; 
45. import javax.xml.parsers.ParserConfigurationException; 
46. import Model.Contract; 
47. import org.json.*; 
48. import org.w3c.dom.Document; 
49. import org.w3c.dom.Element; 
50. import org.w3c.dom.NodeList; 
51. import org.xml.sax.SAXException; 
52.  
53. public class Transfer { 
54. private Transfer(){} 
55.  
56. private static String contractName=null; 
57. private static Contract contract=new Contract(); 
58. private static JSONObject jsonObject=null; 
59.  
60. public static Contract GetContract(String data) throws Exception, JSONException, ParserConfigurationException, SAXException, IOException{ 
61. jsonObject=new JSONObject(data); //把字符串转化为JSONOject对象 
62. GetContractName(); //获取契约名称 
63. GetProperty(); //获取契约的package,class,method属性 
64. GetParams(); //获取契约的参数集 
65. return contract; 
66. } 
67.  
68. /* 
69. * 获取契约对应的包名称，类名称，方法名称 
70. */ 
71. private static void GetProperty() throws Exception{ 
72. File file = new File("Contracts.xml"); 
73. DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); 
74. DocumentBuilder builder = factory.newDocumentBuilder(); 
75. Document doc = builder.parse(file); 
76. NodeList nodeList = doc.getElementsByTagName("Contract"); 
77. Element contractElement=null; 
78. for (int i = 0; i < nodeList.getLength(); i++) { 
79. if(nodeList.item(i).getAttributes().item(0).getNodeValue().equals(contractName)){ 
80. contractElement=(Element)nodeList.item(i); 
81. break; 
82. } 
83. } 
84. if(contractElement!=null){ 
85. Element outputElement=(Element)contractElement.getElementsByTagName("Output").item(0); 
86. contract.setPackage1(outputElement.getElementsByTagName("Package").item(0).getTextContent()); 
87. //获取包名称 
88. contract.setClass1(outputElement.getElementsByTagName("Class").item(0).getTextContent()); 
89. //获取类名称 
90. contract.setMethod(outputElement.getElementsByTagName("Method").item(0).getTextContent()); 
91. //获取方法名 
92. } 
93. else 
94. throw new Exception("未能找到对象的契约"); 
95. } 
96.  
97. /* 
98. * 获取契约名称 
99. */ 
100. private static void GetContractName() throws JSONException{ 
101. contractName=jsonObject.getString("ContractName"); 
102. } 
103.  
104. /* 
105. * 获取输入参数 
106. */ 
107. private static void GetParams() throws JSONException{ 
108. contract.setParams(jsonObject.getJSONArray("Params")); 
109. } 
110. } 
111.  
112. //调用Contract对象里面包中的类的某个方法，获取计算结果 
113. package Common; 
114. import java.lang.reflect.Method; 
115. import java.util.HashMap; 
116. import java.util.Map; 
117. import org.json.JSONArray; 
118. import Model.*; 
119.  
120. public class Implement { 
121. private Contract contract; 
122. private String fullName; 
123. private static Map<String,Object> objects=new HashMap<String,Object>(); //保存对象实体 
124. private static Map<String,Class> classes=new HashMap<String,Class>(); //保存类名 
125.  
126. /* 
127. * 先获取对应的对象，再用反射模式调用对象的方法，获取计算结果 
128. */ 
129. public Object GetResult(Contract contract){ 
130. this.contract=contract; 
131. this.fullName=contract.getPackage1()+"."+contract.getClass1(); 
132.  
133. try { 
134. Object manager=GetObject(); 
135. Class theClass=classes.get(fullName); 
136. Method method=theClass.getDeclaredMethod(contract.getMethod(),JSONArray.class); 
137. return method.invoke(manager, contract.getParams()); 
138. } catch (Exception e) { 
139. // TODO Auto-generated catch block 
140. e.printStackTrace(); 
141. return null; 
142. } 
143. } 
144.  
145. /* 
146. * 多次使用反射创建获取对象会损耗一定性能，所以此处使用单体模式获取对应的对象 
147. */ 
148. private Object GetObject() throws InstantiationException, IllegalAccessException, ClassNotFoundException{ 
149. if(!objects.containsKey(fullName)){ 
150. Class theClass = Class.forName(fullName); 
151. classes.put(fullName,theClass); 
152. Object manager=theClass.newInstance(); 
153. objects.put(fullName, manager); 
154. } 
155. return objects.get(fullName); 
156. } 
157. } 
158.  
159. //直接把接收到的二进制数据转换成String，然后通过Transfer把String转化为Contract对象，最后通过Implement获取运算结果 
160. package Common; 
161.  
162. import java.io.DataInputStream; 
163. import Model.Contract; 
164.  
165. public class InputControl { 
166. private DataInputStream inputStream; 
167.  
168. public InputControl(DataInputStream inputStream){ 
169. this.inputStream=inputStream; 
170. } 
171. /* 
172. * 直接把接收到的二进制数据转换成String，然后通过Transfer把String转化为Contract对象，最后通过Implement对象获取运算结果 
173. */ 
174. public Object GetResult(){ 
175. byte[] byteMessage=new byte[1024]; //在此处只获取测试数据，在真正运行时应使用分批缓存的方式 
176. try{ 
177. int n=inputStream.read(byteMessage); 
178. String message=new String(byteMessage,"ASCII"); 
179. Contract contract=Transfer.GetContract(message); 
180. Implement implement=new Implement(); 
181. Object result=implement.GetResult(contract); 
182. return result; 
183. } 
184. catch(Exception ex){ 
185. ex.printStackTrace(); 
186. return null; 
187. } 
188. } 
189. } 

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

1. //把计算结果返回到客户端 
2. package Common; 
3.  
4. import java.io.DataOutputStream; 
5.  
6. public class OutputControl { 
7. private DataOutputStream outputStream; 
8.  
9. public OutputControl(DataOutputStream outputStream){ 
10. this.outputStream=outputStream; 
11. } 
12.  
13. public void Output(Object data){ 
14. try{ 
15. outputStream.writeBytes(data.toString()); 
16. outputStream.flush(); 
17. }catch(Exception ex){ 
18. ex.printStackTrace(); 
19. } 
20. } 
21. } 
22.  
23. //运行系统进行测试 
24. package Common; 
25.  
26. import java.io.*; 
27. import java.net.*; 
28.  
29. public class Program { 
30. private static ServerSocket serverSocket; 
31.  
32. public static void main(String[] args) throws ClassNotFoundException { 
33. // TODO Auto-generated method stub 
34. Socket socket; 
35. try { 
36. serverSocket=new ServerSocket(5100); //激活5100端口 
37. while(true){ //循环捕捉请求 
38. socket=serverSocket.accept(); 
39. DataOutputStream outStream=new DataOutputStream(socket.getOutputStream()); //获取DataOutputStream输出流 
40. DataInputStream inputStream=new DataInputStream(socket.getInputStream()); //获取DataInputStream输入流 
41.  
42. //调用InputControl对象获取运算结果 
43. InputControl inputControl=new InputControl(inputStream); 
44. Object result=inputControl.GetResult(); 
45. //调用OutputControl对象输入运算结果 
46. OutputControl outputControl=new OutputControl(outStream); 
47. outputControl.Output(result); 
48. } 
49. } catch (Exception e) { 
50. // TODO Auto-generated catch block 
51. e.printStackTrace(); 
52. } 
53. } 
54. } 

• 逻辑转换层

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

1. //设置Person对象 
2. package Model; 
3.  
4. public class Person { 
5. private int id; 
6. private String name; 
7. private int age; 
8. public void setId(int id) { 
9. this.id = id; 
10. } 
11. public int getId() { 
12. return id; 
13. } 
14. public void setName(String name) { 
15. this.name = name; 
16. } 
17. public String getName() { 
18. return name; 
19. } 
20. public void setAge(int age) { 
21. this.age = age; 
22. } 
23. public int getAge() { 
24. return age; 
25. } 
26. } 
27.  
28. //开发PersonManager 
29. package Manager; 
30. import java.util.ArrayList; 
31. import java.util.List; 
32. import org.json.JSONArray; 
33. import org.json.JSONException; 
34. import Model.*; 
35.  
36. public class PersonManager { 
37. /* 
38. * 测试数据 
39. */ 
40. private List<Person> GetList(){ 
41. List<Person> personList=new ArrayList<Person>(); 
42. Person person1=new Person(); 
43. person1.setId(0); 
44. person1.setAge(23); 
45. person1.setName("Mike"); 
46. personList.add(person1); 
47.  
48. Person person2=new Person(); 
49. person2.setId(1); 
50. person2.setAge(29); 
51. person2.setName("Leslie"); 
52. personList.add(person2); 
53.  
54. Person person3=new Person(); 
55. person3.setId(2); 
56. person3.setAge(21); 
57. person3.setName("Jack"); 
58. personList.add(person3); 
59.  
60. Person person4=new Person(); 
61. person4.setId(3); 
62. person4.setAge(23); 
63. person4.setName("Rose"); 
64. personList.add(person4); 
65. return personList; 
66. } 
67.  
68. /* 
69. * 获取年龄等于age参数的Person，因为数据将返还给客户端，所以这时把输出数据转化为JSONArray 
70. */ 
71. public JSONArray GetListByAge(JSONArray jsonList) throws JSONException{ 
72. int age=jsonList.getInt(0); //因为输入参数为一个集合params，所以即使只包括一个参数，也是通过要jsonList的第一个参数来获取的。 
73. List<Person> personList=GetList(); 
74. List<Person> resultList=new ArrayList<Person>(); 
75.  
76. for(int n=0;n<personList.size();n++){ 
77. if(personList.get(n).getAge()==age) 
78. resultList.add(personList.get(n)); 
79. } 
80.  
81. JSONArray jsonArray=new JSONArray(resultList); 
82. return jsonArray; 
83. } 
84. } 

然后在Contracts.xml设置绑定

1. <Contracts> 
2. <Contract name="GetPersonByAge"> //契约名称 
3. <Input> 
4. <Description>获取Age等于此值的People对象集</Description> //文字说明 
5. </Input> 
6. <Output> 
7. <Package>Manager</Package> //绑定包 
8. <Class>PersonManager</Class> //绑定类 
9. <Method>GetListByAge</Method> //绑定处理方法 
10. </Output> 
11. </Contract> 
12. </Contracts> 

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

客户端开发

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

1. namespace Model 
2. { 
3. [DataContract] 
4. public class MessageEntity 
5. { 
6. //契约名称 
7. [DataMember] 
8. public string ContractName 
9. { 
10. get; 
11. set; 
12. } 
13.  
14. //注意参数使用集合的方式来传送 
15. [DataMember] 
16. public IList<Object> Params 
17. { 
18. get; 
19. set; 
20. } 
21. } 
22. } 

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

1. using System; 
2. using System.Collections.Generic; 
3. using System.Linq; 
4. using System.Text; 
5. using System.Net.Sockets; 
6. using System.Runtime.Serialization.Json; 
7. using System.IO; 
8. using System.Threading; 
9. using Model; 
10. using Newtonsoft.Json; 
11.  
12. namespace Common 
13. { 
14. public class MessageManager 
15. { 
16. private static TcpClient _tcpClient; 
17.  
18. //设置tcpClient对象 
19. public static TcpClient TcpClient 
20. { 
21. set { _tcpClient = value; } 
22. } 
23.  
24. //此处只使用静态方法实现数据传送，发送请求后使用Thread.Sleep等待运算结果，这样存在一定风险，也会降低效率 
25. //在大型的开发当中应该进一步改善，把信息发送与信息接收分开处理 
26. public static object GetMessage(MessageEntity message, Type type) 
27. { 
28. NetworkStream networkStream = _tcpClient.GetStream(); 
29. //利用DataContractJsonSerializer将MessageEntity对象实现序列化，发送到服务器 
30. DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(MessageEntity)); 
31. lock (networkStream) 
32. { 
33. jsonSerializer.WriteObject(networkStream, message); 
34. networkStream.Flush(); 
35. } 
36. Thread.Sleep(500); 
37.  
38. //获取回传信息，这里设置接收值1024个字节 
39. //在实际的开发当中应该使用分批缓存的方式实现数据接收 
40. byte[] messageByte = new byte[1024]; 
41. int n = 0; 
42. lock (networkStream) 
43. n = networkStream.Read(messageByte, 0, 1024); 
44. if (n == 0) 
45. return null; 
46.  
47. //根据输入的type对象，把二进制信息转化为对应的对象 
48. string jsonMessage = Encoding.ASCII.GetString(messageByte); 
49. //利用Netonsoft.Json工具集将获取的JSON数据转化对象 
50. object returnValue = JavaScriptConvert.DeserializeObject(jsonMessage, type); 
51. return returnValue; 
52. } 
53. } 
54. } 

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

1. using System; 
2. using System.Collections.Generic; 
3. using System.Text; 
4. using Model; 
5. using Common; 
6.  
7. namespace DAL 
8. { 
9. public class PersonDAL 
10. { 
11. /// <summary> 
12. /// 建立MessageEntity对象，注意输入额定契约名称及数据参数，获取查询结果 
13. /// </summary> 
14. /// <param name="age">Person的年龄</param> 
15. /// <returns>获取年龄等于此值的Person对象集</returns> 
16. public IList<Person> GetPersonByAge(int age) 
17. { 
18. //先建立一个MessageEntity对象，设定其ContractName及参数集合 
19. //注意ContractName的值必须与服务器端Contracts.xml文件中Contract 项的 name 特性相对应 
20. MessageEntity messageEntity = new MessageEntity(); 
21. messageEntity.ContractName = "GetPersonByAge"; 
22. messageEntity.Params = new List<Object> { age }; 
23. //调用MessageManager的GetMessage方法获取计算结果 
24. IList<Person> personList = (List<Person>)MessageManager.GetMessage(messageEntity, typeof(List<Person>)); 
25. return personList; 
26. } 
27. } 
28. } 

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

测试

1. Person实体例 
2. namespace Model 
3. { 
4. public class Person 
5. { 
6. private int _id; 
7. private string _name; 
8. private int _age; 
9.  
10. public int id 
11. { 
12. get { return _id; } 
13. set { _id = value; } 
14. } 
15.  
16. public int age 
17. { 
18. get { return _age; } 
19. set { _age = value; } 
20. } 
21.  
22. public string name 
23. { 
24. get { return _name; } 
25. set { _name = value; } 
26. } 
27.  
28. } 
29. } 
30.  
31. 直接调用DAL层 
32. namespace BLL 
33. { 
34. public class PersonBLL 
35. { 
36. private PersonDAL personDal; 
37.  
38. public PersonBLL() 
39. { 
40. personDal = new PersonDAL(); 
41. } 
42.  
43. public IList<Person> GetPersonByAge(int age) 
44. { 
45. IList<Person> personList=personDal.GetPersonByAge(age); 
46. if (personList.Count != 0) 
47. return personList; 
48. else 
49. return new List<Person>(); 
50. } 
51. } 
52. } 
53.  
54. 测试 
55. class Program 
56. { 
57. private static TcpClient tcpClient = new TcpClient(); 
58.  
59. static void Main(string[] args) 
60. { 
61. tcpClient.Connect("127.0.0.1", 5100); 
62. MessageManager.TcpClient = tcpClient; 
63.  
64. PersonBLL personBll = new PersonBLL(); 
65. IList<Person> personList=personBll.GetPersonByAge(23); 
66. if (personList.Count != 0) 
67. Console.WriteLine(personList.Count.ToString()); 
68. Console.ReadKey(); 
69. } 
70. }
    

注意测试是输入的查询条件转换成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项目，再加入原代码即可以成功运行）

下载

JAVA与.NET的相互调用——利用JNBridge桥接模式实现远程通讯
JAVA与.NET的相互调用——TCP/IP套接字相互调用的基本架构（附原代码）
JAVA与.NET的相互调用——通过Web服务实现相互调用（附原代码）

对JAVA与.NET开发有兴趣的朋友欢迎加入QQ群：59557329