博客
关于我
强烈建议你试试无所不能的chatGPT，快点击我
Java Socket基础（二）
阅读量：5767 次
发布时间：2019-06-18

本文共 4774 字，大约阅读时间需要 15 分钟。

2
）对象消息
         发送对象消息。服务端有LinkServer和LinkServer2两个，分别支持单客户端与多客户端，方式也有些不一样。
         附件解压工程LinkedSocketB，.test包内Test开头的即是测试类了。服务端接收到客户端连接时，直接一个循环发送n个对象过去，没什么大问题^^。
 
2.1）LinkClient.java 
 
     
     
          
  1. /** 
    2.  
          
  2.  * 只建立一个Socket，长连接Server接收数据。 
    3.  
          
  3.  * 
    4.  
          
  4.  * @author Join 
    5.  
          
  5.  */ 
    6.  
          
  6. public class LinkClient extends Thread { 
    7.  
          
  7.   
    8.  
          
  8.     /** 套接字地址 */ 
    9.  
          
  9.     private SocketAddress address; 
    10.  
          
  10.     /** 超时时间 */ 
    11.  
          
  11.     private int timeout; 
    12.  
          
  12.     /** 客户端监听接口 */ 
    13.  
          
  13.     private OnLinkClientListener listener; 
    14.  
          
  14.   
    15.  
          
  15.     /** 
    16.  
          
  16.      * 构造客户端 
    17.  
          
  17.      * 
    18.  
          
  18.      * @param host 服务器名称 
    19.  
          
  19.      * @param port 服务器端口 
    20.  
          
  20.      * @param timeout 连接超时时间 
    21.  
          
  21.      */ 
    22.  
          
  22.     public LinkClient(String host, int port, int timeout) { 
    23.  
          
  23.        this.address = new InetSocketAddress(host, port); 
    24.  
          
  24.        this.timeout = timeout; 
    25.  
          
  25.     } 
    26.  
          
  26.   
    27.  
          
  27.     @Override 
    28.  
          
  28.     public void run() { 
    29.  
          
  29.        Socket socket = new Socket(); // 创建未连接套接字 
    30.  
          
  30.        try { 
    31.  
          
  31.            socket.connect(address, timeout); // 连接到服务器，并指定超时时间 
    32.  
          
  32.            if (null != listener) { 
    33.  
          
  33.               listener.onConnected(); 
    34.  
          
  34.            } 
    35.  
          
  35.            receiveObj(socket); // 接收服务器数据 
    36.  
          
  36.        } catch (ConnectException e) { // 拒绝连接 
    37.  
          
  37.            if (null != listener) { 
    38.  
          
  38.               listener.onConnectException(); 
    39.  
          
  39.            } 
    40.  
          
  40.        } catch (SocketTimeoutException e) { // 连接超时 
    41.  
          
  41.            if (null != listener) { 
    42.  
          
  42.               listener.onTimeoutException(); 
    43.  
          
  43.            } 
    44.  
          
  44.        } catch (IOException e) { 
    45.  
          
  45.            e.printStackTrace(); 
    46.  
          
  46.        } finally { 
    47.  
          
  47.            try { 
    48.  
          
  48.               if (null != socket) { 
    49.  
          
  49.                   socket.close(); // 关闭Socket 
    50.  
          
  50.               } 
    51.  
          
  51.            } catch (IOException e) { 
    52.  
          
  52.               e.printStackTrace(); 
    53.  
          
  53.            } 
    54.  
          
  54.        } 
    55.  
          
  55.     } 
    56.  
          
  56.   
    57.  
          
  57.     /** 接收服务器发送的对象 */ 
    58.  
          
  58.     private void receiveObj(Socket socket) { 
    59.  
          
  59.        // socket.shutdownOutput(); // 半关闭输出流 
    60.  
          
  60.  
    61.  
          
  61.        ObjectInputStream is = null; 
    62.  
          
  62.        try { 
    63.  
          
  63.            is = new ObjectInputStream(new BufferedInputStream( 
    64.  
          
  64.                   socket.getInputStream())); 
    65.  
          
  65.            /** 循环接收对象 */ 
    66.  
          
  66.            while (true) { 
    67.  
          
  67.               Object obj = is.readObject(); 
    68.  
          
  68.               if (null == obj) { 
    69.  
          
  69.                   break; 
    70.  
          
  70.               } 
    71.  
          
  71.               if (null != listener) { 
    72.  
          
  72.                   listener.onReceive(obj); 
    73.  
          
  73.               } 
    74.  
          
  74.            } 
    75.  
          
  75.            if (null != listener) { 
    76.  
          
  76.               listener.onExited(); 
    77.  
          
  77.            } 
    78.  
          
  78.        } catch (SocketException e) { // Connection reset 
    79.  
          
  79.            if (null != listener) { 
    80.  
          
  80.               listener.onSocketException(); 
    81.  
          
  81.            } 
    82.  
          
  82.        } catch (IOException e) { 
    83.  
          
  83.            e.printStackTrace(); 
    84.  
          
  84.        } catch (ClassNotFoundException e) { 
    85.  
          
  85.            e.printStackTrace(); 
    86.  
          
  86.        } finally { 
    87.  
          
  87.            try { 
    88.  
          
  88.               if (null != is) { 
    89.  
          
  89.                   is.close(); 
    90.  
          
  90.               } 
    91.  
          
  91.               if (null != socket) { 
    92.  
          
  92.                   socket.close(); 
    93.  
          
  93.               } 
    94.  
          
  94.            } catch (IOException e) { 
    95.  
          
  95.               e.printStackTrace(); 
    96.  
          
  96.            } 
    97.  
          
  97.        } 
    98.  
          
  98.     } 
    99.  
          
  99.   
    100.  
          
  100.     /** 设置客户端监听接口 */ 
    101.  
          
  101.     public void setOnLinkClientListener(OnLinkClientListener listener) { 
    102.  
          
  102.        this.listener = listener; 
    103.  
          
  103.     } 
    104.  
          
  104.   
    105.  
          
  105. } 
    106.  
         
 
     
         
     
 
     
       2.2）LinkServer.java 
     
 
     
 
     
     
          
  1. /** 
    2.  
          
  2.  * 开启服务器，长连接一个Socket，主动发送数据 
    3.  
          
  3.  * 
    4.  
          
  4.  * @author Join 
    5.  
          
  5.  */ 
    6.  
          
  6. public class LinkServer extends Thread { 
    7.  
          
  7.   
    8.  
          
  8.     /** 服务端口 */ 
    9.  
          
  9.     private int port; 
    10.  
          
  10.     /** 服务套接字 */ 
    11.  
          
  11.     private ServerSocket mServerSocket; 
    12.  
          
  12.     /** 线程池 */ 
    13.  
          
  13.     private ExecutorService pool; 
    14.  
          
  14.     /** 服务器监听接口 */ 
    15.  
          
  15.     private OnLinkServerListener listener; 
    16.  
          
  16.   
    17.  
          
  17.     /** 同步对象 */ 
    18.  
          
  18.     private Object lockObj = new Object(); 
    19.  
          
  19.     /** 是否等待 */ 
    20.  
          
  20.     private boolean isWaiting = false; 
    21.  
          
  21.     /** 发送对象集合 */ 
    22.  
          
  22.     private ArrayList<Object> sendObjList; 
    23.  
          
  23.   
    24.  
          
  24.     public LinkServer(int port) { 
    25.  
          
  25.        this.port = port; 
    26.  
          
  26.        pool = Executors.newCachedThreadPool(); // 缓存线程池 
    27.  
          
  27.        sendObjList = new ArrayList<Object>(); 
    28.  
          
  28.     } 
    29.  
          
  29.   
    30.  
          
  30.     @Override 
    31.  
          
  31.     public void run() { 
    32.  
          
  32.        try { 
    33.  
          
  33.            mServerSocket = new ServerSocket(port); // 创建本地特定端口服务器套接字 
    34.  
          
  34.            Socket client = null; 
    35.  
          
  35.            client = mServerSocket.accept(); // 接收连接的套接字 
    36.  
          
  36.            if (null != listener) { 
    37.  
          
  37.               listener.onClientConnected(client.getInetAddress()); 
    38.  
          
  38.            } 
    39.  
          
  39.            pool.execute(new ThreadServer(client)); // 新线程执行任务 
    40.  
          
  40.         } catch (BindException e) { // 端口使用中 
    41.  
          
  41.  
    42.  
          
  42.            if (null != listener) { 
    43.  
          
  43.               listener.onBindException(); 
    44.  
          
  44.            } 
    45.  
          
  45.        } catch (IOException e) { 
    46.  
          
  46.            e.printStackTrace(); 
    47.  
          
  47.        } 
    48.  
          
  48.   
    49.  
          
  49.     } 
    50.  
          
  50.   
    51.  
          
  51.     /** 各个连接客户端的服务线程 */ 
    52.  
          
  52.     private class ThreadServer extends Thread { 
    53.  
          
  53.   
    54.  
          
  54.        private Socket client; 
    55.  
          
  55.   
    56.  
          
  56.        public ThreadServer(Socket client) { 
    57.  
          
  57.            this.client = client; 
    58.  
          
  58.        } 
    59.  
          
  59.   
    60.  
          
  60.        @Override 
    61.  
          
  61.        public void run() { 
    62.  
          
  62.            ObjectOutputStream os = null; 
    63.  
          
  63.            try { 
    64.  
          
  64.               os = new ObjectOutputStream(client.getOutputStream()); 
    65.  
          
  65.   
    66.  
          
  66.               Object sendObj; 
    67.  
          
  67.               synchronized (lockObj) { 
    68.  
          
  68.                   while (true) { 
    69.  
          
  69.                      if (sendObjList.size() <= 0) { 
    70.  
          
  70.                          isWaiting = true; 
    71.  
          
  71.                          lockObj.wait(); 
    72.  
          
  72.                      } 
    73.  
          
  73.                      sendObj = sendObjList.get(0); 
    74.  
          
  74.                      os.writeObject(sendObj); 
    75.  
          
  75.                      os.flush(); 
    76.  
          
  76.   
    77.  
          
  77.                      /* 发送null时，表示退出了 */ 
    78.  
          
  78.                      if (null == sendObj) { 
    79.  
          
  79.                          if (null != listener) { 
    80.  
          
  80.                             listener.onExited(client.getInetAddress()); 
    81.  
          
  81.                          } 
    82.  
          
  82.                          break; 
    83.  
          
  83.                      } 
    84.  
          
  84.                      sendObjList.remove(0); 
    85.  
          
  85.                   } 
    86.  
          
  86.               } 
    87.  
          
  87.   
    88.  
          
  88.            } catch (SocketException e) { // Connection reset 
    89.  
          
  89.               if (null != listener) { 
    90.  
          
  90.                   listener.onSocketException(client.getInetAddress()); 
    91.  
          
  91.               } 
    92.  
          
  92.            } catch (IOException e) { 
    93.  
          
  93.               e.printStackTrace(); 
    94.  
          
  94.            } catch (InterruptedException e) { 
    95.  
          
  95.               e.printStackTrace(); 
    96.  
          
  96.            } finally { 
    97.  
          
  97.               try { 
    98.  
          
  98.                   if (null != os) { 
    99.  
          
  99.                      os.close(); 
    100.  
          
  100.                   } 
    101.  
          
  101.                   if (null != client) { 
    102.  
          
  102.                      client.close(); 
    103.  
          
  103.                   } 
    104.  
          
  104.               } catch (IOException e) { 
    105.  
          
  105.                   e.printStackTrace(); 
    106.  
          
  106.               } 
    107.  
          
  107.            } 
    108.  
          
  108.        } 
    109.  
          
  109.   
    110.  
          
  110.     } 
    111.  
          
  111.   
    112.  
          
  112.     /** 发送序列化对象 */ 
    113.  
          
  113.     public void sendObj(Object obj) { 
    114.  
          
  114.        /* 这个判断非必需的，记得就好 */ 
    115.  
          
  115.        if (null != obj && !isSerializable(obj)) 
    116.  
          
  116.            throw new IllegalArgumentException( 
    117.  
          
  117.                   "Object needs to implement java.io.Serializable!"); 
    118.  
          
  118.  
    119.  
          
  119.        sendObjList.add(obj); 
    120.  
          
  120.   
    121.  
          
  121.        if (isWaiting) { 
    122.  
          
  122.            synchronized (lockObj) { 
    123.  
          
  123.               lockObj.notifyAll(); 
    124.  
          
  124.            } 
    125.  
          
  125.            isWaiting = false; 
    126.  
          
  126.        } 
    127.  
          
  127.     } 
    128.  
          
  128.   
    129.  
          
  129.     /** 判断是否序列化 */ 
    130.  
          
  130.     private boolean isSerializable(Object obj) { 
    131.  
          
  131.        Class<?>[] cls = obj.getClass().getInterfaces(); 
    132.  
          
  132.        for (Class<?> clazz : cls) { 
    133.  
          
  133.            if (clazz.getName().equals(Serializable.class.getName())) 
    134.  
          
  134.               return true; 
    135.  
          
  135.        } 
    136.  
          
  136.        return false; 
    137.  
          
  137.     } 
    138.  
          
  138.   
    139.  
          
  139.     /** 设置服务器监听接口 */ 
    140.  
          
  140.     public void setOnLinkServerListener(OnLinkServerListener listener) { 
    141.  
          
  141.        this.listener = listener; 
    142.  
          
  142.     } 
    143.  
          
  143.   
    144.  
          
  144. } 
    145.  
         
 
     
 
 
     
 
     
 
    
 
   
 
   
 
 
   
     本文转自winorlose2000 51CTO博客，原文链接：http://blog.51cto.com/vaero/893844，如需转载请自行联系原作者
 
   
 
   
 
   
 
   
 
   
 
  
 

        

        

            你可能感兴趣的文章
        

        
            

                
使用PullToRefresh实现下拉刷新和上拉加载

                
查看>>

            

        
            

                
mysql

                
查看>>

            

        
            

                
2012年电信业八大发展趋势

                
查看>>

            

        
            

                
Web日志安全分析工具 v2.0发布

                
查看>>

            

        
            

                
JS重载

                
查看>>

            

        
            

                
python2和python3同安装在Windows上，切换问题

                
查看>>

            

        
            

                
php加速工具xcache的安装与使用（基于LNMP环境）

                
查看>>

            

        
            

                
android超链接

                
查看>>

            

        
            

                
redhat tomcat

                
查看>>

            

        
            

                
统计数据库大小

                
查看>>

            

        
            

                
IO流的学习--文件夹下文件的复制

                
查看>>

            

        
            

                
第十六章：脚本化HTTP

                
查看>>

            

        
            

                
EXCEL表中如何让数值变成万元或亿元

                
查看>>

            

        
            

                
Cisco PIX防火墙的安装流程

                
查看>>

            

        
            

                
配置系列:ssm中applicationContext-mybatis.xml的简单配置

                
查看>>

            

        
            

                
mysql或者mariadb备份脚本

                
查看>>

            

        
            

                
extundelete恢复文件

                
查看>>

            

        
            

                
电池温度检测原理和示例代码

                
查看>>

            

        
            

                
Linux服务器性能评估与优化、监控利器---dstat应用

                
查看>>

            

        
            

                
hdu 2842 Chinese Rings 矩阵快速幂

                
查看>>

            

        
    






    

            

                
喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！-- 愿君每日到此一游！

                

                    当前时间: 2024-12-20 18:17:01  
                    当前IP: 3.135.214.208  
                    联系邮箱:javaeecc@qq.com
                        Copyright © 2020 - 2022 baihongyu.com
                    京ICP备2021015314号-2
                

            


                
                    

                    强烈建议你试试无所不能的CHAT-GPT，快点击我
                    

                
                
                    

                        强烈建议你试试无所不能的CHAT-GPT，快点击我