皮皮网

1.java实现聊天室是线聊a线怎么做到的？
2.java是如何实现客服在线聊天功能的？
3.Java简单聊天程序
4.用Java实现一个人和几个不同的人私聊，用Socket实现
5.java开发聊天功能用什么技术比较好？

java实现聊天室是怎么做到的？

       Java 实现聊天室可以分为以下几个步骤：

       建立服务器端

       首先需要建立一个服务器端，负责接收客户端的天源连接请求并处理客户端发送过来的消息。

       建立客户端

       然后需要建立客户端，聊天客户端通过网络连接到服务器端，线聊a线并向服务器端发送消息。天源

       实现通信协议

       为了实现聊天室功能，聊天永中office源码需要定义一个通信协议，线聊a线规定客户端和服务器端之间的天源通信格式，例如消息的聊天头部和内容等。

       实现多线程处理

       聊天室通常会有多个用户同时在线，线聊a线因此需要使用多线程来处理多个客户端的天源连接请求和消息传递。

       实现GUI界面（可选）

       为了方便用户使用，聊天可以实现一个GUI界面，线聊a线让用户可以方便地发送和接收消息。天源

       以下是聊天通达信筹码源码一个简单的 Java 聊天室的代码示例：

       java

       Copy code

       // 服务器端代码

       public class Server {

        public static void main(String[] args) {

        try {

        ServerSocket serverSocket = new ServerSocket();

        while (true) {

        Socket socket = serverSocket.accept();

        new Thread(new ServerThread(socket)).start();

        }

        } catch (IOException e) {

        e.printStackTrace();

        }

        }

       }

       class ServerThread implements Runnable {

        private Socket socket;

        private BufferedReader reader;

        private PrintWriter writer;

        public ServerThread(Socket socket) {

        this.socket = socket;

        try {

        reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));

        writer = new PrintWriter(socket.getOutputStream());

        } catch (IOException e) {

        e.printStackTrace();

        }

        }

        public void run() {

        try {

        String msg;

        while ((msg = reader.readLine()) != null) {

        // 处理客户端发送过来的消息

        System.out.println("接收到消息：" + msg);

        // 将消息发送给所有客户端

        for (Socket s : ServerThreadList.getList()) {

        if (s != socket) {

        PrintWriter w = new PrintWriter(s.getOutputStream());

        w.println(msg);

        w.flush();

        }

        }

        }

        // 关闭连接

        socket.close();

        ServerThreadList.removeThread(this);

        } catch (IOException e) {

        e.printStackTrace();

        }

        }

       }

       class ServerThreadList {

        private static List

        list = new ArrayList<>();

        public static void addThread(ServerThread thread) {

        list.add(thread);

        }

        public static void removeThread(ServerThread thread) {

        list.remove(thread);

        }

        public static List

        getList() {

        return list;

        }

       }

       // 客户端代码

       public class Client {

        public static void main(String[] args) {

        try {

        Socket socket = new Socket("localhost", );

        new Thread(new ClientThread(socket)).start();

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        PrintWriter writer = new PrintWriter(socket.getOutputStream());

        while (true) {

        String msg = reader.readLine();

        writer.println(msg);

        writer.flush();

        }

        } catch (IOException e) {

        e.printStackTrace();

        }

        }

       }

       class ClientThread implements Runnable {

        private Socket socket;

        private BufferedReader reader;

        public ClientThread(Socket socket) {

        this.socket = socket;

        try {

        reader

java是如何实现客服在线聊天功能的？

       Java 实现在线客服聊天功能的具体方式会因具体实现技术和业务需求不同而异，以下是一个可能的实现思路：

       客户端和服务端之间的通信协议：在实现在线聊天功能的时候，需要考虑客户端和服务端之间的通信协议。可以使用 WebSocket 协议，这是一种全双工通信协议，支持客户端和服务端之间的实时通信。Java 提供了多个 WebSocket 实现，比如 Tyrus、引导页自动跳转源码Jetty 和 Netty。

       实现服务端：在服务端实现在线聊天功能，需要创建 WebSocket 服务器，并实现消息处理逻辑。在 Java 中，可以使用 Java WebSocket API，该 API 提供了 javax.websocket 包中的月老盲盒系统源码类和接口，可以方便地创建 WebSocket 服务器和处理 WebSocket 消息。

       在服务端，需要实现 WebSocket 端点（Endpoint），处理客户端连接、断开连接以及收发消息等操作。可以通过扩展 javax.websocket.Endpoint 类，重写 onOpen、trw调试器 源码onClose 和 onMessage 方法来处理相应的操作。

       实现客户端：在客户端实现在线聊天功能，需要创建 WebSocket 客户端，并实现消息处理逻辑。Java 提供了多个 WebSocket 客户端实现，比如 Tyrus、Jetty 和 Netty。

       在客户端，可以使用 Java WebSocket API 提供的 javax.websocket 包中的类和接口来实现 WebSocket 客户端。需要使用 javax.websocket.ClientEndpoint 注解来标记客户端类，并使用 javax.websocket.Session 类来处理客户端连接、断开连接以及收发消息等操作。

       存储聊天记录：在实现在线聊天功能时，需要考虑如何存储聊天记录。可以使用数据库或者文件等方式存储聊天记录，具体实现可以依据具体业务需求。

       以上是一种可能的实现思路，实现在线聊天功能需要考虑很多具体细节，包括客户端和服务端的具体实现、消息处理逻辑、聊天记录存储等。

Java简单聊天程序

       package com.kum.im.hrserver.test;

       import java.net.*;

       import java.nio.*;

       import java.nio.channels.*;

       import java.nio.charset.*;

       import java.awt.*;

       import java.awt.event.*;

       public class ChatClient {

        private SocketChannel sc = null;

        private String name = null;

        private Frame f;

        private TextArea ta;

        private TextField tf;

        private boolean runnable = true;

        public static void main(String[] args){

        ChatClient cc = new ChatClient();

        cc.createUI();

        cc.inputName();

        cc.connect();

        new ReceiveThread(cc,cc.getTextArea()).start();

        }

        public SocketChannel getSc(){

        return sc;

        }

        public void setName(String name){

        this.name = name;

        }

        public TextArea getTextArea(){

        return ta;

        }

        public TextField getTextField(){

        return tf;

        }

        public boolean getRunnable(){

        return runnable;

        }

        public void stop(){

        runnable = false;

        }

        public void shutDown(){

        try{

        sc.write(ByteBuffer.wrap("bye".getBytes("UTF-8")));

        ta.append("Exit in 5 seconds!");

        this.stop();

        Thread.sleep();

        sc.close();

        }catch(Exception e){

        e.printStackTrace();

        }

        System.exit(0);

        }

        public void createUI(){

        f = new Frame("Client");

        ta = new TextArea();

        ta.setEditable(false);

        tf = new TextField();

        Button send = new Button("Send");

        Panel p = new Panel();

        p.setLayout(new BorderLayout());

        p.add(tf,"Center");

        p.add(send,"East");

        f.add(ta,"Center");

        f.add(p,"South");

        MyClientListener listener = new MyClientListener(this);

        send.addActionListener(listener);

        tf.addActionListener(listener);

        f.addWindowListener(new WindowAdapter(){

        public void windowClosing(WindowEvent e){

        ChatClient.this.shutDown();

        }

        });

        f.setSize(,);

        f.setLocation(,0);

        f.setVisible(true);

        tf.requestFocus();

        }

        public boolean connect(){

        try{

        sc = SocketChannel.open();

        //"zlg"为目标计算机名

        InetSocketAddress isa = new InetSocketAddress("..1.",);

        sc.connect(isa);

        sc.configureBlocking(false);

        sc.write(ByteBuffer.wrap(name.getBytes("UTF-8")));

        }catch(Exception e){

        e.printStackTrace();

        }

        return true;

        }

        public void inputName(){

        String name = javax.swing.JOptionPane.showInputDialog("Input Your Name:");

        this.setName(name);

        f.setTitle(name);

        }

       }

       class MyClientListener implements ActionListener{

        private ChatClient client;

        public MyClientListener(ChatClient client){

        this.client = client;

        }

        public void actionPerformed(ActionEvent e){

        TextField tf = client.getTextField();

        String info = tf.getText();

        if(info.equals("bye")){

        client.shutDown();

        }else{

        try{

        client.getSc().write(ByteBuffer.wrap(info.getBytes("UTF-8")));

        }catch (Exception e1) {

        e1.printStackTrace();

        }

        }

        tf.setText("");

        tf.requestFocus();

        }

       }

       class ReceiveThread extends Thread{

        private ChatClient client;

        private TextArea ta;

        public ReceiveThread(ChatClient client,TextArea ta){

        this.client = client;

        this.ta = ta;

        }

        public void run(){

        SocketChannel sc = client.getSc();

        ByteBuffer byteBuffer = ByteBuffer.allocate();

        CharBuffer charBuffer = null;

        Charset charset = Charset.forName("UTF-8");

        CharsetDecoder decoder = charset.newDecoder();

        String msg = null;

        int n = 0;

        try{

        while(client.getRunnable()){

        n = sc.read(byteBuffer);

        if(n>0){

        byteBuffer.flip();

        charBuffer = decoder.decode(byteBuffer);

        msg = charBuffer.toString();

        ta.append(msg + "\n");

        }

        byteBuffer.clear();

        Thread.sleep();

        }

        }catch(Exception e){

        e.printStackTrace();

        System.exit(0);

        }

        }

       }

       import java.io.*;

       import java.nio.*;

       import java.nio.channels.*;

       import java.nio.charset.*;

       import java.net.*;

       import java.util.*;

       public class ICQServer {

        private Selector selector = null;

        private ServerSocketChannel ssc = null;

        //服务器端通信端口号

        private int port = ;

        //在线用户列表

        private Hashtable<String, SocketChannel> userList = null;

        public ICQServer() { }

        public ICQServer(int port) {

        this.port = port;

        }

        //初始化服务器

        public void init() {

        try {

        //创建选择器对象

        selector = Selector.open();

        //创建ServerSocketChannel

        ssc = ServerSocketChannel.open();

        //设置ServerSocketChannel为非阻塞模式

        ssc.configureBlocking(false);

        InetAddress ip = InetAddress.getLocalHost();

        System.out.println("主机地址 --------> " + ip);

        InetSocketAddress isa = new InetSocketAddress(ip, port);

        //将与本通道相关的服务器套接字对象绑定到指定地址和端口

        ssc.socket().bind(isa);

        //创建在线用户列表

        userList = new Hashtable<String, SocketChannel> ();

        }

        catch (IOException e) {

        System.out.println("初始化服务器时异常，原因 --------> " + e.getMessage());

        }

        }

        //启动服务器

        public void start() {

        try {

        //将ServerSocketChannel注册到Selector上，准备接收新连接请求

        SelectionKey acceptKey = ssc.register(selector, SelectionKey.OP_ACCEPT);

        SocketChannel sc;

        int n;

        String name; //用户名

        String msg; //用户发言信息

        while (true) {

        //选择当前所有处于就绪状态的通道所对应的选择键,并将这些键组成已选择键集

        n = selector.select(); //n为已选择键集中键的个数

        if (n > 0) {

        //获取此选择器的已选择键集。

        Set readyKeys = selector.selectedKeys();

        Iterator it = readyKeys.iterator();

        //遍历当前已选择键集

        while (it.hasNext()) {

        SelectionKey key = (SelectionKey) it.next();

        //从当前已选择键集中移除当前键，避免重复处理

        it.remove();

        //如果当前键对应的通道已准备好接受新的套接字连接

        if (key.isAcceptable()) {

        //获取当前键对应的可选择通道（ServerSocketChannel）

        ssc = (ServerSocketChannel) key.channel();

        //接收新的套接字连接请求，返回新建的SocketChannel

        sc = (SocketChannel) ssc.accept();

        //如果有新用户接入

        if (sc != null) {

        //接收新上线用户姓名

        name = readMessage(sc);

        //设置新建的SocketChannel为非阻塞模式

        sc.configureBlocking(false);

        //将新建的SocketChannel注册到Selector上，准备进行数据"写"操作，

        //并将当前用户名以附件的方式附带记录到新建的选择键上。

        SelectionKey newKey = sc.register(selector,

        SelectionKey.OP_WRITE, name);

        //将新上线用户信息加入到在线用户列表

        userList.put(name, sc);

        //发送"新用户上线"通知

        transmitMessage(name + " in!", "--Server Info--");

        }

        }

        //否则，如果当前键对应的通道已准备好进行"写"操作

        else if (key.isWritable()) {

        //获取当前键对应的可选择通道（SocketChannel）

        sc = (SocketChannel) key.channel();

        //接收该通道相应用户的发言信息

        msg = readMessage(sc);

        //获取选择键上附带记录的当前用户名

        name = key.attachment().toString();

        //如果用户提出要下线

        if (msg.equals("bye")) {

        //从在线用户列表中移除当前用户

        userList.remove(name);

        //注销当前选择键对应的注册关系

        key.cancel();

        //关闭当前可选择通道

        sc.close();

        //发送"用户下线"通知

        transmitMessage(name + " out!", "--Server Info--");

        }

        //否则，如果接收到的用户发言信息非空（""）

        else if (msg.length() > 0) {

        //转发用户发言信息

        transmitMessage(msg, name);

        }

        }

        }

        }

        //延时循环，降低服务器端处理负荷

        Thread.sleep();

        }

        }

        catch (Exception e) {

        System.out.println("启动服务器时异常，原因 --------> " + e.getMessage());

        }

        }

        //转发用户发言信息

        public void transmitMessage(String msg, String name) {

        try {

        ByteBuffer buffer = ByteBuffer.wrap( (name + ":" + msg).getBytes("UTF-8"));

        //将字节数组包装到缓冲区中

        Collection channels = userList.values();

        SocketChannel sc;

        for (Object o : channels) {

        sc = (SocketChannel) o;

        sc.write(buffer);

        //将缓冲区数据写入聊天面板(TextArea)

        buffer.flip();

        //将缓冲区ByteBuffer的极限值设置为当前数据实际大小，将缓冲区的值设置为0

        }

        }

        catch (Exception e) {

        System.out.println("转发用户发言信息时异常，原因 --------> " + e.getMessage());

        }

        }

        //接收用户发言信息

        public String readMessage(SocketChannel sc) {

        String result = null;

        int n = 0;

        ByteBuffer buf = ByteBuffer.allocate();

        try {

        n = sc.read(buf);

        buf.flip();

        Charset charset = Charset.forName("UTF-8");

        CharsetDecoder decoder = charset.newDecoder();

        CharBuffer charBuffer = decoder.decode(buf);

        result = charBuffer.toString();

        }

        catch (IOException e) {

        System.out.println("接收用户发言信息时异常，原因 --------> " + e.getMessage());

        }

        return result;

        }

        public static void main(String args[]) {

        ICQServer server = new ICQServer();

        server.init();

        server.start();

        }

       }

用Java实现一个人和几个不同的人私聊，用Socket实现

       package API_Day;

       import java.io.BufferedReader;

       import java.io.IOException;

       import java.io.InputStream;

       import java.io.InputStreamReader;

       import java.io.OutputStream;

       import java.io.OutputStreamWriter;

       import java.io.PrintWriter;

       import java.net.Socket;

       import java.util.Scanner;

       /

**

        * 控制台聊天程序

        * 客户端应用程序

        * @author Jacob

       

*

        */

       public class chatClient

       {

        //客户端用于与服务端连接的Socket

        private Socket clientSocket;

        /

**

        * 构造方法，客户端初始化

        */

        public chatClient()

        {

        try

        {

        /

*

        * socket(String host, int port)

        * 地址： IP地址，用来定位网络上的计算机

        * 端口： 用来找到远端计算机上用来连接的服务端应用程序

        */

        clientSocket = new Socket("localhost",);

        }

        catch (Exception e)

        {

        e.printStackTrace();

        }

        }

        /

**

        * 客户端昵称验证方法

        * @param 为Scanner

        */

        private void inputNickName(Scanner scan) throws Exception

        {

        String nickName = null;

        //创建输出流

        PrintWriter pw = new PrintWriter(

        new OutputStreamWriter(clientSocket.getOutputStream(),

        "UTF-8"),true);

        //创建输入流

        BufferedReader br = new BufferedReader(

        new InputStreamReader(

        clientSocket.getInputStream(),"UTF-8"));

        while(true)

        {

        System.out.println("请创建您的昵称：");

        nickName = scan.nextLine();

        if (nickName.trim().equals(""))

        {

        System.out.println("昵称不得为空");

        }

        else

        {

        pw.println(nickName);

        String pass = br.readLine();

        if(pass!=null&&!pass.equals("OK"))

        {

        System.out.println("昵称已经被占用，请更换！");

        }

        else

        {

        System.out.println("你好！"+nickName+"可以开始聊天了");

        break;

        }

        }

        }

        }

        /

*

        * 客户端启动的方法

        */

        public void start()

        {

        try

        {

        /

*

        * 创建Scanner，读取用户输入内容

        * 目的是设置客户端的昵称

        */

        Scanner scanner = new Scanner(System.in);

        inputNickName(scanner);

        /

*

        * 将用于接收服务器端发送过来的信息的线程启动

        */

        Runnable run = new GetServerMsgHandler();

        Thread t = new Thread(run);

        t.start();

        /

*

        * 建立输出流，给服务端发信息

        */

        OutputStream os = clientSocket.getOutputStream();

        OutputStreamWriter osw = new OutputStreamWriter(os,"UTF-8");

        PrintWriter pw = new PrintWriter(osw,true);

        while(true)

        {

        pw.println(scanner.nextLine());

        }

        }

        catch(Exception e)

        {

        e.printStackTrace();

        }

        finally

        {

        if(clientSocket !=null)

        {

        try

        {

        clientSocket.close();

        }

        catch(IOException e)

        {

        e.printStackTrace();

        }

        }

        }

        }

        /

**

        * 该线程体用来循环读取服务端发送过来的信息

        * 并输出到客户端的控制台

        * @param args

        */

        class GetServerMsgHandler implements Runnable

        {

       @Override

        public void run()

        {

        try

        {

        InputStream is = clientSocket.getInputStream();

        InputStreamReader isr = new InputStreamReader(is,"UTF-8");

        BufferedReader br = new BufferedReader(isr);

        String msgString = null;

        while((msgString = br.readLine())!= null)

        {

        System.out.println("服务端提示："+ msgString);

        }

        }

        catch(Exception e)

        {

        e.printStackTrace();

        }

        }

        }

        public static void main(String[] args)

        {

        chatClient client = new chatClient();

        client.start();

        }

       }

       package API_Day;

       import java.io.BufferedReader;

       import java.io.IOException;

       import java.io.InputStream;

       import java.io.InputStreamReader;

       import java.io.OutputStream;

       import java.io.OutputStreamWriter;

       import java.io.PrintWriter;

       import java.net.ServerSocket;

       import java.net.Socket;

       import java.util.HashMap;

       import java.util.Map;

       import java.util.concurrent.ExecutorService;

       import java.util.concurrent.Executors;

       /

**

        * 控制台聊天程序

        * 服务端应用程序

        * @author Jacob

       

*

        */

       public class chatServer

       {

        /

**

        * ServerSocket 是运行在服务端的Socket

        * 用来监听端口，等待客户端的连接，

        * 一旦连接成功就会返回与该客户端通信的Socket

        */

        private ServerSocket serverSocket;

        /

**

        * 创建线程池来管理客户端的连接线程

        * 避免系统资源过度浪费

        */

        private ExecutorService threadPool;

        /

**

        * 该属性用来存放客户端之间私聊的信息

        */

        private Map<String,PrintWriter> allOut;

        /

**

        * 构造方法，服务端初始化

        */

        public chatServer()

        {

        try

        {

        /

*

        * 创建ServerSocket，并申请服务端口

        * 将来客户端就是通过该端口连接服务端程序的

        */

        serverSocket = new ServerSocket();

        /

*

        * 初始化Map集合，存放客户端信息

        */

        allOut = new HashMap<String, PrintWriter>();

        /

*

        * 初始化线程池，设置线程的数量

        */

        threadPool = Executors.newFixedThreadPool();

        /

*

        * 初始化用来存放客户端输出流的集合，

        * 每当一个客户端连接，就会将该客户端的输出流存入该集合；

        * 每当一个客户端断开连接，就会将集合中该客户端的输出流删除；

        * 每当转发一条信息，就要遍历集合中的所有输出流(元素)

        * 因此转发的频率高于客户端登入登出的频率，

        * 还是应该使用ArrayList来存储元素，仅限群聊，私聊不行

        * allOut = new ArrayList<PrintWriter>();

        */

        }

        catch (Exception e)

        {

        e.printStackTrace();

        }

        }

        /

*

        * 将客户端的信息以Map形式存入集合中

        */

        private void addOut(String key,PrintWriter value)

        {

        synchronized(this)

        {

        allOut.put(key, value);

        }

        }

        /

*

        * 将给定的输出流从共享集合中删除

        * 参数为客户端nickName,作为Map的key键

        */

        private synchronized void removeOut(String key)

        {

        allOut.remove(key);

        System.out.println("当前在线人数为："+ allOut.size());

        }

        /

*

        * 将给定的消息转发给所有客户端

        */

        private synchronized void sendMsgToAll(String message)

        {

        for(PrintWriter out: allOut.values())

        {

        out.println(message);

        System.out.println("当前在线人数为："+ allOut.size());

        }

        }

        /

*

        * 将给定的消息转发给私聊的客户端

        */

        private synchronized void sendMsgToPrivate(String nickname,String message)

        {

        PrintWriter pw = allOut.get(nickname); //将对应客户端的聊天信息取出作为私聊内容发送出去

        if(pw!=null)

        {

        pw.println(message);

        System.out.println("当前在线私聊人数为："+ allOut.size());

        }

        }

        /

**

        * 服务端启动的方法

        */

        public void start()

        {

        try

        {

        while(true)

        {

        /

*

        * 监听端口

        */

        System.out.println("等待客户端连接... ... ");

        /

*

        * Socket accept() 这是一个阻塞方法，会一直在端口进行监听

        * 直到一个客户端连接上，此时该方法会将与这个客户端进行通信的Socket返回

        */

        Socket socket = serverSocket.accept();

        System.out.println("客户端连接成功！ ");

        /

*

        * 启动一个线程，由线程来处理客户端的请求，这样可以再次监听

        * 下一个客户端的连接了

        */

        Runnable run = new GetClientMsgHandler(socket);

        threadPool.execute(run); //通过线程池来分配线程

        }

        }

        catch(Exception e)

        {

        e.printStackTrace();

        }

        }

        /

**

        * 该线程体用来处理给定的某一个客户端的消息，循环接收客户端发送

        * 的每一个字符串，并输出到控制台

        * @author Jacob

       

*

        */

        class GetClientMsgHandler implements Runnable

        {

        /

*

        * 该属性是当前线程处理的具体的客户端的Socket

        * @see java.lang.Runnable#run()

        */

        private Socket socket;

        /

*

        * 获取客户端的地址信息

        * private String hostIP;

        */

        /

*

        * 获取客户端的昵称

        */

        private String nickName;

        /

*

        * 创建构造方法

        */

        public GetClientMsgHandler(Socket socket)

        {

        this.socket = socket;

        /

*

        * 获取远端客户的Ip地址信息

        * 保存客户端的IP地址字符串

        * InetAddress address = socket.getInetAddress();

        * hostIP = address.getHostAddress();

        */

        }

        /

*

        * 创建内部类来获取昵称

        */

        private String getNickName() throws Exception

        {

        try

        {

        //服务端的输入流读取客户端发送来的昵称输出流

        InputStream iin = socket.getInputStream();

        InputStreamReader isr =

        new InputStreamReader(iin,"UTF-8");

        BufferedReader bReader = new BufferedReader(isr);

        //服务端将昵称验证结果通过自身的输出流发送给客户端

        OutputStream out = socket.getOutputStream();

        OutputStreamWriter iosw =

        new OutputStreamWriter(out,"UTF-8");

        PrintWriter ipw = new PrintWriter(iosw,true);

        //读取客户端发来的昵称

        String nameString = bReader.readLine();

        while(true)

        {

        if(nameString.trim().length()==0)

        {

        ipw.println("FAIL");

        }

        if(allOut.containsKey(nameString))

        {

        ipw.println("FAIL");

        }

        else

        {

        ipw.println("OK");

        return nameString;

        }

        nameString = bReader.readLine();

        }

        }

        catch(Exception e)

        {

        throw e;

        }

        }

       @Override

        public void run()

        {

        PrintWriter pw = null;

        try

        {

        /

*

        * 通过客户端的Socket获取客户端的输出流

        * 用来将消息发送给客户端

        */

        OutputStream os = socket.getOutputStream();

        OutputStreamWriter osw = new OutputStreamWriter(os,"UTF-8");

        pw = new PrintWriter(osw,true);

        /

*

        * 将客户昵称和其所说的话作为元素存入共享集合HashMap中

        */

        nickName = getNickName();

        addOut(nickName, pw);

        Thread.sleep();

        /

*

        * 服务端通知所有客户端，某用户登录

        */

        sendMsgToAll("[系统通知]：欢迎**"+nickName+"**登陆聊天室!");

        /

*

        * 通过客户端的Socket获取输入流

        * 读取客户端发送来的信息

        */

        InputStream is = socket.getInputStream();

        InputStreamReader isr = new InputStreamReader(is,"UTF-8");

        BufferedReader br = new BufferedReader(isr);

        String msgString = null;

        while((msgString = br.readLine())!=null)

        {

        //验证是否是私聊

        if(msgString.startsWith("@"))

        {

        /

*

        * 私聊格式：@昵称：内容

        */

        int index = msgString.indexOf(":");

        if(index >=0)

        {

        //获取昵称

        String name = msgString.substring(1,index);

        String info = msgString.substring(index+1,msgString.length());

        info = nickName + "对你说："+ info;

        //将私聊信息发送出去

        sendMsgToPrivate(name, info);

        //服务端不在广播私聊的信息

        continue;

        }

        }

        /

*

        * 遍历所有输出流，将该客户端发送的信息转发给所有客户端

        */

        System.out.println(nickName+"说："+ msgString);

        sendMsgToAll(nickName+"说："+ msgString);

        }

        }

        catch (Exception e)

        {

        /

*

        * 因为Win系统用户的客户端断开连接后，br.readLine()方法读取

        * 不到信息就会抛出异常，而Linux系统会持续发送null；

        * 因此这里就不在将捕获的异常抛出了。

        */

        }

        finally

        {

        /

*

        * 当执行到此处时，说明客户端已经与服务端断开连接

        * 则将该客户端存在共享集合中的输出流删除

        */

        removeOut(nickName);

        /

*

        * 通知所有客户端，某某客户已经下线

        */

        sendMsgToAll("[系统通知]："+nickName + "已经下线了。");

        /

*

        * 关闭socket，则通过Socket获取的输入输出流也一同关闭了

        */

        if(socket!=null)

        {

        try

        {

        socket.close();

        }

        catch(IOException e)

        {

        e.printStackTrace();

        }

        }

        }

        }

        }

        public static void main(String[] args)

        {

        chatServer server = new chatServer();

        server.start();

        }

       }

       æˆ‘的作业，供你参考

java开发聊天功能用什么技术比较好？

       推荐以下几种技术：

       Socket编程：Socket编程是Java中最基本的网络编程技术，可以使用Socket实现客户端和服务器之间的通信。

       Java NIO：Java NIO（New Input/Output）是Java 1.4版本中引入的一种新的I/O技术，可以提供非阻塞的I/O操作和高效的网络通信。

       WebSocket：WebSocket是一种基于TCP协议的全双工通信协议，可以实现实时通信和数据传输。

       Spring WebSocket：Spring WebSocket是Spring框架提供的一种WebSocket实现，可以快速开发实时通信应用。

       XMPP：XMPP（Extensible Messaging and Presence Protocol）是一种基于XML的通信协议，可以实现即时通信和在线状态管理。