使用java怎么实现一个局域网聊天小程序

这期内容当中小编将会给大家带来有关使用java怎么实现一个局域网聊天小程序，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。

创新互联2013年开创至今，是专业互联网技术服务公司，拥有项目成都网站建设、网站制作网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元兰西做网站,已为上家服务,为兰西各地企业和个人服务,联系电话:13518219792

Client.java  客户端代码

package chat;
 
import java.awt.BorderLayout;//布置容器的边框布局
import java.awt.Color;
import java.awt.Container;
import java.awt.GridLayout;//布局处理器
import java.awt.Toolkit;//抽象超类
import java.awt.event.ActionEvent;//指示发生了组件定义的动作的语义事件
import java.awt.event.ActionListener;//用于接收操作事件的侦听器接口
import java.awt.event.MouseEvent;//指示组件中发生鼠标动作的事件
import java.awt.event.MouseListener;//鼠标事件的侦听器接口
import java.awt.event.WindowAdapter;//接收窗口事件的抽象适配器类。此类中的方法为空。此类存在的目的是方便创建侦听器对象
import java.awt.event.WindowEvent;//指示窗口状态改变的低级别事件
import java.io.BufferedReader;//提供通用的缓冲方式文本读取
import java.io.IOException;//输入输出异常
import java.io.InputStreamReader;//字节流通向字符流的桥梁
import java.io.PrintWriter;//向文本输出流打印对象的格式化表示形式
import java.net.Socket;//套接字，网络上的两个程序通过一个双向的通信连接实现数据交换的通信
import java.util.HashMap;// HashMap 是 Map 接口的常用实现类
import java.util.Map;//存数据，将键映射到值的对象
import java.util.StringTokenizer;//允许应用程序将字符串分解为标记
 
import javax.swing.BorderFactory;//创建一个浮雕式的边框
import javax.swing.DefaultListModel;//列表模型
import javax.swing.JButton;//按钮
import javax.swing.JFrame;//窗口
import javax.swing.JLabel;//标签
import javax.swing.JList;//列表
import javax.swing.JOptionPane;//对话框
import javax.swing.JPanel;
import javax.swing.JScrollPane;//视图
import javax.swing.JSplitPane;//分隔
import javax.swing.JTextArea;//多行文本
import javax.swing.JTextField;//文本
import javax.swing.border.EmptyBorder;//一个占用空间但不执行绘制的空透明边框
import javax.swing.border.TitledBorder;//该类实现在指定位置以指定对齐方式显示字符串标题的任意边框
 
import oldchat.ChatFrame;
 
 
public class Client
{
 
 private JFrame frame;
 private JList userList;
 private JTextArea textArea;
 private JTextField textField;
 private JTextField txt_port;
 private JTextField txt_hostIp;
 private JTextField txt_name;
 private JButton btn_start;
 private JButton btn_stop;
 private JButton btn_send;
 private JPanel northPanel;
 private JPanel southPanel;
 private JScrollPane rightScroll;
 private JScrollPane leftScroll;
 private JSplitPane centerSplit;
 
 private DefaultListModel listModel;
 private boolean isConnected = false;
 
 private Socket socket;//创建套接字
 private PrintWriter writer;
 private BufferedReader reader;
 private MessageThread messageThread;// 负责接收消息的线程
 private Map onLineUsers = new HashMap();// 所有在线用户
 
 // 主方法,程序入口
 public static void main(String[] args) 
 {
 new Client();
 }
 
 // 执行发送
 public void send() 
 {
 if (!isConnected) 
 {
  JOptionPane.showMessageDialog(frame, "还没有连接服务器，无法发送消息！", "错误",
   JOptionPane.ERROR_MESSAGE);
  return;
 }
 String message = textField.getText().trim();
 if (message == null || message.equals("")) 
 {
  JOptionPane.showMessageDialog(frame, "消息不能为空！", "错误",
   JOptionPane.ERROR_MESSAGE);
  return;
 }
 sendMessage(frame.getTitle() + "@" + "ALL" + "@" + message);
 textField.setText(null);
 }
 
 // 构造方法
 public Client() 
 {
 textArea = new JTextArea();
 textArea.setEditable(false);
 textArea.setForeground(Color.blue);
 textField = new JTextField();
 txt_port = new JTextField("6666");
 txt_hostIp = new JTextField();
 txt_name = new JTextField();
 btn_start = new JButton("连接");
 btn_stop = new JButton("断开");
 btn_send = new JButton("发送");
 listModel = new DefaultListModel();
 userList = new JList(listModel);
 
 northPanel = new JPanel();
 northPanel.setLayout(new GridLayout(1, 7));
 northPanel.add(new JLabel("端口"));
 northPanel.add(txt_port);
 northPanel.add(new JLabel("服务器IP"));
 northPanel.add(txt_hostIp);
 northPanel.add(new JLabel("姓名"));
 northPanel.add(txt_name);
 northPanel.add(btn_start);
 northPanel.add(btn_stop);
 northPanel.setBorder(new TitledBorder("连接信息"));
 
 rightScroll = new JScrollPane(textArea);
 rightScroll.setBorder(new TitledBorder("群聊消息显示区"));
 leftScroll = new JScrollPane(userList);
 leftScroll.setBorder(new TitledBorder("在线用户(双击私聊)"));
 southPanel = new JPanel(new BorderLayout());
 southPanel.add(textField, "Center");
 southPanel.add(btn_send, "East");
 southPanel.setBorder(new TitledBorder("写消息"));
 
 centerSplit = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, leftScroll,
  rightScroll);
 centerSplit.setDividerLocation(100);
 
 frame = new JFrame("客户端");
 // 更改JFrame的图标：
 //frame.setIconImage(Toolkit.getDefaultToolkit().createImage(Client.class.getResource("qq.jpg")));
 frame.setLayout(new BorderLayout());
 frame.add(northPanel, "North");
 frame.add(centerSplit, "Center");
 frame.add(southPanel, "South");
 frame.setSize(600, 400);
 int screen_width = Toolkit.getDefaultToolkit().getScreenSize().width;
 int screen_height = Toolkit.getDefaultToolkit().getScreenSize().height;
 frame.setLocation((screen_width - frame.getWidth()) / 2,
  (screen_height - frame.getHeight()) / 2);
 frame.setVisible(true);
 
 // 写消息的文本框中按回车键时事件
 textField.addActionListener(new ActionListener() 
 {
  public void actionPerformed(ActionEvent arg0) 
  {
  send();
  }
 });
 
 // 单击发送按钮时事件
 btn_send.addActionListener(new ActionListener() 
 {
  public void actionPerformed(ActionEvent e) 
  {
  send();
  }
 });
 
 // 单击连接按钮时事件
 btn_start.addActionListener(new ActionListener() 
 {
  public void actionPerformed(ActionEvent e) 
  {
  int port;
  if (isConnected) {
   JOptionPane.showMessageDialog(frame, "已处于连接上状态，不要重复连接!",
    "错误", JOptionPane.ERROR_MESSAGE);
   return;
  }
  try {
   try {
   port = Integer.parseInt(txt_port.getText().trim());
   } catch (NumberFormatException e2) {
   throw new Exception("端口号不符合要求!端口为整数!");
   }
   String hostIp = txt_hostIp.getText().trim();
   String name = txt_name.getText().trim();
   if (name.equals("") || hostIp.equals("")) {
   throw new Exception("姓名、服务器IP不能为空!");
   }
   boolean flag = connectServer(port, hostIp, name);
   if (flag == false) {
   throw new Exception("与服务器连接失败!");
   }
   frame.setTitle(name);
   JOptionPane.showMessageDialog(frame, "成功连接!");
  } catch (Exception exc) {
   JOptionPane.showMessageDialog(frame, exc.getMessage(),
    "错误", JOptionPane.ERROR_MESSAGE);
  }
  }
 });
//双击聊天（私聊） 
 userList.addMouseListener(new MouseListener() 
 {
  
  public void mouseReleased(MouseEvent e) {}
  public void mousePressed(MouseEvent e) {}
  public void mouseExited(MouseEvent e) {}
  public void mouseEntered(MouseEvent e) {}
  public void mouseClicked(MouseEvent e) 
  {
  if(e.getClickCount()==2) 
  {
   User user=onLineUsers.get(userList.getSelectedValue());
    ChatFrame.main(user.getIp());;
  } 
  }
 });
 
 // 单击断开按钮时事件
 btn_stop.addActionListener(new ActionListener() 
 {
  public void actionPerformed(ActionEvent e) 
  {
  if (!isConnected) {
   JOptionPane.showMessageDialog(frame, "已处于断开状态，不要重复断开!",
    "错误", JOptionPane.ERROR_MESSAGE);
   return;
  }
  try {
   boolean flag = closeConnection();// 断开连接
   if (flag == false) {
   throw new Exception("断开连接发生异常！");
   }
   JOptionPane.showMessageDialog(frame, "成功断开!");
  } catch (Exception exc) {
   JOptionPane.showMessageDialog(frame, exc.getMessage(),
    "错误", JOptionPane.ERROR_MESSAGE);
  }
  }
 });
 
 // 关闭窗口时事件
 frame.addWindowListener(new WindowAdapter() 
 {
  public void windowClosing(WindowEvent e) 
  {
  if (isConnected) {
   closeConnection();// 关闭连接
  }
  System.exit(0);// 退出程序
  }
 });
 }
 
 /**
 * 连接服务器
 * 
 * @param port
 * @param hostIp
 * @param name
 */
 public boolean connectServer(int port, String hostIp, String name) 
 {
 // 连接服务器
 try {
  socket = new Socket(hostIp, port);// 根据端口号和服务器ip建立连接
  writer = new PrintWriter(socket.getOutputStream());
  reader = new BufferedReader(new InputStreamReader(socket
   .getInputStream()));
  // 发送客户端用户基本信息(用户名和ip地址)
  sendMessage(name + "@" + socket.getLocalAddress().toString());
  // 开启接收消息的线程
  messageThread = new MessageThread(reader, textArea);
  messageThread.start();
  isConnected = true;// 已经连接上了
  return true;
 } catch (Exception e) {
  textArea.append("与端口号为：" + port + "  IP地址为：" + hostIp
   + "  的服务器连接失败!" + "\r\n");
  isConnected = false;// 未连接上
  return false;
 }
 }
 
 /**
 * 发送消息
 * 
 * @param message
 */
 public void sendMessage(String message) 
 {
 writer.println(message);
 writer.flush();
 }
 
 /**
 * 客户端主动关闭连接
 */
 @SuppressWarnings("deprecation")
 public synchronized boolean closeConnection() 
 {
 try {
  sendMessage("CLOSE");// 发送断开连接命令给服务器
  messageThread.stop();// 停止接受消息线程
  // 释放资源
  if (reader != null) {
  reader.close();
  }
  if (writer != null) {
  writer.close();
  }
  if (socket != null) {
  socket.close();
  }
  isConnected = false;
  return true;
 } catch (IOException e1) {
  e1.printStackTrace();
  isConnected = true;
  return false;
 }
 }
 
 // 不断接收消息的线程
 class MessageThread extends Thread {
 private BufferedReader reader;
 private JTextArea textArea;
 
 // 接收消息线程的构造方法
 public MessageThread(BufferedReader reader, JTextArea textArea) 
 {
  this.reader = reader;
  this.textArea = textArea;
 }
 
 // 被动的关闭连接
 public synchronized void closeCon() throws Exception 
 {
  // 清空用户列表
  listModel.removeAllElements();
  // 被动的关闭连接释放资源
  if (reader != null) {
  reader.close();
  }
  if (writer != null) {
  writer.close();
  }
  if (socket != null) {
  socket.close();
  }
  isConnected = false;// 修改状态为断开
 }
 
 public void run() {
  String message = "";
  while (true) {
  try {
   message = reader.readLine();
   StringTokenizer stringTokenizer = new StringTokenizer(message, "/@");
   String command = stringTokenizer.nextToken();// 命令
   if (command.equals("CLOSE"))// 服务器已关闭命令
   {
   textArea.append("服务器已关闭!\r\n");
   closeCon();// 被动的关闭连接
   return;// 结束线程
   } else if (command.equals("ADD")) {// 有用户上线更新在线列表
   String username = "";
   String userIp = "";
   if ((username = stringTokenizer.nextToken()) != null
    && (userIp = stringTokenizer.nextToken()) != null) 
   {
    User user = new User(username, userIp);
    onLineUsers.put(username, user);
    listModel.addElement(username);
   }
   } else if (command.equals("DELETE")) {// 有用户下线更新在线列表
   String username = stringTokenizer.nextToken();
   User user = (User) onLineUsers.get(username);
   onLineUsers.remove(user);
   listModel.removeElement(username);
   } else if (command.equals("USERLIST")) {// 加载在线用户列表
   int size = Integer
    .parseInt(stringTokenizer.nextToken());
   String username = null;
   String userIp = null;
   for (int i = 0; i < size; i++) {
    username = stringTokenizer.nextToken();
    userIp = stringTokenizer.nextToken();
    User user = new User(username, userIp);
    onLineUsers.put(username, user);
    listModel.addElement(username);
   }
   } else if (command.equals("MAX")) {// 人数已达上限
   textArea.append(stringTokenizer.nextToken()
    + stringTokenizer.nextToken() + "\r\n");
   closeCon();// 被动的关闭连接
   JOptionPane.showMessageDialog(frame, "服务器缓冲区已满！", "错误",
    JOptionPane.ERROR_MESSAGE);
   return;// 结束线程
   } else {// 普通消息
   textArea.append(message + "\r\n");
   }
  } catch (IOException e) {
   e.printStackTrace();
  } catch (Exception e) {
   e.printStackTrace();
  }
  }
 }
 }
 
}

Server.java

package chat;
 
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.GridLayout;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.BindException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.StringTokenizer;
 
import javax.swing.DefaultListModel;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.border.TitledBorder;
 
public class Server 
{
 
 private JFrame frame;
 private JTextArea contentArea;
 private JTextField txt_message;
 private JTextField txt_max;
 private JTextField txt_port;
 private JButton btn_start;
 private JButton btn_stop;
 private JButton btn_send;
 private JPanel northPanel;
 private JPanel southPanel;
 private JScrollPane rightPanel;
 private JScrollPane leftPanel;
 private JSplitPane centerSplit;
 private JList userList;
 private DefaultListModel listModel;
 
 private ServerSocket serverSocket;
 private ServerThread serverThread;
 private ArrayList clients;
 
 private boolean isStart = false;
 
 // 主方法,程序执行入口
 public static void main(String[] args) 
 {
 new Server();
 }
 
 // 执行消息发送
 public void send() 
 {
 if (!isStart) 
 {
  JOptionPane.showMessageDialog(frame, "服务器还未启动,不能发送消息！", "错误",
   JOptionPane.ERROR_MESSAGE);
  return;
 }
 if (clients.size() == 0) 
 {
  JOptionPane.showMessageDialog(frame, "没有用户在线,不能发送消息！", "错误",
   JOptionPane.ERROR_MESSAGE);
  return;
 }
 String message = txt_message.getText().trim();
 if (message == null || message.equals("")) 
 {
  JOptionPane.showMessageDialog(frame, "消息不能为空！", "错误",
   JOptionPane.ERROR_MESSAGE);
  return;
 }
 sendServerMessage(message);// 群发服务器消息
 contentArea.append("服务器说：" + txt_message.getText() + "\r\n");
 txt_message.setText(null);
 }
 
 // 构造放法
 public Server() 
 {
 frame = new JFrame("服务器");
 // 更改JFrame的图标：
 //frame.setIconImage(Toolkit.getDefaultToolkit().createImage(Client.class.getResource("qq.png")));
 //frame.setIconImage(Toolkit.getDefaultToolkit().createImage(Server.class.getResource("qq.jpg")));
 contentArea = new JTextArea();
 contentArea.setEditable(false);
 contentArea.setForeground(Color.blue);
 txt_message = new JTextField();
 txt_max = new JTextField("30");
 txt_port = new JTextField("6666");
 btn_start = new JButton("启动");
 btn_stop = new JButton("停止");
 btn_send = new JButton("发送");
 btn_stop.setEnabled(false);
 listModel = new DefaultListModel();
 userList = new JList(listModel);
 
 southPanel = new JPanel(new BorderLayout());
 southPanel.setBorder(new TitledBorder("写消息"));
 southPanel.add(txt_message, "Center");
 southPanel.add(btn_send, "East");
 leftPanel = new JScrollPane(userList);
 leftPanel.setBorder(new TitledBorder("在线用户"));
 
 rightPanel = new JScrollPane(contentArea);
 rightPanel.setBorder(new TitledBorder("群聊消息显示区"));
 
 centerSplit = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, leftPanel,
  rightPanel);
 centerSplit.setDividerLocation(100);
 northPanel = new JPanel();
 northPanel.setLayout(new GridLayout(1, 6));
 northPanel.add(new JLabel("人数上限"));
 northPanel.add(txt_max);
 northPanel.add(new JLabel("端口"));
 northPanel.add(txt_port);
 northPanel.add(btn_start);
 northPanel.add(btn_stop);
 northPanel.setBorder(new TitledBorder("配置信息"));
 
 frame.setLayout(new BorderLayout());
 frame.add(northPanel, "North");
 frame.add(centerSplit, "Center");
 frame.add(southPanel, "South");
 frame.setSize(600, 400);
 //frame.setSize(Toolkit.getDefaultToolkit().getScreenSize());//设置全屏
 int screen_width = Toolkit.getDefaultToolkit().getScreenSize().width;
 int screen_height = Toolkit.getDefaultToolkit().getScreenSize().height;
 frame.setLocation((screen_width - frame.getWidth()) / 2,
  (screen_height - frame.getHeight()) / 2);
 frame.setVisible(true);
 
 // 关闭窗口时事件
 frame.addWindowListener(new WindowAdapter() 
 {
  public void windowClosing(WindowEvent e) 
  {
  if (isStart) {
   closeServer();// 关闭服务器
  }
  System.exit(0);// 退出程序
  }
 });
 
 // 文本框按回车键时事件
 txt_message.addActionListener(new ActionListener() 
 {
  public void actionPerformed(ActionEvent e) 
  {
  send();
  }
 });
 
 // 单击发送按钮时事件
 btn_send.addActionListener(new ActionListener() 
 {
  public void actionPerformed(ActionEvent arg0) 
  {
  send();
  }
 });
 
 // 单击启动服务器按钮时事件
 btn_start.addActionListener(new ActionListener() 
 {
  public void actionPerformed(ActionEvent e) 
  {
  if (isStart) {
   JOptionPane.showMessageDialog(frame, "服务器已处于启动状态，不要重复启动！",
    "错误", JOptionPane.ERROR_MESSAGE);
   return;
  }
  int max;
  int port;
  try {
   try {
   max = Integer.parseInt(txt_max.getText());
   } catch (Exception e1) {
   throw new Exception("人数上限为正整数！");
   }
   if (max <= 0) {
   throw new Exception("人数上限为正整数！");
   }
   try {
   port = Integer.parseInt(txt_port.getText());
   } catch (Exception e1) {
   throw new Exception("端口号为正整数！");
   }
   if (port <= 0) {
   throw new Exception("端口号 为正整数！");
   }
   serverStart(max, port);
   contentArea.append("服务器已成功启动!人数上限：" + max + ",端口：" + port
    + "\r\n");
   JOptionPane.showMessageDialog(frame, "服务器成功启动!");
   btn_start.setEnabled(false);
   txt_max.setEnabled(false);
   txt_port.setEnabled(false);
   btn_stop.setEnabled(true);
  } catch (Exception exc) {
   JOptionPane.showMessageDialog(frame, exc.getMessage(),
    "错误", JOptionPane.ERROR_MESSAGE);
  }
  }
 });
 
 // 单击停止服务器按钮时事件
 btn_stop.addActionListener(new ActionListener() 
 {
  public void actionPerformed(ActionEvent e) 
  {
  if (!isStart) {
   JOptionPane.showMessageDialog(frame, "服务器还未启动，无需停止！", "错误",
    JOptionPane.ERROR_MESSAGE);
   return;
  }
  try {
   closeServer();
   btn_start.setEnabled(true);
   txt_max.setEnabled(true);
   txt_port.setEnabled(true);
   btn_stop.setEnabled(false);
   contentArea.append("服务器成功停止!\r\n");
   JOptionPane.showMessageDialog(frame, "服务器成功停止！");
  } catch (Exception exc) {
   JOptionPane.showMessageDialog(frame, "停止服务器发生异常！", "错误",
    JOptionPane.ERROR_MESSAGE);
  }
  }
 });
 }
 
 // 启动服务器
 public void serverStart(int max, int port) throws java.net.BindException 
 {
 try {
  clients = new ArrayList();
  serverSocket = new ServerSocket(port);
  serverThread = new ServerThread(serverSocket, max);
  serverThread.start();
  isStart = true;
 } catch (BindException e) {
  isStart = false;
  throw new BindException("端口号已被占用，请换一个！");
 } catch (Exception e1) {
  e1.printStackTrace();
  isStart = false;
  throw new BindException("启动服务器异常！");
 }
 }
 
 // 关闭服务器
 @SuppressWarnings("deprecation")
 public void closeServer() {
 try {
  if (serverThread != null)
  serverThread.stop();// 停止服务器线程
 
  for (int i = clients.size() - 1; i >= 0; i--) {
  // 给所有在线用户发送关闭命令
  clients.get(i).getWriter().println("CLOSE");
  clients.get(i).getWriter().flush();
  // 释放资源
  clients.get(i).stop();// 停止此条为客户端服务的线程
  clients.get(i).reader.close();
  clients.get(i).writer.close();
  clients.get(i).socket.close();
  clients.remove(i);
  }
  if (serverSocket != null) {
  serverSocket.close();// 关闭服务器端连接
  }
  listModel.removeAllElements();// 清空用户列表
  isStart = false;
 } catch (IOException e) {
  e.printStackTrace();
  isStart = true;
 }
 }
 
 // 群发服务器消息
 public void sendServerMessage(String message) {
 for (int i = clients.size() - 1; i >= 0; i--) {
  clients.get(i).getWriter().println("服务器：" + message);
  clients.get(i).getWriter().flush();
 }
 }
 
 // 服务器线程
 class ServerThread extends Thread {
 private ServerSocket serverSocket;
 private int max;// 人数上限
 
 // 服务器线程的构造方法
 public ServerThread(ServerSocket serverSocket, int max) {
  this.serverSocket = serverSocket;
  this.max = max;
 }
 
 public void run() {
  while (true) {// 不停的等待客户端的链接
  try {
   Socket socket = serverSocket.accept();
   if (clients.size() == max) {// 如果已达人数上限
   BufferedReader r = new BufferedReader(
    new InputStreamReader(socket.getInputStream()));
   PrintWriter w = new PrintWriter(socket
    .getOutputStream());
   // 接收客户端的基本用户信息
   String inf = r.readLine();
   StringTokenizer st = new StringTokenizer(inf, "@");
   User user = new User(st.nextToken(), st.nextToken());
   // 反馈连接成功信息
   w.println("MAX@服务器：对不起，" + user.getName()
    + user.getIp() + "，服务器在线人数已达上限，请稍后尝试连接！");
   w.flush();
   // 释放资源
   r.close();
   w.close();
   socket.close();
   continue;
   }
   ClientThread client = new ClientThread(socket);
   client.start();// 开启对此客户端服务的线程
   clients.add(client);
   listModel.addElement(client.getUser().getName());// 更新在线列表
   contentArea.append(client.getUser().getName()
    + client.getUser().getIp() + "上线!\r\n");
  } catch (IOException e) {
   e.printStackTrace();
  }
  }
 }
 }
 
 // 为一个客户端服务的线程
 class ClientThread extends Thread 
 {
 private Socket socket;
 private BufferedReader reader;
 private PrintWriter writer;
 private User user;
 
 public BufferedReader getReader() 
 {
  return reader;
 }
 
 public PrintWriter getWriter() 
 {
  return writer;
 }
 
 public User getUser() 
 {
  return user;
 }
 
 // 客户端线程的构造方法
 public ClientThread(Socket socket) 
 {
  try {
  this.socket = socket;
  reader = new BufferedReader(new InputStreamReader(socket
   .getInputStream()));
  writer = new PrintWriter(socket.getOutputStream());
  // 接收客户端的基本用户信息
  String inf = reader.readLine();
  StringTokenizer st = new StringTokenizer(inf, "@");
  user = new User(st.nextToken(), st.nextToken());
  // 反馈连接成功信息
  writer.println(user.getName() + user.getIp() + "与服务器连接成功!");
  writer.flush();
  // 反馈当前在线用户信息
  if (clients.size() > 0) 
  {
   String temp = "";
   for (int i = clients.size() - 1; i >= 0; i--) 
   {
   temp += (clients.get(i).getUser().getName() + "/" + clients
    .get(i).getUser().getIp())
    + "@";
   }
   writer.println("USERLIST@" + clients.size() + "@" + temp);
   writer.flush();
  }
  // 向所有在线用户发送该用户上线命令
  for (int i = clients.size() - 1; i >= 0; i--) 
  {
   clients.get(i).getWriter().println(
    "ADD@" + user.getName() + user.getIp());
   clients.get(i).getWriter().flush();
  }
  } catch (IOException e) 
  {
  e.printStackTrace();
  }
 }
 
 @SuppressWarnings("deprecation")
 public void run() {// 不断接收客户端的消息，进行处理。
  String message = null;
  while (true) {
  try {
   message = reader.readLine();// 接收客户端消息
   if (message.equals("CLOSE"))// 下线命令
   {
   contentArea.append(this.getUser().getName()
    + this.getUser().getIp() + "下线!\r\n");
   // 断开连接释放资源
   reader.close();
   writer.close();
   socket.close();
 
   // 向所有在线用户发送该用户的下线命令
   for (int i = clients.size() - 1; i >= 0; i--) 
   {
    clients.get(i).getWriter().println(
     "DELETE@" + user.getName());
    clients.get(i).getWriter().flush();
   }
 
   listModel.removeElement(user.getName());// 更新在线列表
 
   // 删除此条客户端服务线程
   for (int i = clients.size() - 1; i >= 0; i--) 
   {
    if (clients.get(i).getUser() == user) 
    {
    ClientThread temp = clients.get(i);
    clients.remove(i);// 删除此用户的服务线程
    temp.stop();// 停止这条服务线程
    return;
    }
   }
   } else {
   dispatcherMessage(message);// 转发消息
   }
  } catch (IOException e) 
  {
   e.printStackTrace();
  }
  }
 }
 
 // 转发消息
 public void dispatcherMessage(String message) 
 {
  StringTokenizer stringTokenizer = new StringTokenizer(message, "@");
  String source = stringTokenizer.nextToken();
  String owner = stringTokenizer.nextToken();
  String content = stringTokenizer.nextToken();
  message = source + "说：" + content;
  contentArea.append(message + "\r\n");
  if (owner.equals("ALL")) {// 群发
  for (int i = clients.size() - 1; i >= 0; i--) {
   clients.get(i).getWriter().println(message);
   clients.get(i).getWriter().flush();
  }
  }
 }
 }
}

运行截图

上述就是小编为大家分享的使用java怎么实现一个局域网聊天小程序了，如果刚好有类似的疑惑，不妨参照上述分析进行理解。如果想知道更多相关知识，欢迎关注创新互联行业资讯频道。