精华内容
下载资源
问答
  • Java 群聊

    2014-06-23 13:47:39
    package cn.java.core.ch06.chat;...import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.ServerSocket; import java.net.

    Server.java

    package Chat;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.net.SocketException;
    import java.util.ArrayList;
    import java.util.List;
    
    public class Server {
    
    	private List<ServerThread> clients = null;
    
    	public static void main(String[] args) {
    		System.out.println("服务器已启动...");
    		new Server().startUp();
    	}
    
    	private void startUp() {
    		ServerSocket ss = null;
    		try {
    			ss = new ServerSocket(7788); // step1 创建ServerSocket对象
    			clients = new ArrayList<ServerThread>(); // step2 创建一个用于维护客户端线程的集合
    			while (true) { // step3 循环侦听每一个客户端的连接
    				Socket s = ss.accept();
    				Thread t = new Thread(new ServerThread(s)); // 没成功连接一个客户端,就单独开一个线程去维护这个客户端的读写操作
    				t.start();
    			}
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    			try {
    				if (ss != null)
    					ss.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    
    	class ServerThread implements Runnable {
    		private Socket socket;
    		private BufferedReader in = null;
    		private PrintWriter out = null;
    		private String name = null;
    
    		public ServerThread(Socket s) {
    			this.socket = s;
    			try {
    				in = new BufferedReader(new InputStreamReader(
    						socket.getInputStream()));
    				out = new PrintWriter(socket.getOutputStream(), true);
    				name = "[" + socket.getInetAddress().getHostAddress() + ":"
    						+ socket.getPort() + "]";
    				clients.add(this);
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    
    		public void run() {
    			getMsg();
    		}
    
    		// 群发消息(向所有客户端发消息)
    		public void sendMsg(String msg) {
    			for (ServerThread st : clients) {
    				st.out.println(msg);
    			}
    		}
    
    		// 读取客户端的消息
    		public void getMsg() {
    			String msg = null;
    			try {
    				while ((msg = in.readLine()) != null) {
    					if (msg.equalsIgnoreCase("quit")) {
    						this.out.println("disconnect");
    						stop();
    						break;
    					}
    				}
    			} catch (SocketException e) {
    				System.out.println(name + "非法退出!");
    				stop();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    
    		// 当前线程资源释放
    		public void stop() {
    			sendMsg(name + "下线了!");
    			clients.remove(this);
    		}
    	}
    }
    

    Client.java

    package Chat;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    import java.net.Socket;
    import java.net.UnknownHostException;
    
    public class Client {
    
    	private Socket s = null; // 用于连接服务器的socket
    	private BufferedReader in = null; // 用于接收服务器消息的阅读器
    	private PrintWriter out = null; // 用于向服务器发送消息的编写器
    
    	private BufferedReader sbr = null; // 用于从键盘读入数据的阅读器
    	private boolean flag = true; // 线程结束标志
    
    	public static void main(String[] args) {
    		new Client().startUp();
    	}
    
    	public void startUp() {
    		try {
    			s = new Socket("127.0.0.1", 7788);
    			in = new BufferedReader(new InputStreamReader(s.getInputStream()));
    			out = new PrintWriter(s.getOutputStream(), true);
    
    			sbr = new BufferedReader(new InputStreamReader(System.in));
    			new Thread(new ClientThread()).start();
    
    			sendMsg();
    
    		} catch (UnknownHostException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    
    			try {
    				if (s != null)
    					s.close();
    				if (in != null)
    					in.close();
    				if (out != null)
    					out.close();
    				if (sbr != null)
    					sbr.close();
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    
    		}
    	}
    
    	// 向服务端不断的通过键盘输入并发送消息
    	private void sendMsg() {
    		String str = null;
    		while (flag) {
    			try {
    				str = sbr.readLine();
    				if (str == null)
    					break;
    				out.println(str);
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    
    	// 接收服务端发送过来的消息
    	private void getMsg() {
    		String str;
    		try {
    			str = this.in.readLine();
    			if (str == null)
    				return;
    			if (str.equalsIgnoreCase("discounnect"))
    				flag = false;
    			System.out.println(str);
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    
    	// 从服务端获取数据的线程(循环接收)
    	class ClientThread implements Runnable {
    
    		public void run() {
    			while (flag) {
    				getMsg();
    			}
    		}
    
    	}
    }
    


    展开全文
  • 本文实例为大家分享了java群聊功能,供大家参考,具体内容如下Java 对TCP协议的支持:--> java.net包中定义了两个类ServerSocket 和Socket ,分别用来实现双向连接的server 端和client 端。--> Client 类定义...

    本文实例为大家分享了java群聊功能,供大家参考,具体内容如下

    Java 对TCP协议的支持:--> java.net包中定义了两个类ServerSocket 和Socket ,分别用来实现双向连接的server 端和client 端。

    --> Client 类定义客户端

    package com.dragon.java.tcpchat;

    import java.io.IOException;

    import java.net.Socket;

    import java.net.UnknownHostException;

    /**

    * 客户端

    *

    * @author Auser

    *

    */

    public class Client {

    public static void main(String args[]) throws UnknownHostException,

    IOException {

    Socket client = new Socket("192.168.1.188", 10000);

    // 穿件发送信息的线程

    new ClientSend(client).start();

    // 创建接收信息的线程

    new ClientReceive(client).start();

    // 因为要实现聊天功能,而不是只发送一次信息,所以输出流和客户端都不能关闭。

    // client.shutdownOutput();

    // client.close();

    }

    }

    --> ClientSend 类 定义客户端向服务端发送信息的线程

    package com.dragon.java.tcpchat;

    import java.io.IOException;

    import java.io.PrintStream;

    import java.net.Socket;

    import java.util.Scanner;

    /**

    * 客户端向服务端发送信息的线程

    *

    * @author Auser

    *

    */

    public class ClientSend extends Thread {

    private Scanner scanner;

    private Socket socket;

    public ClientSend(Socket socket) {

    this.socket = socket;

    }

    @Override

    public void run() {

    scanner = new Scanner(System.in);

    try {

    PrintStream ps = new PrintStream(socket.getOutputStream());

    String line = "";

    // 阻塞式发送信息

    while ((line = scanner.nextLine()) != null) {

    ps.println(line);

    }

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    }

    --> ClientReceive 类 定义客户端接收服务端信息的线程

    package com.dragon.java.tcpchat;

    import java.io.BufferedReader;

    import java.io.InputStreamReader;

    import java.net.Socket;

    /**

    * 客户端接收信息的线程

    *

    * @author Auser

    *

    */

    public class ClientReceive extends Thread {

    private Socket socket;

    public ClientReceive(Socket socket) {

    this.socket = socket;

    }

    @Override

    public void run() {

    try {

    BufferedReader br = new BufferedReader(new InputStreamReader(

    socket.getInputStream()));

    // 按行接收信息

    String line = "";

    while ((line = br.readLine()) != null) {

    System.out.println(line);

    }

    } catch (Exception e) {

    e.printStackTrace();

    }

    }

    }

    --> Server 类定义服务端

    package com.dragon.java.tcpchat;

    import java.io.IOException;

    import java.net.ServerSocket;

    import java.net.Socket;

    import java.util.ArrayList;

    import java.util.List;

    /**

    * 服务器

    *

    * @author Auser

    *

    */

    public class Server {

    public static void main(String[] args) throws IOException,

    InterruptedException {

    List list = new ArrayList<>();

    // 创建服务器端的套接字

    ServerSocket server = new ServerSocket(10000);

    while (true) {

    // 接收客户端的阻塞方法

    Socket socket = server.accept();

    // 设计到多个线程可能会对集合进行增删的操作,要进行同步的处理

    synchronized (list) {

    list.add(socket);

    }

    // 启动一个新的线程去处理这个客户端的交流

    new HandleSocket(socket, list).start();

    }

    // 因为不知道客户端什么时候发送信息,所以服务端要一直开启不能关闭。

    }

    }

    --> HandleSocket 类对连接到服务端的客户端进行操作(上下线通知、屏蔽拉黑、将信息发送到每个客户端等...)

    package com.dragon.java.tcpchat;

    import java.io.BufferedReader;

    import java.io.IOException;

    import java.io.InputStreamReader;

    import java.io.PrintStream;

    import java.net.InetAddress;

    import java.net.Socket;

    import java.util.List;

    /**

    * 处理每个(单个)连接到服务器的客户端的线程

    *

    * @author Auser

    *

    */

    public class HandleSocket extends Thread {

    private Socket socket;

    private List list;

    /**

    * 构造方法

    *

    * @param socket

    * 当前连接的客户端

    * @param list

    * 存储已连接客户端的集合

    */

    public HandleSocket(Socket socket, List list) {

    this.socket = socket;

    this.list = list;

    }

    /**

    * 线程run方法

    */

    @Override

    public void run() {

    InetAddress address = socket.getInetAddress(); // 获取连接到服务器的这的客户端的地址

    String ip = address.getHostAddress();

    System.out.println(ip + "上线了!");

    if (ip.equals("192.168.1.117")) {

    synchronized (list) {

    sendToAll(ip + "由于违规操作,已被拉入黑名单!");

    list.remove(socket);

    }

    return;

    }

    try {

    BufferedReader br = new BufferedReader(new InputStreamReader(

    socket.getInputStream(), "gbk"));

    String line = "";

    while ((line = br.readLine()) != null) {

    String msg = ip + ":" + line;

    System.out.println(msg); // 输出到服务器端的控制台

    // 把这个客户端说的话,发给其他所有的客户端

    sendToAll(msg);

    }

    } catch (IOException e) {

    // e.printStackTrace();

    System.out.println(ip + "下线了!");

    synchronized (list) {

    list.remove(socket);

    }

    }

    }

    /**

    * 把信息发送给所有的客户端,去除当前socket

    *

    * @param msg

    * 发送的信息

    */

    private void sendToAll(String msg) {

    synchronized (list) {

    for (Socket s : list) {

    if (s != socket) {

    try {

    PrintStream ps = new PrintStream(s.getOutputStream());

    ps.println();

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    }

    }

    }

    }

    --> 注意:因为要实现客户端连接到服务端,即客户端要先找到服务端,所以服务端要先开启,再开启服务端...

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

    展开全文
  • 服务器(selector实现):package ...import java.io.IOException;import java.net.InetSocketAddress;import java.nio.ByteBuffer;import java.nio.channels.*;import java.util.Iterator;public class GroupC...

    服务器(selector实现):

    package com.ronghao.nio;

    import java.io.IOException;

    import java.net.InetSocketAddress;

    import java.nio.ByteBuffer;

    import java.nio.channels.*;

    import java.util.Iterator;

    public class GroupChatServer {

    //定义属性

    private Selector selector;

    private ServerSocketChannel listenChannel;

    private static final int PORT = 9999;

    //初始化工作

    public GroupChatServer() {

    try {

    //选择器

    selector = Selector.open();

    //通道

    listenChannel = ServerSocketChannel.open();

    listenChannel.socket().bind(new InetSocketAddress(PORT));

    listenChannel.configureBlocking(false);

    listenChannel.register(selector, SelectionKey.OP_ACCEPT);

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    //监听

    public void listen() {

    try {

    //循环处理

    while (true) {

    int count = selector.select();

    if (count > 0) {//有事件处理

    //遍历得到selectionKey集合

    Iterator iterator = selector.selectedKeys().iterator();

    while (iterator.hasNext()) {

    //去除selectionkey

    SelectionKey key = iterator.next();

    //监听到accept

    if (key.isAcceptable()) {

    SocketChannel sc = listenChannel.accept();

    //非阻塞

    sc.configureBlocking(false);

    //将该sc注册到selector上

    sc.register(selector, SelectionKey.OP_READ);

    //提示

    System.out.println(sc.getRemoteAddress() + "上线");

    }

    if (key.isReadable()) {//通道发送read事件,即通道是可读的状态

    //处理读

    readData(key);

    }

    //当前key从集合中删除,防止重复处理。

    iterator.remove();

    }

    }

    }

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    //读取客户端消息

    private void readData(SelectionKey key) {

    //定义一个SocketChannel

    SocketChannel channel = null;

    try {

    channel = channel = (SocketChannel) key.channel();

    ByteBuffer buffer = ByteBuffer.allocate(1024);

    int count = channel.read(buffer);

    if (count > 0) {

    //把缓冲区的数据转换成字符串

    String message = new String(buffer.array());

    //输出该消息

    System.out.println("from 客户端:" + message);

    //向其他客户端转发消息(去掉自己),专门写一个方法来处理

    sendInfoToOtherClients(message, channel);

    }

    } catch (IOException e) {

    try {

    System.out.println(channel.getRemoteAddress() + " 离线了");

    //取消注册

    key.cancel();

    //关闭通道

    channel.close();

    } catch (IOException ioException) {

    ioException.printStackTrace();

    }

    }

    }

    //转发消息给其它客户(通道)

    private void sendInfoToOtherClients(String msg, SocketChannel self) throws IOException {

    //遍历所有注册到selector上的SocketChannel,并排除self

    for (SelectionKey key : selector.keys()) {

    //通过key取出对应的SocketChannel

    SelectableChannel targetChannel = key.channel();

    //排除自己

    if (targetChannel instanceof SocketChannel && targetChannel != self) {

    //转型

    SocketChannel dest = (SocketChannel) targetChannel;

    //将msg存储到buffer

    ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());

    //将buffer的数据写入通道;

    dest.write(buffer);

    }

    }

    }

    public static void main(String[] args) {

    GroupChatServer server = new GroupChatServer();

    server.listen();

    }

    }

    客户端:

    package com.ronghao.nio;

    import java.io.IOException;

    import java.net.InetSocketAddress;

    import java.nio.ByteBuffer;

    import java.nio.channels.SocketChannel;

    import java.util.Scanner;

    public class GroupChatClient {

    //定义相关属性

    private final String HOST = "127.0.0.1";//服务器的ip

    private final int PORT = 9999;//服务器端口

    private SocketChannel socketChannel;

    private String username;

    //初始化工作

    GroupChatClient() {

    try {

    //连接服务器

    socketChannel = SocketChannel.open(new InetSocketAddress(HOST, PORT));

    //非阻塞

    username = socketChannel.getLocalAddress().toString().substring(1);

    System.out.println(username + " is ok ...");

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    //发送数据

    public void sendInfo(String info) {

    try {

    info = username + " 说:" + info;

    socketChannel.write(ByteBuffer.wrap(info.getBytes()));

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    //读取从服务端回复的消息

    public void readInfo() {

    try {

    ByteBuffer buffer = ByteBuffer.allocate(1024);

    socketChannel.read(buffer);

    String msg = new String(buffer.array());

    System.out.println(msg.trim());

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    public static void main(String[] args) {

    //启动客户端

    GroupChatClient chatClient = new GroupChatClient();

    //启动一个线程,每隔3秒,读取从服务器发送数据

    new Thread(() -> {

    while (true) {

    chatClient.readInfo();

    try {

    Thread.sleep(3000);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    }).start();

    //获取用户输入,发送到服务器

    Scanner scanner = new Scanner(System.in);

    while (scanner.hasNextLine()) {

    String s = scanner.nextLine();

    chatClient.sendInfo(s);

    }

    }

    }

    展开全文
  • 本文实例为大家分享了java群聊功能,供大家参考,具体内容如下Java 对TCP协议的支持:--> java.net包中定义了两个类ServerSocket 和Socket ,分别用来实现双向连接的server 端和client 端。--> Client 类定义...

    本文实例为大家分享了java群聊功能,供大家参考,具体内容如下

    Java 对TCP协议的支持:

    --> java.net包中定义了两个类ServerSocket 和Socket ,分别用来实现双向连接的server 端和client 端。

    --> Client 类定义客户端

    package com.dragon.java.tcpchat;

    import java.io.IOException;

    import java.net.Socket;

    import java.net.UnknownHostException;

    /**

    * 客户端

    *

    * @author Auser

    *

    */

    public class Client {

    public static void main(String args[]) throws UnknownHostException,

    IOException {

    Socket client = new Socket("192.168.1.188", 10000);

    // 穿件发送信息的线程

    new ClientSend(client).start();

    // 创建接收信息的线程

    new ClientReceive(client).start();

    // 因为要实现聊天功能,而不是只发送一次信息,所以输出流和客户端都不能关闭。

    // client.shutdownOutput();

    // client.close();

    }

    }

    --> ClientSend 类 定义客户端向服务端发送信息的线程

    package com.dragon.java.tcpchat;

    import java.io.IOException;

    import java.io.PrintStream;

    import java.net.Socket;

    import java.util.Scanner;

    /**

    * 客户端向服务端发送信息的线程

    *

    * @author Auser

    *

    */

    public class ClientSend extends Thread {

    private Scanner scanner;

    private Socket socket;

    public ClientSend(Socket socket) {

    this.socket = socket;

    }

    @Override

    public void run() {

    scanner = new Scanner(System.in);

    try {

    PrintStream ps = new PrintStream(socket.getOutputStream());

    String line = "";

    // 阻塞式发送信息

    while ((line = scanner.nextLine()) != null) {

    ps.println(line);

    }

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    }

    --> ClientReceive 类 定义客户端接收服务端信息的线程

    package com.dragon.java.tcpchat;

    import java.io.BufferedReader;

    import java.io.InputStreamReader;

    import java.net.Socket;

    /**

    * 客户端接收信息的线程

    *

    * @author Auser

    *

    */

    public class ClientReceive extends Thread {

    private Socket socket;

    public ClientReceive(Socket socket) {

    this.socket = socket;

    }

    @Override

    public void run() {

    try {

    BufferedReader br = new BufferedReader(new InputStreamReader(

    socket.getInputStream()));

    // 按行接收信息

    String line = "";

    while ((line = br.readLine()) != null) {

    System.out.println(line);

    }

    } catch (Exception e) {

    e.printStackTrace();

    }

    }

    }

    --> Server 类定义服务端

    package com.dragon.java.tcpchat;

    import java.io.IOException;

    import java.net.ServerSocket;

    import java.net.Socket;

    import java.util.ArrayList;

    import java.util.List;

    /**

    * 服务器

    *

    * @author Auser

    *

    */

    public class Server {

    public static void main(String[] args) throws IOException,

    InterruptedException {

    List list = new ArrayList<>();

    // 创建服务器端的套接字

    ServerSocket server = new ServerSocket(10000);

    while (true) {

    // 接收客户端的阻塞方法

    Socket socket = server.accept();

    // 设计到多个线程可能会对集合进行增删的操作,要进行同步的处理

    synchronized (list) {

    list.add(socket);

    }

    // 启动一个新的线程去处理这个客户端的交流

    new HandleSocket(socket, list).start();

    }

    // 因为不知道客户端什么时候发送信息,所以服务端要一直开启不能关闭。

    }

    }

    --> HandleSocket 类对连接到服务端的客户端进行操作(上下线通知、屏蔽拉黑、将信息发送到每个客户端等...)

    package com.dragon.java.tcpchat;

    import java.io.BufferedReader;

    import java.io.IOException;

    import java.io.InputStreamReader;

    import java.io.PrintStream;

    import java.net.InetAddress;

    import java.net.Socket;

    import java.util.List;

    /**

    * 处理每个(单个)连接到服务器的客户端的线程

    *

    * @author Auser

    *

    */

    public class HandleSocket extends Thread {

    private Socket socket;

    private List list;

    /**

    * 构造方法

    *

    * @param socket

    * 当前连接的客户端

    * @param list

    * 存储已连接客户端的集合

    */

    public HandleSocket(Socket socket, List list) {

    this.socket = socket;

    this.list = list;

    }

    /**

    * 线程run方法

    */

    @Override

    public void run() {

    InetAddress address = socket.getInetAddress(); // 获取连接到服务器的这的客户端的地址

    String ip = address.getHostAddress();

    System.out.println(ip + "上线了!");

    if (ip.equals("192.168.1.117")) {

    synchronized (list) {

    sendToAll(ip + "由于违规操作,已被拉入黑名单!");

    list.remove(socket);

    }

    return;

    }

    try {

    BufferedReader br = new BufferedReader(new InputStreamReader(

    socket.getInputStream(), "gbk"));

    String line = "";

    while ((line = br.readLine()) != null) {

    String msg = ip + ":" + line;

    System.out.println(msg); // 输出到服务器端的控制台

    // 把这个客户端说的话,发给其他所有的客户端

    sendToAll(msg);

    }

    } catch (IOException e) {

    // e.printStackTrace();

    System.out.println(ip + "下线了!");

    synchronized (list) {

    list.remove(socket);

    }

    }

    }

    /**

    * 把信息发送给所有的客户端,去除当前socket

    *

    * @param msg

    * 发送的信息

    */

    private void sendToAll(String msg) {

    synchronized (list) {

    for (Socket s : list) {

    if (s != socket) {

    try {

    PrintStream ps = new PrintStream(s.getOutputStream());

    ps.println();

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    }

    }

    }

    }

    --> 注意:因为要实现客户端连接到服务端,即客户端要先找到服务端,所以服务端要先开启,再开启服务端...

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持聚米学院。

    展开全文
  • java群聊聊天室.zip

    2020-08-08 11:30:48
    java版本简易聊天室 服务端和客户端都有 其中用到了反射 jdbc Swing 一些知识
  • Java群聊系统下载:http://download.csdn.net/detail/a362523/8920729 项目迭代1 服务端的启动会开启三个线程,一个用于监听客户端的连接(接收用户名登录的信息),一个用户用于接收客户端发送过来的聊天信息。用于...
  • 前言 闲言少叙,上代码! 代码编写 server服务端 /*** 服务端*/ public classServer {private static ServerSocket ...多客户端、涉及有界面的聊天建议使用websocket(猛戳这里 -->WebSocket+Java 私聊、群聊实例)。
  • packagecom.dragon.java.tcpchat;importjava.io.BufferedReader;importjava.io.IOException;importjava.io.InputStreamReader;importjava.io.PrintStream;importjava.net.InetAddress;importjava.net.Socket;importj...
  • } } //群聊:获取自己的消息,发给其他人和私聊功能 private void sendothers(String msg,boolean issys) { boolean issecrete =msg.startsWith("@"); if(issecrete) { int index=msg.indexOf(":"); String target=...
  • 所用技术 项目使用Maven构建,后端使用的语言是JAVA框架为Spring + Spring MVC + Mybatis数据库使用的是Oracle 10gMySQL 前台采用Amaze UI,弹窗和分页使用的是Layer,当然还有Jquery...开发工具使用的是IntelliJ IDEA ...
  • 提供客户端和服务器2个操作平台,群聊功能,输入IP即可,默认为本地回落
  • java群聊

    2014-07-07 15:28:59
    基于java网络编程的群聊室,能够进行多人在线群聊~供各位学习java网络入门的参考哦
  • Java TCP 群聊

    2017-08-31 19:40:40
    服务器: ...import java.io .*; import java.net .*; import java.util.ArrayList; public class TCPServer { //创建一个集合,集合存放客服端的对象  ArrayList arrayListSocket = new ArrayList();
  • java实现群聊功能

    2011-03-29 00:10:36
    java语言实现群聊系统的啦,绝对能用,放心。。。。。。。。
  • java qq 源码 群聊

    2011-05-16 10:35:57
    java socket 实现群聊 简单通讯
  • 基于Java群聊系统

    2015-07-21 20:30:57
    这是个用Java语言编写的模拟群聊系统的实现。涉及到Socket编程、多线程、客户端与服务器(模拟的客户端与服务器)之间的数据传递用的是简单的自定义格式的字符数据。
  • java单聊群聊案例

    2018-06-27 21:33:50
    java单聊群聊案例,课程代码,适合新手学习,基础知识的掌握
  • 本文实例为大家分享了java群聊功能,供大家参考,具体内容如下java 对tcp协议的支持:--> java.net包中定义了两个类serversocket 和socket ,分别用来实现双向连接的server 端和client 端。--> client 类定义...
  • java 单聊 群聊

    2010-12-05 20:18:25
    基于java socket编程、简单实现了单聊群聊功能、、
  • 1.服务器端代码import java.io.IOException;import java.net.InetSocketAddress;import java.net.ServerSocket;import java.nio.ByteBuffer;import java.nio.channels.Channel;import java.nio.channels....
  • public class MyServer {List list=new ArrayList();public static void main(String[] args) {try {//定义服务端//获取一个连接new MyServer(). start();} catch (IOException e) {// TODO Auto-generated catch ...
  • java swing实现群聊功能

    2018-07-11 16:18:50
    群聊功能。使用java swing,socket,多线程实现。 1) 客户端用来接收和展示数据,服务器实现与底层数据的交互。 2) 实现服务器端与客户端的分离,如果要操作数据库,可以在服务器端改代码调用Model。 3) 实现用户...
  • JAVA实现的UDP群聊小软件,安装了JAVA的电脑都可以编译运行,附源码,适合初学者体会学习UDP MULTICAST的基础知识。
  • java实现群聊设计思路

    2020-05-26 13:28:05
    } } 4.java界面 public class login extends JFrame//图形界面容器 JFrame { JPanel mb1,mb2,mb3;//面板容器类 JButton an1,an2;//按钮组件 JLabel bq1,bq2;//标签组件 一个标签,本身是用于显示信息的,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,381
精华内容 552
关键字:

java群聊

java 订阅