第13章 网络编程

/*****************
***第13章 网络编程
*******知识点:
**************1.基本概念
******************1.1 网络OSI模型
******************1.2 IP地址
******************1.3 端口地址
******************1.4 通讯协议
**************2.Java网络相关类
******************2.1 URLDecoder类
******************2.2 URLEncoder类
******************2.3 URL类
******************2.4 URLConnection 类
******************2.4 Socket类
******************2.5 ServerSocket类
******************2.6 InetAddress类
******************2.7 InetSocketAddress类
******************2.8 DatagramSocket类
******************2.9 DatagramPacket类
******************2.10 MulticastSocket类
******************2.11 ProxySelector类
**************3.UDP通信编程
******************3.1 UDP基本使用
******************3.2 使用DatagramSocket发送、接收数据
******************3.3 使用MulticastSocket实现多点广播
**************4.TCP通信编程
******************4.1 服务器和客户端
******************4.2 TCP基本使用
******************4.3 使用NIO实现非阻塞Socket通信
**************5.代理服务器
******************8.1 直接使用Proxy创建连接
******************8.2 使用ProxySelector选择代理服务器
**************6.常见网络编程异常
*/

public class test13{
    public static void main(String[] args){
        demoBaseInfo();//1.基本概念
        demoRelatedClass();//2.Java网络相关类
        demoUDP();//3.UDP通信编程
        demoTCP();//4.TCP通信编程
        demoProxyServer();//5.代理服务器
        demoCommonException();//6.常见网络编程异常
    }
    
    /*
    *1.基本概念
    */
    public static void demoBaseInfo(){
        /**1.1 网络OSI模型**/
        //网络OSI模型:OSI（Open System Interconnect），即开放式系统互联。是ISO（国际标准化组织）组织在1985年研究的网络互联模型
        //该体系定义了网络互连的七层结构，分别为(从底层到顶层):
        //    1.物理层————物理层是OSI参考模型的最低层，它利用传输介质为数据链路层提供物理连接
        //    2.数据链路层————数据链路层是为网络层提供服务的，解决两个相邻结点之间的通信问题，传送的协议数据单元称为数据帧
        //    3.网络层——————网络层是为传输层提供服务的，传送的协议数据单元称为数据包或分组
        //    4.传输层——————传输层的作用是为上层协议提供端到端的可靠和透明的数据传输服务，包括处理差错控制和流量控制等问题
        //    5.会话层——————会话层主要功能是管理和协调不同主机上各种进程之间的通信（对话），即负责建立、管理和终止应用程序之间的会话
        //    6.表示层——————表示层处理流经结点的数据编码的表示方式问题，以保证一个系统应用层发出的信息可被另一系统的应用层读出
        //    7.应用层——————应用层是OSI参考模型的最高层，是用户与网络的接口
        
        //更多资料参考百度百科或者计算机网络相关书籍  这里就不再详细介绍了
        
        /**1.2 IP地址**/
        //IP————（IP）是Internet Protocol的外语缩写，全称为网络之间互连的协议
        //其中Ip地址分为五类，分别是：
        //    1.A类地址————范围：1.0.0.0---126.0.0.0
        //    2.B类地址————范围：128.0.0.0---191.255.0.0
        //    3.C类地址————范围：192.0.0.0---223.255.255.0
        //    4.D类地址————范围：224.0.0.0---239.255.255.255
        //    5.E类地址————范围：240.0.0.0---255.255.255.254
        
        //IPv6————"Internet Protocol Version 6"的缩写，也被称作下一代互联网协议，用来替代现行的IPv4（现行的IP）协议的一种新的IP协议
        //更多资料参考百度百科或者计算机网络相关书籍  这里就不再详细介绍了
        
        /**1.3 端口号**/
        //端口号————用于区分服务的端口，如TCP/IP协议中的服务端口，端口号的范围从0到65535
        //其中端口号分为有：
        //    1.公认端口————知名端口即众所周知的端口号，范围从0到1023，这些端口号一般固定分配给一些服务 如：21端口分配给FTP(文件传输协议)服务，25端口分配给SMTP（简单邮件传输协议）服务，
        //                                                                                                80端口分配给HTTP服务，135端口分配给RPC（远程过程调用）服务等等
        //    2.注册端口————端口号从1025到49151。它们松散地绑定于一些服务
        //    3.动态/私有端口————动态端口的范围从1024到65535，这些端口号一般不固定分配给某个服务，也就是说许多服务都可以使用这些端口
        //更多资料参考百度百科或者计算机网络相关书籍  这里就不再详细介绍了
        
        /**1.4 通讯协议**/
        //通讯协议——————通信协议又称通信规程，是指通信双方对数据传送控制的一种约定。约定中包括对数据格式，同步方式，传送速度，传送步骤，
　　　　　　　//检纠错方式以及控制字符定义等问题做出统一规定，通信双方必须共同遵守，它也叫做链路控制规程(不要怪我，百科出来滴)
        //常用的协议有：
        //    1.TCp————TCP（Transmission Control Protocol 传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议
        //             会有三次握手。即A->B(发送请求) B->A(回复A) A->B(发送数据)
        //    2.UDP————UDP （User Datagram Protocol 用户数据报协议）是一种无连接、效率高的传输层通信协议
        
        //更多资料参考百度百科或者计算机网络相关书籍  这里就不再详细介绍了
    }
    
    /*
    *2.Java网络相关类
    */
    public static void demoRelatedClass(){
        /**2.1 URLDecoder类**/
        //URLDecoder类————HTML 格式编码的实用工具类。该类包含了将 String 转换为 application/x-www-form-urlencoded MIME 格式的静态方法
        //常用方法有：static String encode(String s, String enc) 参数s是要转换的字符串  参数enc是所支持的字符编码名称
        
        /**2.2 URLEncoder类**/
        //URLEncoder类————HTML 格式编码的实用工具类。该类包含了将 String 转换为 application/x-www-form-urlencoded MIME 格式的静态方法
        //常用方法有：static String encode(String s, String enc) 参数s是要转换的字符串  参数enc是所支持的字符编码名称
        //用于取代URLDecoder类
    
        /**2.3 URL类**/
        //URL类——————统一资源定位符类，它是指向互联网“资源”的指针
        //URL url = new URL("http://www.ecnu.edu.cn");
        
        /**2.4 URLConnection类**/
        //URLConnection类——————抽象类 URLConnection 是所有网络链接类的超类，它代表应用程序和 URL 之间的通信链接
        //URLConnection uc = url.openConnection();
        
        
        /*  //演示URL类和URLConnection类  获取网页内容
        public static void demoURLAndURLEncoder() throws Exception{
            URL url = new URL("http://www.baidu.com");
            System.out.println("返回主机名:" + url.getHost());//获取主机名
            System.out.println("返回端口号:" + url.getPort());//获取端口号
            System.out.println("返回协议名称:" + url.getProtocol());//获取协议
            
            URLConnection uc = url.openConnection();//打开连接
            InputStream in = uc.getInputStream();//得到网页输入流
            
            String directory = "F:\\ciade\\学习\\学习笔记\\Java\\第13章(网络编程)"; //设定为当前路径 
            FileOutputStream out = new FileOutputStream(
                                    new File(directory + "\\testdemoURLAndURLEncoder.html")
                                    );
            int c;
            while((c =  in.read()) != -1){
                out.write(c);//写入本地文件中
            }
            in.close();
            out.close();
        }
        */
        
        /**2.4 Socket类**/
        //Socket类：此类实现客户端套接字（也可以就叫“套接字”）。套接字是两台机器间通信的端点。TCP可用
        /*
        import java.util.*;
        import java.io.*;
        import java.net.*;

        class Receive implements Runnable{
            private Socket s;
            public Receive(Socket s){
                this.s = s;
            }
            public void run() {
                try{
                Scanner in = new Scanner(s.getInputStream());//接受数据
                String str=null;
                while(true){
                    str =  in.nextLine();
                    System.out.println("客户端传来：" + str);
                }
                }catch(Exception e){
                    
                }
            }
        }
        public class Client{
            public static void main(String[] args) throws Exception{
                Socket s = new Socket("localhost",8819);  
                PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
                Thread t = new Thread(new Receive(s));  
                t.start();  
                //以下代码用于发送数据  
                Scanner in = new Scanner(System.in);//键盘输入  
                while(in.hasNextLine()){    //一直不断  
                    out.println(in.nextLine()); //发送键盘输入数据  
                } 
            }
            
        }
        */
        //配合服务器端一同执行
        
        /**2.5 ServerSocket类**/
        //ServerSocket类：此类实现服务器套接字 .TCP 可用
        /*
        import java.util.*;  
        import java.io.*;  
        import java.net.*;  
        public class Server{  
            public static void main(String[]args)throws Exception{  
                ServerSocket server = new ServerSocket(8819);  
                Socket s = server.accept();  
                PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
                Thread t = new Thread(new Receive1(s));  
                t.start();  
                //以下代码用于发送数据  
                Scanner in = new Scanner(System.in);//键盘输入  
                while(in.hasNextLine()){    //一直不断  
                    out.println(in.nextLine()); //发送键盘输入数据  
                }  
            }  
        }  
        class Receive1 implements Runnable  //这个类用于接收数据  
        {  
            private Socket s;  
            public Receive1(Socket s)  
            {  
                this.s = s;  
            }  
            public void run()  
            {  
                try{  
                    Scanner in = new Scanner(s.getInputStream());   //in：接收数据  
                  
                    String str = null;  
                    while(true)  
                    {  
                        str = in.nextLine();      
                        System.out.println("客户端说："+str);    //打印接收数据  
                    }  
                      
                }  
                catch(Exception e){}  
            }  
        }
        */
        //配合客户端一同执行
        
        /**2.6 InetAddress类**/
         //InetAddress类：此类表示 Internet Protocol version 4 (IPv4) 地址（不包含端口号）
         
        /**2.7 InetSocketAddress类**/
        //InetSocketAddress类：此类实现 IP 套接字地址（IP 地址 + 端口号）
        
        /* //演示InetAddress、InetSocketAddress
        public static void demoInetAddressAndInetSocketAddress() throws Exception {
            InetAddress local = InetAddress.getLocalHost();
            System.out.println("返回本机地址：" + local.getHostAddress());//获取本地地址
            System.out.println("返回本机名：" + local.getHostName());//获取主机名
            
            InetAddress[] remote =  InetAddress.getAllByName("www.baidu.com");//如果一个地址多个Ip，则返回IP 地址所组成的数组
            for(InetAddress a : remote){
                System.out.println("地址：" + a.getHostAddress());
                System.out.println("名称：" + a.getHostName());
            }
            
            InetSocketAddress isAdd = new InetSocketAddress(local.getHostAddress(),8080);//第一个参数为IP，第二个参数为端口号
            System.out.println("是否已解析地址：" + isAdd.isUnresolved());//如果无法将主机名解析为 InetAddress，则返回 true。
            
            System.out.println("地址：" + isAdd.getAddress() + ",端口：" + isAdd.getPort());//获取IP和端口
            
            
        }
        */
        
        /**2.8 DatagramSocket类**/
        //DatagramSocket类：表示用来发送和接收数据报包的套接字。在此类上总是启用 UDP 广播发送
        
        /**2.9 DatagramPacket类**/
        //DatagramPacket类：此类表示数据报包
        
        /*//演示DatagramSocket、DatagramPacket类
        //服务器
        class ServerDemo implements Runnable{
            public void run(){
                try{
                    DatagramSocket dgs = new DatagramSocket(8081);
                    while(true){
                        byte[] buf = new byte[1024];
                        DatagramPacket dp = new DatagramPacket(buf,buf.length);
                        dgs.receive(dp);
                        String ip = dp.getAddress().getHostAddress();
                        String data = new String(dp.getData(),0,dp.getLength());
                        System.out.println("IP:" + ip + "发来消息：" + data);
                        dgs.close();
                    }
                }catch(Exception e){
                    
                }
            }
        }

        //客户端
        class ClientDemo implements Runnable{
            public void run(){
                try{
                    DatagramSocket dc = new DatagramSocket();
                    InetAddress ip = InetAddress.getByName("localhost");
                    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                    String line =null;
                    DatagramPacket dp =null;
                    while((line=br.readLine()) != null){
                        if("886".equals(line)){
                            break;
                        }
                        dp = new DatagramPacket(line.getBytes(),line.length(),ip,8081);
                        dc.send(dp);
                        dc.close();
                        br.close();
                    }
                }catch(Exception e){
                    
                }
            }
        }
        */
        
        /**2.10 MulticastSocket类**/
        //MulticastSocket类：用于发送和接收 IP 多播包，在此类上总是启用 UDP 广播发送
        //组播时用到
        
        /**2.11 ProxySelector类**/
        //ProxySelector类：连接到 URL 引用的网络资源时选择要使用的代理服务器类，抽象类
    }
    
    /*
    *3.UDP通信编程
    */
    public static void demoUDP(){
        /**3.1 UDP基本使用**/
        /**3.2 使用DatagramSocket发送、接收数据**/
        //参考上面 演示DatagramSocket、DatagramPacket类中的使用
        
        /**3.3 使用MulticastSocket实现多点广播**/
        //DatagramSocket只允许数据报发送给指定的目标地址，
        //而MulticastSocket可以将数据报以广播方式发送到数量不等的多个客户端
        /*
        MulticastSocket ms =new MulticastSocket(4000);      //新建组播socket
        InetAddress ia = InetAddress.getByName("224.2.2.2");//组播地址   
        ms.joinGroup(ia); //加入主播组  
        byte[] buffer=new byte[512];   
        //发送数据包
              byte[] buf = "Hello,This is a member of multicast!".getBytes();
              DategramPacket packet =
              new DatagramPacket(buf, buf.length,ia,4000);
              ms.send(packet);
              
        //接收数据包
              DatagramPacket dp =new DatagramPacket(buffer,buffer.length);   
              ms.receive(dp);
              String s=new String(dp.getData()).trim();
              System.out.println(s);   
         ms.leaveGroup(address);
         ms.close();
        */
    }
    
    /*
    *4.TCP通信编程
    */
    public static void demoTCP(){
        /**4.1 服务器和客户端**/
        
        /**4.2 TCP基本使用**/
        /*
        //服务端：
        //1，建立服务器端的socket服务，serverSocket();
        //    并监听一个端口。
        //2，获取连接过来的客户端对象
        //   通过ServerSocket的accept方法，没有连接就会等，所以这个方法阻塞
         //
        //3，客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读取
        //   发过来的数据，将之打印在控制台上。
        //4，关闭服务器端。(可选择)
        //
        import java.io.*;
        import java.net.*;
         
        //代表server类
        public class TcpChat
        {
                  public static void main(String[]args)throws Exception
                  {
                           //创建绑定到特定端口的服务器套接字。
                     ServerSocket ss = new ServerSocket(8082);
                           //侦听并接受到此套接字的连接。
                     Socket sk = ss.accept();
                    
                     String ip = sk.getInetAddress().getHostAddress();//得到ip地址
                     //返回此套接字的输入流。
                     InputStream is = sk.getInputStream();
         
                     int len = 0;
                     byte []buf = new byte[1024];
                     while((len=is.read(buf))!=-1)
                     {
                         System.out.println(ip+""...""+new String(buf,0,len));
                     }
              
                     sk.close();
                    ss.close();
                }
        }
        
        
        //客户端：
        //通过查阅socket对象，发现在该对象上建立时，就可以去连接到指定的主机了。
        //因为tcp是面向连接的，所以在建立socket服务是，就要有服务器端的存在，并连接成功。形成通路后，
        //在该通道进行数据的传输。
        // 
        //需求：给服务器端发送一个文本数据。
         
        //步骤：
        //1，创建Socket服务，并指定要连接的主机和端口。
        //
        
        
        
        //代表客户端类
        class TcpClient
        {
                  public static void main(String []arg)throws Exception
                  {
                           //创建一个客户端服务
                     Socket s = new Socket(""192.168.0.101"", 8082);
                //指定要发送的内容
                     byte[] buf = ""Hello Rory, You do it!"".getBytes();
                     //得到此套接字的输出流。
                     OutputStream os = s.getOutputStream();
              
                     os.write(buf);
                     s.close();
         
         
                  }
        }
        */
        
        /**4.3 使用NIO实现非阻塞Socket通信**/
        /*
        //服务器端
        import java.io.IOException;  
        import java.net.InetSocketAddress;  
        import java.nio.ByteBuffer;  
        import java.nio.channels.Channel;  
        import java.nio.channels.SelectionKey;  
        import java.nio.channels.Selector;  
        import java.nio.channels.ServerSocketChannel;  
        import java.nio.channels.SocketChannel;  
        import java.nio.charset.Charset;  
          
        public class NServer {  
          
            // 用于检测所有的Channel状态的selector  
            private Selector selector = null;  
            static final int PORT = 30000;  
            // 定义实现编码、解码的字符串集对象  
            private Charset charse = Charset.forName("GBK");  
          
            public void init() throws IOException {  
                selector = Selector.open();  
                // 通过open方法来打开一个未绑定的ServerSocketChannel实例  
                ServerSocketChannel server = ServerSocketChannel.open();  
                InetSocketAddress isa = new InetSocketAddress("127.0.0.1", PORT);  
                // 将该ServerSocketChannel绑定到指定的IP地址  
                server.bind(isa);  
                // 设置serverSocket已非阻塞方式工作  
                server.configureBlocking(false);  
                // 将server注册到指定的selector对象  
                server.register(selector, SelectionKey.OP_ACCEPT);  
                while (selector.select() > 0) {  
                    // 一次处理selector上的每个选择的SelectionKey  
                    for (SelectionKey sk : selector.selectedKeys()) {  
                        // 从selector上已选择的Kye集中删除正在处理的SelectionKey  
                        selector.selectedKeys().remove(sk);  
                        // 如果sk对应的Channel包含客户端的连接请求  
                        if (sk.isAcceptable()) {  
                            // 调用accept方法接收连接，产生服务器段的SocketChennal  
                            SocketChannel sc = server.accept();  
                            // 设置采用非阻塞模式  
                            sc.configureBlocking(false);  
                            // 将该SocketChannel注册到selector  
                            sc.register(selector, SelectionKey.OP_READ);  
                        }  
                        // 如果sk对应的Channel有数据需要读取  
                        if (sk.isReadable()) {  
                            // 获取该SelectionKey对银行的Channel，该Channel中有刻度的数据  
                            SocketChannel sc = (SocketChannel) sk.channel();  
                            // 定义备注执行读取数据源的ByteBuffer  
                            ByteBuffer buff = ByteBuffer.allocate(1024);  
                            String content = "";  
                            // 开始读取数据  
                            try {  
                                while (sc.read(buff) > 0) {  
                                    buff.flip();  
                                    content += charse.decode(buff);  
                                }  
                                System.out.println("读取的数据：" + content);  
                                // 将sk对应的Channel设置成准备下一次读取  
                                sk.interestOps(SelectionKey.OP_READ);  
                            }  
                            // 如果捕获到该sk对银行的Channel出现了异常，表明  
                            // Channel对应的Client出现了问题，所以从Selector中取消  
                            catch (IOException io) {  
                                // 从Selector中删除指定的SelectionKey  
                                sk.cancel();  
                                if (sk.channel() != null) {  
                                    sk.channel().close();  
                                }  
                            }  
                            // 如果content的长度大于0,则连天信息不为空  
                            if (content.length() > 0) {  
                                // 遍历selector里注册的所有SelectionKey  
                                for (SelectionKey key : selector.keys()) {  
                                    // 获取该key对应的Channel  
                                    Channel targerChannel = key.channel();  
                                    // 如果该Channel是SocketChannel对象  
                                    if (targerChannel instanceof SocketChannel) {  
                                        // 将读取到的内容写入该Channel中  
                                        SocketChannel dest = (SocketChannel) targerChannel;  
                                        dest.write(charse.encode(content));  
                                    }  
                                }  
                            }  
                        }  
                    }  
                }  
          
            }  
              
            public static void main(String [] args) throws IOException{  
                new NServer().init();  
            }  
          
        }  
        
        
        //客户端
        import java.io.IOException;  
        import java.net.InetSocketAddress;  
        import java.nio.ByteBuffer;  
        import java.nio.channels.SelectionKey;  
        import java.nio.channels.Selector;  
        import java.nio.channels.SocketChannel;  
        import java.nio.charset.Charset;  
        import java.util.Scanner;  
          
        public class NClient {  
              
            //定义检测Sockethannel的Selector对象  
            private Selector  selector=null;  
            static final int PORT=30000;  
            //定义处理编码的字符集  
            private Charset charset=Charset.forName("GBK");  
            //客户端SocketChannel  
            private SocketChannel sc=null;  
              
            public void init() throws IOException{  
                selector=Selector.open();  
                InetSocketAddress isa=new InetSocketAddress("127.0.0.1", PORT);  
                //调用open的静态方法创建连接指定的主机的SocketChannel  
                sc=SocketChannel.open(isa);  
                //设置该sc已非阻塞的方式工作  
                sc.configureBlocking(false);  
                //将SocketChannel对象注册到指定的Selector  
                sc.register(selector, SelectionKey.OP_READ);  
                //启动读取服务器数据端的线程  
                new ClientThread().start();  
                //创建键盘输入流  
                Scanner scan=new Scanner(System.in);  
                while(scan.hasNextLine()){  
                    //读取键盘的输入  
                    String line=scan.nextLine();  
                    //将键盘的内容输出到SocketChanenel中  
                    sc.write(charset.encode(line));  
                }  
            }  
              
            //定义读取服务器端的数据的线程  
            private class ClientThread extends Thread{  
          
                @Override  
                public void run() {  
                    try{  
                        while(selector.select()>0){  
                            //遍历每个有可能的IO操作的Channel对银行的SelectionKey  
                            for(SelectionKey sk:selector.selectedKeys()){  
                                //删除正在处理的SelectionKey  
                                selector.selectedKeys().remove(sk);  
                                //如果该SelectionKey对应的Channel中有可读的数据  
                                if(sk.isReadable()){  
                                    //使用NIO读取Channel中的数据  
                                    SocketChannel sc=(SocketChannel)sk.channel();  
                                    String content="";  
                                    ByteBuffer bff=ByteBuffer.allocate(1024);  
                                    while(sc.read(bff)>0){  
                                        sc.read(bff);  
                                        bff.flip();  
                                        content+=charset.decode(bff);  
                                    }  
                                    //打印读取的内容  
                                    System.out.println("聊天信息:"+content);  
                                    sk.interestOps(SelectionKey.OP_READ);  
                                      
                                }  
                            }  
                        }  
                          
                    }catch(IOException io){  
                        io.printStackTrace();  
                    }  
                }  
                  
            }  
              
            public static void main(String [] args) throws IOException{  
                new NClient().init();  
            }  
          
        }
        */
    }
    
    /*
    *5.代理服务器
    */
    public static void demoProxyServer(){
        /**8.1 直接使用Proxy创建连接**/
        /*
        URL url = new URL("127.0.0.1");//创建一个代理服务器对象  
        
        //使用指定的代理服务器打开连接  
        Proxy proxy = new Proxy(Proxy.Type.HTTP,new InetSocketAddress(proxyAddress , proxyPort));
        
        URLConnection conn = url.openConnection(proxy);//设置超时时长  
        conn.setConnectTimeout(5000);  
        */
        
        /**8.2 使用ProxySelector选择代理服务器**/
        /*
        系统提供了默认的ProxySelector子类作为代理选择器，开发者可以实现自己的代理选择器，
        程序可以通过继承ProxySelector来实现自己的代理选择器。继承ProxySelector需要重写两个方法：
        List<Proxy> select(URI uri)：实现该方法让代理选择器根据不同的URI来使用不同的代理服务器，
                                    该方法就是代理选择器管理网络连接使用代理服务器的关键。
        connectFailed(URI uri, SocketAddress sa, IOException ioe)：当系统通过默认的代理服务器建立连接失败后，
                            代理选择器将会自动调用该方法。通过重写该方法可以对连接代理服务器失败的情形进行处理。
                            
        //更多使用说明详见API文档或者度娘
        */
    }
    
    /*
    *6.常见网络编程异常
    */
    public static void demoCommonException(){
        //1.java.net.BindException:异常的原因是以为与port一样的一个端口已经被启动，并进行监听
        //2.java.net.ConnectException：异常发生的原因是或者具有ip地址的机器不能找到（也就是说从当前机器不存在到指定ip路由），或者是该ip存在，但找不到指定的端口进行监听
        //3.java.net.SocketException：
        //    3.1异常的原因是己方主动关闭了连接后（调用了Socket的close方法）再对网络连接进行读写操作
        //    3.2异常的原因是甲方主动关闭了连接后（调用了Socket的close方法）再对网络连接进行读写操作
        //    3.3简单的说就是在连接断开后的读和写操作引起的
        //解决方式：首先确保程序退出前关闭所有的网络连接，其次是要检测对方的关闭连接操作，发现对方关闭连接后自己也要关闭该连接
    }

    
    /**部分文档参考至： http://blog.csdn.net/xiazdong/article/details/6713691
                        http://blog.sina.com.cn/s/blog_4d9c3fec0101tztp.html
                        http://blog.csdn.net/x605940745/article/details/14123343**/
}