JAVA语言程序设计-单Client与Server的单向通信和双向通信
金延鑫 2018-04-04 来源 : 阅读 519 评论 0

摘要:本文主要介绍了JAVA语言程序设计的单Client与Server的单向通信和双向通信,通过实际的案例,让我们从中学到单Client与Server的单向通信和双向通信的精髓所在,让我们在JAVA语言程序设计这条路上走得更远,更加熟练的完成这些代码。

从Console中读取内容:

Java代码  

1. BufferedReader inputReader;    
2. // Alt + Shift + z    try...catch等快捷键    
3. // 从Console读取内容    
4. try {    
5.     inputReader = new BufferedReader(new InputStreamReader(System.in));    
6.     String inputContent;    
7.     while (!(inputContent = inputReader.readLine()).equals("bye")) {    
8.         System.out.println(inputContent);    
9.     }    
10. } catch (Exception e) {    
11.     e.printStackTrace();    
12. }

一.单向通信

        Client -> Server

SocketClient.java

Java代码  

1. import java.io.BufferedReader;  
2. import java.io.BufferedWriter;  
3. import java.io.IOException;  
4. import java.io.InputStreamReader;  
5. import java.io.OutputStreamWriter;  
6. import java.net.Socket;  
7.   
8. public class SocketClient {  
9.   
10.     public static void main(String[] args) {  
11.         SocketClient client = new SocketClient();  
12.         client.start();  
13.     }  
14.   
15.     public void start() {  
16.         BufferedReader inputReader = null;  
17.         BufferedWriter writer = null;  
18.         Socket socket = null;  
19.         // 从Console读取内容    
20.         try {  
21.             socket = new Socket("127.0.0.1", 9898);  
22.             // 从socket进行写入    
23.             writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));  
24.             inputReader = new BufferedReader(new InputStreamReader(System.in));  
25.             String inputContent;  
26.             while (!(inputContent = inputReader.readLine()).equals("bye")) {  
27.                 writer.write(inputContent + "\n");  
28.                 writer.flush();   
29.             }  
30.         } catch (Exception e) {  
31.             e.printStackTrace();  
32.         } finally {  
33.             try {  
34.                 writer.close();  
35.                 inputReader.close();  
36.                 socket.close();  
37.             } catch (IOException e) {  
38.                 e.printStackTrace();  
39.             }  
40.         }  
41.     }  
42. }

SocketServer.java

Java代码  

1. import java.io.BufferedReader;  
2. import java.io.IOException;  
3. import java.io.InputStreamReader;  
4. import java.net.ServerSocket;  
5. import java.net.Socket;  
6.   
7. public class SocketServer {  
8.   
9.     public static void main(String[] args) {  
10.         SocketServer socketServer = new SocketServer();  
11.         socketServer.startServer();  
12.     }  
13.   
14.     public void startServer() {  
15.         ServerSocket serverSocket = null;  
16.         BufferedReader reader = null;  
17.         Socket socket = null;  
18.         try {  
19.             // 端口号只要不冲突就行    
20.             serverSocket = new ServerSocket(9898);  
21.             System.out.println("server started..");  
22.             // 进入阻塞状态,等待客户端接入    
23.             socket = serverSocket.accept();  
24.             System.out.println("client " + socket.hashCode() + " connected");  
25.             // 从socket中读取数据    
26.             reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));  
27.             String receiveMsg;  
28.             while ((receiveMsg = reader.readLine()) != null) { // 以"\n"结束    
29.                 System.out.println(receiveMsg);  
30.             }  
31.         } catch (Exception e) {  
32.             e.printStackTrace();  
33.         } finally {  
34.             try {  
35.                 reader.close();  
36.                 socket.close();  
37.                 serverSocket.close();  
38.             } catch (IOException e) {  
39.                 e.printStackTrace();  
40.             }  
41.         }  
42.     }  
43. }

 

二.Client Server双向通信

        即时接受消息,也就是所谓的长连接,记得要先启动Server。

SocketClient2.java

Java代码  

1. import java.io.BufferedReader;  
2. import java.io.BufferedWriter;  
3. import java.io.IOException;  
4. import java.io.InputStreamReader;  
5. import java.io.OutputStreamWriter;  
6. import java.net.Socket;  
7.   
8. public class SocketClient2 {  
9.   
10.     public static void main(String[] args) {  
11.         SocketClient2 client = new SocketClient2();  
12.         client.start();  
13.     }  
14.   
15.     public void start() {  
16.         BufferedReader inputReader = null;  
17.         // 从socket读取    
18.         BufferedReader reader = null;  
19.         BufferedWriter writer = null;  
20.         Socket socket = null;  
21.         // Alt + Shift + z    try...catch等快捷键    
22.         // 从Console读取内容    
23.         try {  
24.             socket = new Socket("127.0.0.1", 9898);  
25.             // 用于读取服务器返回的数据    
26.             reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));  
27.             // 从socket进行写入    
28.             writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));  
29.             inputReader = new BufferedReader(new InputStreamReader(System.in));  
30.             String inputContent;  
31.             while (!(inputContent = inputReader.readLine()).equals("bye")) {  
32.                 writer.write(inputContent + "\n");  
33.                 writer.flush();  
34.                 //              System.out.println(inputContent);    
35.                 // 服务器返回的数据    
36.                 String response = reader.readLine();  
37.                 System.out.println(response);  
38.             }  
39.         } catch (Exception e) {  
40.             e.printStackTrace();  
41.         } finally {  
42.             try {  
43.                 reader.close();  
44.                 writer.close();  
45.                 inputReader.close();  
46.                 socket.close();  
47.             } catch (IOException e) {  
48.                 e.printStackTrace();  
49.             }  
50.         }  
51.     }  
52. }

SocketServer2.java

Java代码  

1. import java.io.BufferedReader;  
2. import java.io.BufferedWriter;  
3. import java.io.IOException;  
4. import java.io.InputStreamReader;  
5. import java.io.OutputStreamWriter;  
6. import java.net.ServerSocket;  
7. import java.net.Socket;  
8.   
9. public class SocketServer2 {  
10.   
11.     public static void main(String[] args) {  
12.         SocketServer2 socketServer = new SocketServer2();  
13.         socketServer.startServer();  
14.     }  
15.   
16.     public void startServer() {  
17.         ServerSocket serverSocket = null;  
18.         BufferedReader reader = null;  
19.         BufferedWriter writer = null;  
20.         Socket socket = null;  
21.         try {  
22.             // 端口号只要不冲突就行    
23.             serverSocket = new ServerSocket(9898);  
24.             System.out.println("server started..");  
25.             // 进入阻塞状态,等待客户端接入    
26.             socket = serverSocket.accept();  
27.             System.out.println("client " + socket.hashCode() + " connected");  
28.             // 从socket中读取数据    
29.             reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));  
30.             writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));  
31.             String receiveMsg;  
32.             while ((receiveMsg = reader.readLine()) != null) { // 以"\n"结束    
33.                 System.out.println(receiveMsg);  
34.                 writer.write("server reply:" + receiveMsg + "\n");  
35.                 writer.flush();  
36.             }  
37.         } catch (Exception e) {  
38.             e.printStackTrace();  
39.         } finally {  
40.             try {  
41.                 reader.close();  
42.                 writer.close();  
43.                 socket.close();  
44.                 serverSocket.close();  
45.             } catch (IOException e) {  
46.                 e.printStackTrace();  
47.             }  
48.         }  
49.     }  
50. }

 

三.Socket模拟http请求响应(仅模拟)

Java代码  

1. import java.io.BufferedReader;  
2. import java.io.InputStreamReader;  
3. import java.io.PrintStream;  
4. import java.io.PrintWriter;  
5. import java.net.ServerSocket;  
6. import java.net.Socket;  
7. import java.util.Date;  
8. import java.util.Random;  
9.   
10. public class SimpleServer {  
11.     private ServerSocket ss;  
12.     private Socket socket;  
13.     private BufferedReader in;  
14.     private PrintWriter out;  
15.     private Random random = new Random();  
16.   
17.     public SimpleServer() {  
18.         try {  
19.             this.ss = new ServerSocket(9898);  
20.   
21.             System.out.println("The server is waiting your input...");  
22.             for (;;) {  
23.                 this.socket = this.ss.accept();  
24.   
25.                 this.in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));  
26.                 this.out = new PrintWriter(this.socket.getOutputStream(), true);  
27.                 String line = this.in.readLine();  
28.   
29.                 System.out.println("you input is : " + line);  
30.   
31.                 String echo = randomEcho();  
32.                 System.out.println("echo : " + echo);  
33.                 StringBuilder sb = new StringBuilder();  
34.                 sb.append("HTTP/1.1 200 OK").append("\n")  
35.                         .append("Content-Type:application/x-www-form-urlencoded;charset=UTF-8").append("\n")  
36.                         .append("Date:").append(new Date().toString()).append("\n").append("Content-Length:")  
37.                         .append(echo.getBytes().length).append("\n").append("\n").append(echo);  
38.   
39.                 this.out.println(sb.toString());  
40.                 this.out.flush();  
41.   
42.                 this.out.close();  
43.                 this.in.close();  
44.                 this.socket.close();  
45.                 if (line.equalsIgnoreCase("quit") || line.equalsIgnoreCase("exit") || line.equalsIgnoreCase("bye")) {  
46.                     break;  
47.                 }  
48.             }  
49.             this.ss.close();  
50.         } catch (Exception e) {  
51.             e.printStackTrace();  
52.         }  
53.     }  
54.   
55.     private String randomEcho() throws Exception {  
56.         int num = this.random.nextInt();  
57.         StringBuilder sb = new StringBuilder();  
58.         sb.append("respCode=").append("0000").append("&").append("respMsg=").append("随机消息:" + num);  
59.         //    String signature = SignUtil.sign(ResourcesUtils.getInstance().tppPriKey().trim().getBytes("UTF-8"), sb.toString());  
60.         //    sb.append("&").append("signature=").append(signature);  
61.         return sb.toString();  
62.     }  
63.   
64.     public static void main(String[] args) {  
65.         new SimpleServer();  
66.     }  
67. }

 希望这篇文章可以帮助到你,总之同学们,it资讯尽在职坐标。

本文由 @职坐标 发布于职坐标。未经许可,禁止转载。
喜欢 | 0 不喜欢 | 0
看完这篇文章有何感觉?已经有0人表态,0%的人喜欢 快给朋友分享吧~
评论(0)
后参与评论
本文作者 联系TA

擅长与学生或家长及时有效沟通

  • 10
    文章
  • 1964
    人气
  • 91%
    受欢迎度

已有11人表明态度,91%喜欢该老师!

进入TA的空间
名师指导 直通车
  • 索取资料 索取资料 索取资料
  • 答疑解惑 答疑解惑 答疑解惑
  • 技术交流 技术交流 技术交流
  • 职业测评 职业测评 职业测评
  • 面试技巧 面试技巧 面试技巧
  • 高薪秘笈 高薪秘笈 高薪秘笈
TA的其他文章 更多>>
JAVA语言-类和对象
经验技巧 100% 的用户喜欢
匿名对象,内部类,静态内部类,static关键字-JAVA从入门到精通
经验技巧 0% 的用户喜欢
JAVA语言-String类的常用方法
经验技巧 0% 的用户喜欢
JAVA语言-volatile
经验技巧 0% 的用户喜欢
JAVA从入门到精通-抽象类
经验技巧 0% 的用户喜欢
其他海同名师 更多>>
刘新华
刘新华 联系TA
实力型。激情饱满,对专业充满热情
吴翠红
吴翠红 联系TA
独创“教、学、练、测”循环教学模式
吕益平
吕益平 联系TA
熟悉企业软件开发的产品设计及开发
黄泽民
黄泽民 联系TA
擅长javase核心技术
程钢
程钢 联系TA
擅长大型企业商业网站开发和管理
经验技巧30天热搜词 更多>>

您输入的评论内容中包含违禁敏感词

我知道了

助您圆梦职场 匹配合适岗位
验证码手机号,获得海同独家IT培训资料
选择就业方向:
人工智能物联网
大数据开发/分析
人工智能Python
Java全栈开发
WEB前端+H5

请输入正确的手机号码

请输入正确的验证码

获取验证码

您今天的短信下发次数太多了,明天再试试吧!

提交

我们会在第一时间安排职业规划师联系您!

您也可以联系我们的职业规划师咨询:

小职老师的微信号:13167058313
小职老师的微信号:13167058313

版权所有 职坐标-一站式IT培训就业服务领导者 沪ICP备13042190号-4
上海海同信息科技有限公司 Copyright ©2015 www.zhizuobiao.com,All Rights Reserved.
 沪公网安备 31011502005948号    ICP许可  沪B2-20190160

站长统计