【Socket编程】经过Socket实现TCP编程

经过Socket实现TCP编程

Socket通讯 ：

1.TCP协议是面向对象链接、可靠的、有序的，以字节流的方式发送数据。

2.基于TCP协议实现网络通讯的类：

• 客户端----Socket类
• 服务器端----ServerSocket类

1、通讯过程（Socket通讯模型）

Socket通讯模型用下图所示：

 

一、在服务端创建一个ServerSocket,绑定相应的端口，而且在指定的端口进行侦听，等待客户端的链接。

二、当客户端建立链接Socket而且向服务端发送请求。

三、服务器收到请求，而且接受客户端的请求信息。一旦接收到客户端的链接请求后，会建立一个连接socket，用来与客户端的socket进行通讯。 经过相应的输入/输出流进行数据的交换，数据的发送接收以及数据的响应等等。

四、当客户端和服务端通讯完毕后，须要分别关闭socket，结束通讯。

Socket通讯实现步骤：

了解Socket通讯模型后，就能够简化出Socket通讯的实现步骤：

1.建立ServerSocket和Socket

2.打开连接到Socket的输入/输出流

3.按照协议对Socket进行读/写操做

4.关闭输入输出流、关闭Socket

2、Socket和ServerSocket经常使用方法

ServerSocket经常使用方法：

• ServerSocket(int port)——建立并绑定到特定端口的服务器套接字
• accept()——侦听并接受到此套接字的链接
• close()——关闭此套接字 getInetAddress()——获得ServerSocket对象绑定的IP地址。若是ServerSocket对象未绑定IP地址，返回0.0.0.0。
• getLocalPort()——返回此套接字在其上侦听的端口

Socket经常使用方法：

• Socket(InetAddress address, int port)——建立一个套接字并将其链接到指定ip地址的指定端口号
• Socket(String host, int port)——建立一个套接字并将其链接到指定主机上的指定端口号
• close()——关闭此套接字
• getInetAddress()——返回套接字链接的地址
• getInputStream()——返回此套接字的输入流
• getOutputStream——返回此套接字的输出流

3、编程实现基于TCP/IP的用户登陆小程序

经过写一个用户登陆的小程序，来直观了解Socket通讯的工做过程，首先咱们得知道在客户端和服务器通讯时，二者的运做流程是如何的，先从服务器入手。

服务端:

一、建立ServerSocket对象，绑定监听端口

二、经过accept()方法监听客户端请求

三、链接创建后，经过输入流读取客户端发送的请求信息

四、经过输出流向客户端发送响应信息

五、关闭相关资源

那么用户登陆的测试案例的服务器端类能够这样（待完善）：

 1         //1.建立一个服务器端的Socket,即ServerSocket，指定绑定的端口
 2         ServerSocket ss=new ServerSocket(8888);
 3         //2.调用accept方法开始监听，等待客户端的链接
 4         System.out.println("服务器即将启动，等待客户端的链接...");
 5         Socket so=ss.accept();//accept方法返回Socket实例
 6         //3.获取一个输入流，并读取客户端信息
 7         InputStream is=so.getInputStream();//字节输入流
 8         InputStreamReader isr=new InputStreamReader(is);//将字节输入流包装成字符输入流
 9         BufferedReader br=new BufferedReader(isr);//加上缓冲流，提升效率
10         String info=null;
11         while((info=br.readLine())!=null){//循环读取客户端信息
12             System.out.println("我是服务器，客户端说："+info);
13             
14         }
15         so.shutdownInput();//关闭输入流
16         //4.关闭资源
17         br.close();
18         isr.close();
19         is.close();
20         so.close();
21         ss.close();

 

接着咱们看一下客户端的运做过程，其实和服务器端差很少，可是其中的区别仍是要清楚的。

客户端：

一、建立Socket对象，指明须要链接的服务器的地址和端口号

二、链接创建后，经过输出流向服务器端发送请求信息

三、经过输入流获取服务器相应的信息

四、关闭相关资源。

那么用户登陆的测试案例的客户端类能够这样（待完善）：

 1         //1.建立客户端Socket，指定服务器地址和端口
 2         Socket so=new Socket("localhost", 8888);//端口号要和服务器端相同
 3         //2.获取输出流，向服务器端发送登陆的信息
 4         OutputStream os=so.getOutputStream();//字节输出流
 5         PrintWriter pw=new PrintWriter(os);//字符输出流
 6         BufferedWriter bw=new BufferedWriter(pw);//加上缓冲流
 7         bw.write("用户名：admin;密码：123");
 8         bw.flush();
 9         so.shutdownOutput();//关闭输出流
10         //3.关闭资源
11         bw.close();
12         pw.close();
13         os.close();
14         so.close();

 

这样服务端和客户端就能进行最简单的通讯了，目前这个还不能实现交互，下面会讲二者的交互。

运行一下，看看服务器端是否能接收到客户端发送的信息了呢...

分别启动服务器和客户端，注意必须先启动服务器再启动客户端，不然客户端找不到资源报错：

---

完善用户登陆之服务器响应客户端

 在上述的例子中，服务器和客户端仅仅只是相互能够通讯，但服务器对于接收到的客户端信息并无向客户端响应，客户端没有接收到服务器端的任何信息，这明显是不完善不友好的，在这里将对刚刚的例子进行完善，完成服务器对客户端的响应。

修改后的服务器端：

 1     //1.建立一个服务器端的Socket,即ServerSocket，指定绑定的端口
 2             ServerSocket ss= new ServerSocket(8888);
 3             //2.调用accept方法开始监听，等待客户端的链接
 4             System.out.println("服务器即将启动，等待客户端的链接...");
 5             Socket so=ss.accept();//accept方法返回Socket实例
 6             //3.获取一个输入流，并读取客户端信息
 7             InputStream is=so.getInputStream();//字节输入流
 8             InputStreamReader isr=new InputStreamReader(is);//将字节输入流包装成字符输入流
 9             BufferedReader br=new BufferedReader(isr);//加上缓冲流，提升效率
10             String info=null;
11             while((info=br.readLine())!=null){//循环读取客户端信息
12                 System.out.println("我是服务器，客户端说："+info);
13                 
14             }
15             so.shutdownInput();//关闭输入流
16             //4.获取一个输出流，向客户端输出信息,响应客户端的请求
17             OutputStream os=so.getOutputStream();//字节输出流
18             PrintWriter pw=new PrintWriter(os);//字符输出流
19             BufferedWriter bw=new BufferedWriter(pw);//缓冲输出流
20             bw.write("欢迎您！");
21             bw.newLine();
22             bw.flush();
23             
24             //5.关闭资源
25             os.close();
26             pw.close();
27             bw.close();
28             br.close();
29             isr.close();
30             is.close();
31             so.close();
32             ss.close();

修改后的客户端：

 1 //1.建立客户端Socket，指定服务器地址和端口
 2         Socket so=new Socket("localhost", 8888);//端口号要和服务器端相同
 3         //2.获取输出流，向服务器端发送登陆的信息
 4         OutputStream os=so.getOutputStream();//字节输出流
 5         PrintWriter pw=new PrintWriter(os);//字符输出流
 6         BufferedWriter bw=new BufferedWriter(pw);//加上缓冲流
 7         bw.write("用户名：admin;密码：123");
 8         bw.flush();
 9         so.shutdownOutput();//关闭输出流
10         //3.获取输入流，获得服务端的响应信息
11         InputStream is=so.getInputStream();
12         InputStreamReader isr=new InputStreamReader(is);
13         BufferedReader br=new BufferedReader(isr);
14         String info=null;
15         while((info=br.readLine())!=null){
16             System.out.println("我是客户端，服务器说:"+info);
17         }
18                 
19         
20         //4.关闭资源
21         bw.close();
22         pw.close();
23         os.close();
24         so.close();

运行结果：

4、使用多线程实现多客户端的通讯

 应用多线程来实现服务器与多客户端之间的通讯。<关于多线程更多的内容之后再总结>

多线程基本步骤：

1.服务器端建立ServerSocket，循环调用accept()等待客户端链接。

2.客户端建立一个socket并请求和服务器端链接。

3.服务器端接收客户端请求，建立socket与该客户创建专线链接。

4.创建链接的两个socket在一个单独的线程上对话。

5.服务器端继续等待新的链接。

------------------------------------------------------------------------------

下面再将上述的例子修改为多线程的通讯

新建一个服务器线程处理类ServerThread，该类继承Thread类：

 1 /*
 2  * 服务器线程处理类
 3  */
 4 public class ServerThread extends Thread {
 5     // 和本线程相关的Socket
 6     Socket so = null;
 7 
 8     public ServerThread(Socket socket) {// 初始化与本线程相关的Socket
 9         so = socket;
10     }
11 
12     // 线程执行的操做，响应客户端的请求
13     public void run() {// 重写父类的run方法
14         InputStream is = null;
15         InputStreamReader isr = null;
16         BufferedReader br = null;
17         OutputStream os = null;
18         PrintWriter pw = null;
19         BufferedWriter bw = null;
20         try {
21             // 3.获取一个输入流，并读取客户端信息
22             is = so.getInputStream();// 字节输入流
23             isr = new InputStreamReader(is);// 将字节输入流包装成字符输入流
24             br = new BufferedReader(isr);// 加上缓冲流，提升效率
25             String info = null;
26             while ((info = br.readLine()) != null) {// 循环读取客户端信息
27                 System.out.println("我是服务器，客户端说：" + info);
28 
29             }
30             so.shutdownInput();// 关闭输入流
31             // 4.获取一个输出流，向客户端输出信息,响应客户端的请求
32             os = so.getOutputStream();// 字节输出流
33             pw = new PrintWriter(os);// 字符输出流
34             bw = new BufferedWriter(pw);// 缓冲输出流
35             bw.write("欢迎您！");
36             bw.newLine();
37             bw.flush();
38 
39         } catch (IOException e) {
40             // TODO Auto-generated catch block
41             e.printStackTrace();
42         } finally {
43             // 5.关闭资源
44             try {
45                 if (os != null)
46                     os.close();
47                 if (pw != null)
48                     pw.close();
49                 if (bw != null)
50                     bw.close();
51                 if (br != null)
52                     br.close();
53                 if (isr != null)
54                     isr.close();
55                 if (is != null)
56                     is.close();
57                 if (!so.isClosed())
58                     so.close();
59             } catch (IOException e) {
60                 // TODO Auto-generated catch block
61                 e.printStackTrace();
62             }
63         }
64 
65     }
66 }

<解 惑>关闭资源为什么要加一个判断条件：不为空 ？？？

<回 答>这是一种正确、严谨的写法。 验证非NULL是编码中很重要的一环。假如原本就是NULL，这是调用各自的close()方法是会报错的。 若是在实例化这些对象时出错致使这些对象为NULL，或是实例化没问题但中途出了什么异常致使这些对象为NULL，都会在未经验证非NULL前尝试调用close()方法关闭时报错。

<提 示>集中异常处理的快捷键：Alt+shift+z

服务器端：

 1 try {
 2             //1.建立一个服务器端的Socket,即ServerSocket，指定绑定的端口
 3             ServerSocket ss= new ServerSocket(8888);
 4             
 5             System.out.println("服务器即将启动，等待客户端的链接...");
 6             Socket so=null;
 7             //记录客户端的数量
 8             int count=0;
 9             //循环侦听等待客户端的链接
10             while(true){
11                 //2.调用accept方法开始监听，等待客户端的链接
12                  so=ss.accept();//accept方法返回Socket实例
13                  //建立一个新的线程
14                  ServerThread st=new ServerThread(so);
15                  //启动线程，执行与客户端的交互
16                  st.start();//注意是start不是run
17                  count++;
18                  System.out.println("此时客户端数量为："+count);
19                  InetAddress add=so.getInetAddress();
20                  System.out.println("当前客户端的ip地址为"+add.getHostAddress());
21             }
22         } catch (IOException e) {
23             // TODO Auto-generated catch block
24             e.printStackTrace();
25         }

多个客户端的运行结果：

这样一个简单的多线程通讯就完成了，这个多线程还不是并行操做的，要实现并行操做能够按照下面的思路：

主线程负责建立socket

* 一个线程用来读取

* 一个线程用来写入,用两个内部类

* 要用多线程实现，send线程和recived线程同时访问buff数据区。

* 发送完成后notify，接收线程。接收线程自身wait

* 接收的说，我先wait一下，可能缓存中尚未数据，我会拿到空值得。

* 发送的说Ok，我先写，写完了我notifyall你。我就一直锁着，这样默契的合做了。

变成并行处理了 每一个客户端链接服务端都会产生一个新的socket。

< 具体代码还没写，你们能够自行摸索。。。写完了再更新>

 ---------------点击查看更多关于Socket信息------------------