Java知识【TCP通信程序】

旧城等待， 2023-10-02 22:07 25阅读 0赞

### 3.TCP通信程序 ###

#### 3.1TCP发送数据【应用】 ####

*  Java中的TCP通信
    
     *  Java对基于TCP协议的的网络提供了良好的封装，使用Socket对象来代表两端的通信端口，并通过Socket产生IO流来进行网络通信。
     *  Java为客户端提供了Socket类，为服务器端提供了ServerSocket类
 *  构造方法
    
    <table> 
     <thead> 
      <tr> 
       <th>方法名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>Socket(InetAddress address,int port)</td> 
       <td>创建流套接字并将其连接到指定IP指定端口号</td> 
      </tr> 
      <tr> 
       <td>Socket(String host, int port)</td> 
       <td>创建流套接字并将其连接到指定主机上的指定端口号</td> 
      </tr> 
     </tbody> 
    </table>
 *  相关方法
    
    <table> 
     <thead> 
      <tr> 
       <th>方法名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>InputStream getInputStream()</td> 
       <td>返回此套接字的输入流</td> 
      </tr> 
      <tr> 
       <td>OutputStream getOutputStream()</td> 
       <td>返回此套接字的输出流</td> 
      </tr> 
     </tbody> 
    </table>
 *  示例代码
    
        public class ClientDemo {
              
            public static void main(String[] args) throws IOException {
              
                //创建客户端的Socket对象(Socket)
                //Socket(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号
                Socket s = new Socket("127.0.0.1",10000);
        
                //获取输出流，写数据
                //OutputStream getOutputStream() 返回此套接字的输出流
                OutputStream os = s.getOutputStream();
                os.write("hello,tcp,我来了".getBytes());
        
                //释放资源
                s.close();
            }
        }

#### 3.2TCP接收数据【应用】 ####

*  构造方法
    
    <table> 
     <thead> 
      <tr> 
       <th>方法名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>ServletSocket(int port)</td> 
       <td>创建绑定到指定端口的服务器套接字</td> 
      </tr> 
     </tbody> 
    </table>
 *  相关方法
    
    <table> 
     <thead> 
      <tr> 
       <th>方法名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>Socket accept()</td> 
       <td>监听要连接到此的套接字并接受它</td> 
      </tr> 
     </tbody> 
    </table>
 *  注意事项
    
    1.  accept方法是阻塞的,作用就是等待客户端连接
    2.  客户端创建对象并连接服务器,此时是通过三次握手协议,保证跟服务器之间的连接
    3.  针对客户端来讲,是往外写的,所以是输出流  
        针对服务器来讲,是往里读的,所以是输入流
    4.  read方法也是阻塞的
    5.  客户端在关流的时候,还多了一个往服务器写结束标记的动作
    6.  最后一步断开连接,通过四次挥手协议保证连接终止
 *  三次握手和四次挥手
    
     *  三次握手

![在这里插入图片描述][17a378b6d06b4518ac1d5adf3f65001d.png]

*  四次挥手
    
    ![f0b1221850084bdfa3ae306afbca3e6b.png][]
 *  示例代码
    
        public class ServerDemo {
              
            public static void main(String[] args) throws IOException {
              
                //创建服务器端的Socket对象(ServerSocket)
                //ServerSocket(int port) 创建绑定到指定端口的服务器套接字
                ServerSocket ss = new ServerSocket(10000);
        
                //Socket accept() 侦听要连接到此套接字并接受它
                Socket s = ss.accept();
        
                //获取输入流，读数据，并把数据显示在控制台
                InputStream is = s.getInputStream();
                byte[] bys = new byte[1024];
                int len = is.read(bys);
                String data = new String(bys,0,len);
                System.out.println("数据是：" + data);
        
                //释放资源
                s.close();
                ss.close();
            }
        }

#### 3.3TCP程序练习【应用】 ####

*  案例需求
    
    客户端：发送数据，接受服务器反馈
    
    服务器：收到消息后给出反馈
 *  案例分析
    
     *  客户端创建对象，使用输出流输出数据
     *  服务端创建对象，使用输入流接受数据
     *  服务端使用输出流给出反馈数据
     *  客户端使用输入流接受反馈数据
 *  代码实现
    
        // 客户端
        public class ClientDemo {
              
            public static void main(String[] args) throws IOException {
              
                Socket socket = new Socket("127.0.0.1",10000);
        
                OutputStream os = socket.getOutputStream();
                os.write("hello".getBytes());
               // os.close();如果在这里关流,会导致整个socket都无法使用
                socket.shutdownOutput();//仅仅关闭输出流.并写一个结束标记,对socket没有任何影响
                
                BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                String line;
                while((line = br.readLine())!=null){
              
                    System.out.println(line);
                }
                br.close();
                os.close();
                socket.close();
            }
        }
        // 服务器
        public class ServerDemo {
              
            public static void main(String[] args) throws IOException {
              
                ServerSocket ss = new ServerSocket(10000);
        
                Socket accept = ss.accept();
        
                InputStream is = accept.getInputStream();
                int b;
                while((b = is.read())!=-1){
              
                    System.out.println((char) b);
                }
        
                System.out.println("看看我执行了吗?");
        
                BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
                bw.write("你谁啊?");
                bw.newLine();
                bw.flush();
        
                bw.close();
                is.close();
                accept.close();
                ss.close();
            }
        }

#### 3.4TCP程序文件上传练习【应用】 ####

*  案例需求
    
    客户端：数据来自于本地文件，接收服务器反馈
    
    服务器：接收到的数据写入本地文件，给出反馈
 *  案例分析
    
     *  创建客户端对象，创建输入流对象指向文件，每读一次数据就给服务器输出一次数据，输出结束后使用shutdownOutput()方法告知服务端传输结束
     *  创建服务器对象，创建输出流对象指向文件，每接受一次数据就使用输出流输出到文件中，传输结束后。使用输出流给客户端反馈信息
     *  客户端接受服务端的回馈信息
 *  相关方法
    
    <table> 
     <thead> 
      <tr> 
       <th>方法名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>void shutdownInput()</td> 
       <td>将此套接字的输入流放置在“流的末尾”</td> 
      </tr> 
      <tr> 
       <td>void shutdownOutput()</td> 
       <td>禁止用此套接字的输出流</td> 
      </tr> 
     </tbody> 
    </table>
 *  代码实现
    
        // 客户端
        public class ClientDemo {
              
            public static void main(String[] args) throws IOException {
              
                Socket socket = new Socket("127.0.0.1",10000);
        
                //是本地的流,用来读取本地文件的.
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream("socketmodule\\ClientDir\\1.jpg"));
        
                //写到服务器 --- 网络中的流
                OutputStream os = socket.getOutputStream();
                BufferedOutputStream bos = new BufferedOutputStream(os);
        
                int b;
                while((b = bis.read())!=-1){
              
                    bos.write(b);//通过网络写到服务器中
                }
                bos.flush();
                //给服务器一个结束标记,告诉服务器文件已经传输完毕
                socket.shutdownOutput();
        
                BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                String line;
                while((line = br.readLine()) !=null){
              
                    System.out.println(line);
                }
                bis.close();
                socket.close();
            }
        }
        // 服务器
        public class ServerDemo {
              
            public static void main(String[] args) throws IOException {
              
                ServerSocket ss = new ServerSocket(10000);
        
                Socket accept = ss.accept();
        
                //网络中的流,从客户端读取数据的
                BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
                //本地的IO流,把数据写到本地中,实现永久化存储
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("socketmodule\\ServerDir\\copy.jpg"));
        
                int b;
                while((b = bis.read()) !=-1){
              
                    bos.write(b);
                }
        
                BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
                bw.write("上传成功");
                bw.newLine();
                bw.flush();
        
                bos.close();
                accept.close();
                ss.close();
            }
        }

#### 3.5TCP程序服务器优化【应用】 ####

*  优化方案一
    
     *  需求
        
        服务器只能处理一个客户端请求，接收完一个图片之后，服务器就关闭了。
     *  解决方案
        
        使用循环
     *  代码实现
        
            // 服务器代码如下,客户端代码同上个案例,此处不再给出
            public class ServerDemo {
                    
                public static void main(String[] args) throws IOException {
                    
                    ServerSocket ss = new ServerSocket(10000);
            
                    while (true) {
                    
                        Socket accept = ss.accept();
            
                        //网络中的流,从客户端读取数据的
                        BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
                        //本地的IO流,把数据写到本地中,实现永久化存储
                        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("optimizeserver\\ServerDir\\copy.jpg"));
            
                        int b;
                        while((b = bis.read()) !=-1){
                    
                            bos.write(b);
                        }
            
                        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
                        bw.write("上传成功");
                        bw.newLine();
                        bw.flush();
            
                        bos.close();
                        accept.close();
                    }
                    //ss.close();
                    
                }
            }
 *  优化方案二
    
     *  需求
        
        第二次上传文件的时候，会把第一次的文件给覆盖。
     *  解决方案
        
        UUID. randomUUID()方法生成随机的文件名
     *  代码实现
        
            // 服务器代码如下,客户端代码同上个案例,此处不再给出
            public class ServerDemo {
                    
                public static void main(String[] args) throws IOException {
                    
                    ServerSocket ss = new ServerSocket(10000);
            
                    while (true) {
                    
                        Socket accept = ss.accept();
            
                        //网络中的流,从客户端读取数据的
                        BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
                        //本地的IO流,把数据写到本地中,实现永久化存储
                        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("optimizeserver\\ServerDir\\" + UUID.randomUUID().toString() + ".jpg"));
            
                        int b;
                        while((b = bis.read()) !=-1){
                    
                            bos.write(b);
                        }
            
                        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
                        bw.write("上传成功");
                        bw.newLine();
                        bw.flush();
            
                        bos.close();
                        accept.close();
                    }
                    //ss.close();
            
                }
            }
 *  优化方案三
    
     *  需求
        
        使用循环虽然可以让服务器处理多个客户端请求。但是还是无法同时跟多个客户端进行通信。
     *  解决方案
        
        开启多线程处理
     *  代码实现
        
            // 线程任务类
            public class ThreadSocket implements Runnable {
                    
                private Socket acceptSocket;
            
                public ThreadSocket(Socket accept) {
                    
                    this.acceptSocket = accept;
                }
              
                @Override
                public void run() {
                    
                    BufferedOutputStream bos = null;
                    try {
                    
                        //网络中的流,从客户端读取数据的
                        BufferedInputStream bis = new BufferedInputStream(acceptSocket.getInputStream());
                        //本地的IO流,把数据写到本地中,实现永久化存储
                        bos = new BufferedOutputStream(new FileOutputStream("optimizeserver\\ServerDir\\" + UUID.randomUUID().toString() + ".jpg"));
            
                        int b;
                        while((b = bis.read()) !=-1){
                    
                            bos.write(b);
                        }
                      
                        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(acceptSocket.getOutputStream()));
                        bw.write("上传成功");
                        bw.newLine();
                        bw.flush();
                    } catch (IOException e) {
                    
                        e.printStackTrace();
                    } finally {
                    
                        if(bos != null){
                    
                            try {
                    
                                bos.close();
                            } catch (IOException e) {
                    
                                e.printStackTrace();
                            }
                        }
            
                        if (acceptSocket != null){
                    
                            try {
                    
                                acceptSocket.close();
                            } catch (IOException e) {
                    
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
            // 服务器代码
            public class ServerDemo {
                    
                public static void main(String[] args) throws IOException {
                    
                    ServerSocket ss = new ServerSocket(10000);
            
                    while (true) {
                    
                        Socket accept = ss.accept();
                        ThreadSocket ts = new ThreadSocket(accept);
                        new Thread(ts).start();
                    }
                    //ss.close();
                }
            }
 *  优化方案四
    
     *  需求
        
        使用多线程虽然可以让服务器同时处理多个客户端请求。但是资源消耗太大。
     *  解决方案
        
        加入线程池
     *  代码实现
        
            // 服务器代码如下,线程任务类代码同上,此处不再给出
            public class ServerDemo {
                    
                public static void main(String[] args) throws IOException {
                    
                    ServerSocket ss = new ServerSocket(10000);
                    ThreadPoolExecutor pool = new ThreadPoolExecutor(
                            3,//核心线程数量
                            10,   //线程池的总数量
                            60,   //临时线程空闲时间
                            TimeUnit.SECONDS, //临时线程空闲时间的单位
                            new ArrayBlockingQueue<>(5),//阻塞队列
                            Executors.defaultThreadFactory(),//创建线程的方式
                            new ThreadPoolExecutor.AbortPolicy()//任务拒绝策略
                    );
            
                    while (true) {
                    
                        Socket accept = ss.accept();
                        ThreadSocket ts = new ThreadSocket(accept);
                        //new Thread(ts).start();
                        pool.submit(ts);
                    }
                    //ss.close();
                }
            }

[17a378b6d06b4518ac1d5adf3f65001d.png]: https://img-blog.csdnimg.cn/17a378b6d06b4518ac1d5adf3f65001d.png
[f0b1221850084bdfa3ae306afbca3e6b.png]: https://img-blog.csdnimg.cn/f0b1221850084bdfa3ae306afbca3e6b.png