Java Socket编程如何建立两者关系

事实上网络编程简单的理解就是两台计算机相互通讯数据而已.对于程序员而言,去掌握一种编程接口并使用一种编程模型相对就会显得简单的多了.Java SDK提供一些相对简单的Api来完成这些工作.Java Socket编程就是其中之一.对于Java而言.这些Api存在与java.net 这个包里面.因此只要导入这个包就可以准备网络编程了.

网络编程的基本模型就是客户机到服务器模型.简单的说就是两个进程之间相互通讯,然后其中一个必须提供一个固定的位置,而另一个则只需要知道这个固定的位置.并去建立两者之间的联系..然后完成数据的通讯就可以了.这里提供固定位置的通常称为服务器,而建立联系的通常叫做客户端.基于这个简单的模型,就可以进入网络编程啦.

Java对这个模型的支持有很多种Api.而这里我只想介绍有关Java Socket编程的编程接口.对于Java而言已经简化了Socket的编程接口.首先我们来讨论有关提供固定位置的服务方是如何建立的.Java提供了ServerSocket来对其进行支持.事实上当你创建该类的一个实力对象并提供一个端口资源你就建立了一个固定位置可以让其他计算机来访问你.ServerSocket server=new ServerSocket(6789);这里稍微要注意的是端口的分配必须是唯一的.因为端口是为了唯一标识每台计算机唯一服务的.另外端口号是从0~65535之间的,前1024个端口已经被Tcp/Ip 作为保留端口,因此你所分配的端口只能是1024个之后的.好了.

我们有了固定位置.现在所需要的就是一根连接线了.该连接线由客户方首先提出要求.因此Java同样提供了一个Java Socket编程对象来对其进行支持.只要客户方创建一个Socket的实例对象进行支持就可以了.Socket client=new Socket(InetAddress.getLocalHost(),5678);客户机必须知道有关服务器的IP地址.对于着一点Java也提供了一个相关的类InetAddress 该对象的实例必须通过它的静态方法来提供.它的静态方法主要提供了得到本机IP 和通过名字或IP直接得到InetAddress的方法.

好了.上面的方法基本可以建立一条连线让两台计算机相互交流了.可是数据是如何传输的呢?事实上I/O操作总是和网络编程息息相关的.因为底层的网络是继续数据的.除非远程调用,处理问题的核心在执行上.否则数据的交互还是依赖于IO操作的.所以你也必须导入java.io这个包.java的IO操作也不复杂.它提供了针对于字节流和Unicode的读者和写者,然后也提供了一个缓冲用于数据的读写.

1. BufferedReader in=new BufferedReader(new InputStream
   Reader(server.getInputStream()));   
2. PrintWriter out=new PrintWriter(server.getOutputStream());  

上面两句就是建立缓冲并把原始的字节流转变为Unicode可以操作.而原始的字节流来源于Java Socket编程的两个方法.getInputStream()和getOutputStream()方.分别用来得到输入和输出.那么现在有了基本的模型和基本的操作工具.我们可以做一个简单的Socket例程了.

服务方:

1. import java.io.*;   
2. import java.net.*;   
3. public class MyServer {   
4. public static void main(String[] args) throws IOException{   
5. ServerSocket server=new ServerSocket(5678);   
6. Socket client=server.accept();   
7. BufferedReader in=new BufferedReader(new InputStreamReader
   (client.getInputStream()));   
8. PrintWriter out=new PrintWriter(client.getOutputStream());   
9. while(true){   
10. String str=in.readLine();   
11. System.out.println(str);   
12. out.println("has receive....");   
13. out.flush();   
14. if(str.equals("end"))   
15. break;   
16. }   
17. client.close();   
18. }   
19. }  

这个Java Socket编程的主要目的在于服务器不断接收客户机所写入的信息只到.客户机发送"End"字符串就退出程序.并且服务器也会做出"Receive"为回应.告知客户机已接收到消息。

Socket通信读取有不少需要我们注意的知识点。当我们在使用的时候有很多的问题摆在我们面前。下面我们就来详细的学习有关Java Socket通信读取的相关代码编写。

以下是Java Socket通信读取的相关代码。

1. import java.io.BufferedReader;  
2. import java.io.BufferedWriter;  
3. import java.io.File;  
4. import java.io.FileWriter;  
5. import java.io.InputStreamReader;  
6. import java.net.URL;public class URLReader {  
7. /**  
8. * @param args  
9. * @throws Exception  
10. */  
11. public static void main(String[] args) throws Exception {  
12. // 声明抛出所有例外  
13. URL tirc = new URL(http://www.sina.com);  
14. File writeFile = new File("d:\\style_1.html");  
15. // 构建一URL对象14100  
16. BufferedReader in = new BufferedReader(new InputStreamReader(tirc.openStream()));  
17. BufferedWriter bos = new BufferedWriter(new FileWriter(writeFile));  
18. //byte[] b=new byte[4096];  
19. String inputLine;  
20. // 使用openStream得到一输入流并由此构造一个BufferedReader对象  
21. while ((ininputLine = in.readLine()) != null){  
22. bos.write(inputLine);  
23. System.out.println(inputLine);  
24. }  
25. bos.flush();  
26. in.close();  
27. bos.close();  
28. }  
29. } 

这就是传说中的Java Socket通信读取相关代码的介绍。

Java Socket线程我们经常会用到的技术，但是有很多程序员还是有不少的使用问题，下面我们就看看如何才能进行有关的代码编写，希望大家又说收获。网络的伟大之一也是信息共享，Server可以主动向所有Client广播消息，同时Client也可以向其它Client发布消息。

下面看看如何开发一个可以实时传递消息的程序。

Java Socket线程的设计原理：

服务器端接受客户端的连接请求，同时启动一个线程处理这个连接，线程不停的读取客户端输入，然后把输入加入队列中，等候处理。在线程启动的同时将线程加入队列中，以便在需要的时候定位和取出。

{源码｝

1. import java.io.*;   
2. import java.net.*;   
3. import java.util.*;   
4. import java.lang.*;   
5. public class Server extends ServerSocket   
6. {   
7. private static ArrayList User_List = new ArrayList();   
8. private static ArrayList Threader = new ArrayList();   
9. private static LinkedList Message_Array = new LinkedList();   
10. private static int Thread_Counter = 0;   
11. private static boolean isClear = true;   
12. protected static final int SERVER_PORT = 10000;   
13. protected FileOutputStream LOG_FILE = new FileOutputStream("d:/connect.log", true);   
14. public Server() throws FileNotFoundException, IOException   
15. {   
16. super(SERVER_PORT);   
17. new Broadcast();   
18. //append connection log   
19. Calendar now = Calendar.getInstance();   
20. String str = "[" + now.getTime().toString() + "] Accepted a connection1512";   
21. byte[] tmp = str.getBytes();   
22. LOG_FILE.write(tmp);   
23. try   
24. {   
25. while (true)   
26. {   
27. Socket socket = accept();   
28. new CreateServerThread(socket);   
29. }   
30. }   
31. finally   
32. {   
33. close();   
34. }   
35. }   
36. public static void main(String[] args) throws IOException   
37. {   
38. new Server();   
39. }   
40. //--- Broadcast   
41. class Broadcast extends Thread   
42. {   
43. public Broadcast()   
44. {   
45. start();   
46. }   
47. public void run()   
48. {   
49. while (true)   
50. {   
51. if (!isClear)   
52. {   
53. String tmp = (String)Message_Array.getFirst();   
54. for (int i = 0; i < Threader.size(); i++)   
55. {   
56. CreateServerThread client = (CreateServerThread)Threader.get(i);   
57. client.sendMessage(tmp);   
58. }  
59. Message_Array.removeFirst();   
60. isClear = Message_Array.size() > 0 ? false : true;   
61. }   
62. }   
63. }   
64. }   
65. //--- CreateServerThread   
66. class CreateServerThread extends Thread   
67. {   
68. private Socket client;   
69. private BufferedReader in;   
70. private PrintWriter out;   
71. private String Username;   
72. public CreateServerThread(Socket s) throws IOException   
73. {   
74. client = s;   
75. in = new BufferedReader(new InputStreamReader(client.getInputStream()));   
76. out = new PrintWriter(client.getOutputStream(), true);   
77. out.println("--- Welcome to this chatroom ---");   
78. out.println("Input your nickname:");   
79. start();   
80. }   
81. public void sendMessage(String msg)   
82. {   
83. out.println(msg);   
84. }   
85. public void run()   
86. {   
87. try   
88. {   
89. int flag = 0;   
90. Thread_Counter++;   
91. String line = in.readLine();   
92. while (!line.equals("bye"))   
93. {   
94. if (line.equals("l"))   
95. {   
96. out.println(listOnlineUsers());   
97. line = in.readLine();   
98. continue;   
99. }   
100. if (flag++ == 0)   
101. {   
102. Username = line;   
103. User_List.add(Username);   
104. out.println(listOnlineUsers());   
105. Threader.add(this);   
106. pushMessage("[< " + Username + " come on in >]");   
107. }   
108. else   
109. {   
110. pushMessage("<" + Username + ">" + line);   
111. }   
112. line = in.readLine();   
113. }   
114. out.println("--- See you, bye! ---");   
115. client.close();   
116. }   
117. catch (IOException e)   
118. {}   
119. finally   
120. {   
121. try   
122. {  
123. client.close();   
124. }   
125. catch (IOException e)   
126. {}   
127. Thread_Counter--;   
128. Threader.remove(this);   
129. User_List.remove(Username);   
130. pushMessage("[< " + Username + " left>]");   
131. }   
132. }   
133. private String listOnlineUsers()   
134. {   
135. String s ="-+- Online list -+-1512";   
136. for (int i = 0; i < User_List.size(); i++)   
137. {   
138. s += "[" + User_List.get(i) + "]1512";   
139. }   
140. s += "-+---------------------+-";   
141. return s;   
142. }   
143. private void pushMessage(String msg)   
144. {   
145. Message_Array.addLast(msg);   
146. isClear = false;   
147. }   
148. }   
149. }  

以上就是对Java Socket线程的详细介绍。这就是程序运行后，多用户登陆并且输入信息后的屏幕。实现了信息的实时广播。用户输入"l"就可以列出在线人员表。

文章来源: aaaedu.blog.csdn.net，作者：tea_year，版权归原作者所有，如需转载，请联系作者。

原文链接：aaaedu.blog.csdn.net/article/details/88093633