【Java】聊天程序综合案例

拼搏现实的明天。 2021-12-01 14:38 343阅读 0赞

在这里插入图片描述
创建服务端
在类中添加消息队列及Socket集合
因为需要给所有客户端发送消息，所以服务器端必须持有所有客户端Socket的集合
生产和消费消息数据需要一个消息队列,所以服务器还必须定义一个消息队列

  1. package edu.xalead.server;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintWriter;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  9. import java.util.concurrent.ConcurrentHashMap;
  10. import java.util.concurrent.ConcurrentLinkedQueue;
  11. public class chatServer {
  13.  /**
  14.      * 所有客户端连接集合
  15.      */
  16.     private ConcurrentHashMap<String, Socket> allCustomer = new ConcurrentHashMap<>();
  17.     /***
  18.      * 存放消息的队列
  19.      */
  20.     private ConcurrentLinkedQueue<String> messageQueue = new ConcurrentLinkedQueue<>();
  21.  }

创建接收线程
离开ChatServer类没有利用价值，所以我这里写成内部类

  1. /**
  2.      * 创建接受线程
  3.      * 离开ChatServer后失去价值，故使用内部类
  4.      * 作用：只做接受消息，放进消息队列
  5.      */
  6.     private class ReceiveService extends  Thread{
  8.         /**
  9.          * 必须持有消息队列的引用
  10.          */
  11.         //如果需要创建效果更强的外部类则对于消息队列需要创建接口
  12. //        private ConcurrentLinkedQueue<String> messageQueue=null;
  13. //        private ReceiveService(ConcurrentLinkedQueue<String> messageQueue){
  15. //            this.messageQueue=messageQueue;
  16. //        }
  17.                 //客户端的套接字
  18.         private Socket client=null;
  19.         public  ReceiveService(Socket client) {
  21.             this.client = client;
  22.         }
  23.         public void run(){
  25.             BufferedReader br=null;
  26.             try {
  28.                 //注意socket只能得到字节流，所以要把它包装成字符流得用InputStreamReader包装一下
  29.                 br=new BufferedReader(
  30.               new InputStreamReader(client.getInputStream()));
  31.                 while (true) {
  33.                     //接收消息
  34.                         System.out.println("等待接收客户端【"+client.getInetAddress().getHostAddress()
  35.                                 +"】消息");
  36.                         String mesg=br.readLine();
  37.                         System.out.println("接收到客户端【"+client.getInetAddress().getHostAddress()
  38.                                 +"】消息");
  39.                         //放入消息队列
  40.                     synchronized (messageQueue) {
  42.                         messageQueue.offer(mesg);
  43.                         messageQueue.notify();
  44.                     }
  45.                     //接受下一条
  46.                 }
  47.             } catch (IOException e) {
  49.                 e.printStackTrace();
  50.             }
  51.         }
  52.     }

.接收客户消息
每个接收线程只能为一个特定客户服务，必须持有这个客户的Socket,所以在接收线程中添加客户的 Socket引用

  1. //客户端的套接字
  2.         private Socket client=null;
  3.         public  ReceiveService(Socket client) {
  5.             this.client = client;
  6.         }

接收线程中的Socket怎么得到呢？
显然，需要编写监听客户端的代码吧 4.添加监听客户端连接的代码

  1. private static final int port=9999;
  2.     /**
  3.      * 监听
  4.      */
  5.     public void start(){
  7.         //启动发送消息线程
  8.         new Thread(new SendService()).start();
  10.         ServerSocket serverSocket=null;
  11.         Socket client=null;
  12.         try {
  14.             //申请端口
  15.             serverSocket =new ServerSocket(port);
  16.             while (true) {
  18.                 //监听
  19.                 System.out.println("开始监听新的客户端连接 。。。。");
  20.                 client=serverSocket.accept();
  21.                 System.out.println("监听到客户端【"+client.getInetAddress().getHostAddress()
  22.                         +":"+client.getPort()+"】");
  23.                 //提供消息服务
  24.                 new ReceiveService(client).start();
  25.                 //把socket放进客户socket集合，以便发送线程使用
  26.                 String key=client.getInetAddress().getHostAddress()+":"+client.getPort();
  28.                 System.out.println(key);
  29.                 allCustomer.put(key,client);
  30.                 //监听下一个
  31.             }
  32.         } catch (Exception e) {
  34.             e.printStackTrace();
  35.         }
  36.     }

定义发送线程

  1. /**
  2.      * 创建发送线程
  3.      */
  4.     private class  SendService implements Runnable{
  7.         @Override
  8.         public void run() {
  10.             try {
  12.                 PrintWriter pw=null;
  13.                 while (true) {
  15. //取消息队列中的消息
  16.                     String mesg=messageQueue.poll();//poll取一个删一个
  17.                     synchronized (messageQueue) {
  19.                         if(mesg!=null) {
  22.                             //遍历客户端连接
  23.                             for (Socket socket : allCustomer.values()) {
  25.                                 //创建字符输出流半配网络字节流
  26.                                 pw = new PrintWriter(socket.getOutputStream());
  27.                                 //向客户端发送消息
  29.                                     pw.println(mesg);
  30.                                     pw.flush();
  31.                             }
  32.                         }else {
  34.                             //休息
  35.                             messageQueue.wait();
  36.                         }
  37.                     }
  38.                 }
  39.                 //到队列里取下一条消息
  40.             } catch (Exception e) {
  42.                 e.printStackTrace();
  43.             }
  45.         }
  46.     }

启动发送消息线程
在这里插入图片描述
完整服务端代码

  1. package edu.xalead.server;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintWriter;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  9. import java.util.concurrent.ConcurrentHashMap;
  10. import java.util.concurrent.ConcurrentLinkedQueue;
  12. public class chatServer {
  14.     private static final int port=9999;
  15.     /**
  16.      * 监听
  17.      */
  18.     public void start(){
  20.         //启动发送消息线程
  21.         new Thread(new SendService()).start();
  23.         ServerSocket serverSocket=null;
  24.         Socket client=null;
  25.         try {
  27.             //申请端口
  28.             serverSocket =new ServerSocket(port);
  29.             while (true) {
  31.                 //监听
  32.                 System.out.println("开始监听新的客户端连接 。。。。");
  33.                 client=serverSocket.accept();
  34.                 System.out.println("监听到客户端【"+client.getInetAddress().getHostAddress()
  35.                         +":"+client.getPort()+"】");
  36.                 //提供消息服务
  37.                 new ReceiveService(client).start();
  38.                 //把socket放进客户socket集合，以便发送线程使用
  39.                 String key=client.getInetAddress().getHostAddress()+":"+client.getPort();
  41.                 System.out.println(key);
  42.                 allCustomer.put(key,client);
  43.                 //监听下一个
  44.             }
  45.         } catch (Exception e) {
  47.             e.printStackTrace();
  48.         }
  49.     }
  50.     /**
  51.      * 所有客户端连接集合
  52.      */
  53.     private ConcurrentHashMap<String, Socket> allCustomer = new ConcurrentHashMap<>();
  54.     /***
  55.      * 存放消息的队列
  56.      */
  57.     private ConcurrentLinkedQueue<String> messageQueue = new ConcurrentLinkedQueue<>();
  58.     /**
  59.      * 创建发送线程
  60.      */
  61.     private class  SendService implements Runnable{
  64.         @Override
  65.         public void run() {
  67.             try {
  69.                 PrintWriter pw=null;
  70.                 while (true) {
  72. //取消息队列中的消息
  73.                     String mesg=messageQueue.poll();//poll取一个删一个
  74.                     synchronized (messageQueue) {
  76.                         if(mesg!=null) {
  79.                             //遍历客户端连接
  80.                             for (Socket socket : allCustomer.values()) {
  82.                                 //创建字符输出流半配网络字节流
  83.                                 pw = new PrintWriter(socket.getOutputStream());
  84.                                 //向客户端发送消息
  86.                                     pw.println(mesg);
  87.                                     pw.flush();
  88.                             }
  89.                         }else {
  91.                             //休息
  92.                             messageQueue.wait();
  93.                         }
  94.                     }
  95.                 }
  96.                 //到队列里取下一条消息
  97.             } catch (Exception e) {
  99.                 e.printStackTrace();
  100.             }
  102.         }
  103.     }
  104.     /**
  105.      * 创建接受线程
  106.      * 离开ChatServer后失去价值，故使用内部类
  107.      * 作用：只做接受消息，放进消息队列
  108.      */
  109.     private class ReceiveService extends  Thread{
  111.         /**
  112.          * 必须持有消息队列的引用
  113.          */
  114.         //如果需要创建效果更强的外部类则对于消息队列需要创建接口
  115. //        private ConcurrentLinkedQueue<String> messageQueue=null;
  116. //        private ReceiveService(ConcurrentLinkedQueue<String> messageQueue){
  118. //            this.messageQueue=messageQueue;
  119. //        }
  120.                 //客户端的套接字
  121.         private Socket client=null;
  122.         public  ReceiveService(Socket client) {
  124.             this.client = client;
  125.         }
  126.         public void run(){
  128.             BufferedReader br=null;
  129.             try {
  131.                 //注意socket只能得到字节流，所以要把它包装成字符流得用InputStreamReader包装一下
  132.                 br=new BufferedReader(
  133.               new InputStreamReader(client.getInputStream()));
  134.                 while (true) {
  136.                     //接收消息
  137.                         System.out.println("等待接收客户端【"+client.getInetAddress().getHostAddress()
  138.                                 +"】消息");
  139.                         String mesg=br.readLine();
  140.                         System.out.println("接收到客户端【"+client.getInetAddress().getHostAddress()
  141.                                 +"】消息");
  142.                         //放入消息队列
  143.                     synchronized (messageQueue) {
  145.                         messageQueue.offer(mesg);
  146.                         messageQueue.notify();
  147.                     }
  148.                     //接受下一条
  149.                 }
  150.             } catch (IOException e) {
  152.                 e.printStackTrace();
  153.             }
  154.         }
  155.     }
  156. }

思考线程协作的问题
如果不考虑线程协作，那么发送消息线程在消息队列为空的时候仍然会做无意义循环，浪费宝贵的CPU 时间片
在这里插入图片描述
所以我们要用线程协作解决这个问题。首先要添加同步块，因为消息队列是所有线程监控的同一对象， 所以用它作为同步监视器
在这里插入图片描述
切记要注意同步块的范围，如果同步锁定紫色框选范围，则只要有一个线程br.readLine()会等待客户消 息，导致所有接收消息的线程无法进入同步块，无法执行接收消息的工作
在这里插入图片描述
最后添加协作代码
当消息队列为空时，发送线程进入休眠状态
watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDE2MjI2_size_16_color_FFFFFF_t_70 5
当接收消息线程接收到消息并放入消息队列，则唤醒发送线程
在这里插入图片描述
.我们准备把传输数据改为json传输
创建VO对象

  1. package edu.xalead.vo;
  4. import java.util.Date;
  6. public class MessageVO {
  7.     //vo(view object)
  8.     private String mesg;
  9.     private Date date;
  10. public MessageVO(){
  13. }
  14.     public MessageVO(String mesg, Date date) {
  16.         this.mesg = mesg;
  17.         this.date = date;
  18.     }
  20.     @Override
  21.     public String toString() {
  23.         return "MessageVO{" +
  24.                 "mesg='" + mesg + '\'' +
  25.                 ", date=" + date +
  26.                 '}';
  27.     }
  29.     public String getMesg() {
  31.         return mesg;
  32.     }
  34.     public void setMesg(String mesg) {
  36.         this.mesg = mesg;
  37.     }
  39.     public Date getDate() {
  41.         return date;
  42.     }
  44.     public void setDate(Date date) {
  46.         this.date = date;
  47.     }
  48. }

创建JSON和对象互转工具类

  1. package edu.xalead.util;
  3. import net.sf.json.JSONObject;
  5. public class JSONUtil {
  7.     /**
  8.      * 对象转json的方法
  9.      * @return
  10.      */
  11.     public static String obj2json(Object obj){
  13.         JSONObject ob=JSONObject.fromObject(obj);
  14.         return ob.toString();
  15.     }
  17.     /**
  18.      * 把json串转成对象的方法
  19.      */
  20.     public static <T> T json2obj(String jsonStr,Class<T> t){
  22.         JSONObject object=JSONObject.fromObject(jsonStr);
  23.         return (T)JSONObject.toBean(object,t);
  24.     }
  25. }
  26. ______
  27. 测试代码
  28. package test.edu.xalead;
  30. import edu.xalead.util.JSONUtil;
  31. import net.sf.json.JSONObject;
  33. public class TestJSONUtil {
  35.     @org.junit.Test
  36.         public void test1(){
  38.             //创建学生对象
  39.             Student s=new Student();
  40.             s.setNo(222);
  41.             s.setAge(20);
  42.             s.setName("zhansgan");
  43.             Address adr=new Address();
  44.             adr.setHomeadr("未央区");
  45.             adr.setSchooladr("碑林区");
  46.             s.setAddress(adr);
  47.             System.out.println(JSONUtil.obj2json(s));
  48.         String jsonStr="{\"address\":{\"homeadr\":\"央区\",\"schooladr\":\"碑林区\"},\"age\":20,\"name\":\"zhansgan\",\"no\":22}";
  49.         Student ss=JSONUtil.json2obj(jsonStr,Student.class);
  50.         System.out.println(ss);
  51.         }
  52. }

编译结果
在这里插入图片描述
编写服务端启动类

  1. package edu.xalead.server;
  3. public class ServerStart {
  5.     public static void main(String[] args) {
  7.         new chatServer().start();
  8.     }
  9. }

写客户端
客户端知道服务器的地址和端口,先编写客户端类直连服务

  1. package edu.xalead.client;
  3. import edu.xalead.util.JSONUtil;
  4. import edu.xalead.vo.MessageVO;
  6. import javax.xml.crypto.Data;
  7. import java.io.BufferedReader;
  8. import java.io.IOException;
  9. import java.io.InputStreamReader;
  10. import java.io.PrintWriter;
  11. import java.net.Socket;
  14. import java.util.Date;
  15. import java.util.Scanner;
  17. public class ChatClient {
  19.     /**
  20.      * 服务器地址
  21.      */
  22.     private String addr="127.0.0.1";
  23.     Socket s=null;
  24.     /**
  25.      * 聊天服务端口
  26.      */
  27.     private int port=9999;
  28.     public  void start(){
  31.         try {
  33.             //客户知道服务器的地址和端口,直接创建套接字
  34.             s=new Socket(addr,port);
  35.             //启动两个监听服务线程
  36.             new ReceiveService().start();
  37.             new SendService().start();
  39.         } catch (Exception e) {
  41.             e.printStackTrace();
  42.         }
  43.     }
  44. }

客户端要做两件事：
1.监听服务器返回的消息，并输出到控制台
2.监听键盘消息，并发向服务器 很显然，这里需要两个客户线程

创建客户端接收线程
监听服务器返回的消息，并输出到控制台,因为离开客户端没有复用价值，所以我们也是写成 ChatClient类的内部类

  1. /**
  2.      * 创建监听键盘消息
  3.      */
  4.     private  class SendService extends Thread{
  6.         private PrintWriter pw=null;
  7.         public void run(){
  9.             try {
  11.                 while (true) {
  13.                     Scanner scanner =new Scanner(System.in);
  14.                     //接受键盘消息
  15.                     String mesg=scanner.nextLine();
  16.                     //封装MessageVO
  17.                     MessageVO vo= new MessageVO(mesg, new Date());
  18.                     //解析成json串
  19.                     String jsonStr=JSONUtil.obj2json(vo);
  20.                     //发送到服务器
  21.                     pw=new PrintWriter(s.getOutputStream());
  22.                     pw.println(jsonStr);
  23.                     pw.flush();
  24.                 }
  25.             } catch (Exception e) {
  27.                 e.printStackTrace();
  28.             }
  29.         }
  30. }

监听键盘消息，并发向服务器

  1. /**
  2.      * 创建监听服务器消息线程
  3.      */
  4.     private class ReceiveService extends Thread{
  6.         private BufferedReader br=null;
  7.         public void run(){
  9.             try {
  11.                 while (true) {
  13.                     br=new BufferedReader(
  14.                             new InputStreamReader(s.getInputStream()));
  15.                     //监听服务器发送过来的json字符串
  16.                     String jsonStr =br.readLine();
  17.                     //json串转换成对象
  18.                     MessageVO mvo= JSONUtil.json2obj(jsonStr,MessageVO.class);
  19.                     //在控制台输出
  20.                     System.out.println("info:"+mvo.getMesg()+"【时间："+mvo.getDate()+"】");
  21.                 }
  22.             } catch (Exception e) {
  24.                 e.printStackTrace();
  25.             }
  27.         }
  28.     }

最后，客户端要启动两个服务线程
在这里插入图片描述
两个监听线程均依赖网络套接字，所以启动线程的代码写在创建套接后就可以

最后，编写客户端的启动类

  1. package edu.xalead.client;
  3. public class ClientStart {
  5.     public static void main(String[] args) {
  7.         new ChatClient().start();
  8.     }
  9. }

结果
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

发表评论

表情：
评论列表 （有 0 条评论，343人围观）

还没有评论，来说两句吧...

相关阅读