Java编程Socket实现多个客户端连接同一个服务端代码
Java socket(套接字)通常也称作"套接字"，用于描述ip地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。
使用socket实现多个客户端和同一客户端通讯；首先客户端连接服务端发送一条消息，服务端接收到消息后进行处理，完成后再回复客户端一条消息。
服务端代码
public class server {
public static void main(string[] args) throws ioexception {
// 为了简单起见，所有的异常信息都往外抛
int port = 8899;
// 定义一个servicesocket监听在端口8899上
serversocket server = new serversocket(port);
system.out.println("等待与客户端建立连接...");
while (true) {
// server尝试接收其他socket的连接请求，server的accept方法是阻塞式的
socket socket = server.accept();
/**
* 我们的服务端处理客户端的连接请求是同步进行的， 每次接收到来自客户端的连接请求后，
* 都要先跟当前的客户端通信完之后才能再处理下一个连接请求。 这在并发比较多的情况下会严重影响程序的性能，
* 为此，我们可以把它改为如下这种异步处理与客户端通信的方式
*/
// 每接收到一个socket就建立一个新的线程来处理它
new thread(new task(socket)).start();
}
// server.close();
}
/**
* 处理socket请求的线程类
*/
static class task implements runnable {
private socket socket;
/**
* 构造函数
*/
public task(socket socket) {
this.socket = socket;
}
@override
public void run() {
try {
handlersocket();
}
catch (exception e) {
e.printstacktrace();
}
}
/**
* 跟客户端socket进行通信
*
* @throws ioexception
*/
private void handlersocket() throws exception {
// 跟客户端建立好连接之后，我们就可以获取socket的inputstream，并从中读取客户端发过来的信息了
/**
* 在从socket的inputstream中接收数据时，像上面那样一点点的读就太复杂了，
* 有时候我们就会换成使用bufferedreader来一次读一行
*
* bufferedreader的readline方法是一次读一行的，这个方法是阻塞的，直到它读到了一行数据为止程序才会继续往下执行，
* 那么readline什么时候才会读到一行呢？直到程序遇到了换行符或者是对应流的结束符readline方法才会认为读到了一行，
* 才会结束其阻塞，让程序继续往下执行。
* 所以我们在使用bufferedreader的readline读取数据的时候一定要记得在对应的输出流里面一定要写入换行符（
* 流结束之后会自动标记为结束，readline可以识别），写入换行符之后一定记得如果输出流不是马上关闭的情况下记得flush一下，
* 这样数据才会真正的从缓冲区里面写入。
*/
bufferedreader br = new bufferedreader(
new inputstreamreader(socket.getinputstream(), "utf-8"));
stringbuilder sb = new stringbuilder();
string temp;
int index;
while ((temp = br.readline()) != null) {
if ((index = temp.indexof("eof")) != -1) {
// 遇到eof时就结束接收
sb.append(temp.substring(0, index));
break;
}
sb.append(temp);
}
system.out.println("form cliect[port:" + socket.getport()
+ "] 消息内容:" + sb.tostring());
// 回应一下客户端
writer writer = new outputstreamwriter(socket.getoutputstream(),
"utf-8");
writer.write(string.format("hi,%d.天朗气清，惠风和畅！", socket.getport()));
writer.flush();
writer.close();
system.out.println(
"to cliect[port:" + socket.getport() + "] 回复客户端的消息发送成功");
br.close();
socket.close();
}
}
}
客户端代码
import java.io.inputstreamreader;
import java.io.outputstreamwriter;
import java.io.reader;
import java.io.writer;
import java.net.socket;
/** * socket客户端
* 功能说明： * * @author 大智若愚的小懂 * @date 2016年8月30日 * @version 1.0 */
public class client {
/** * 入口 * @param args */
public static void main(string[] args) {
// 开启三个客户端，一个线程代表一个客户端
for (int i = 0; i < 3; i++) {
new thread(new runnable() {
@override public void run() {
try {
testclient client = testclientfactory.createclient();
client.send(string.format("hello,server!i'm %d.这周末天气如何。", client.client.getlocalport()));
client.receive();
}
catch (exception e) {
e.printstacktrace();
}
}
}
).start();
}
}
/** * 生产测试客户端的工厂 */
static class testclientfactory {
public static testclient createclient() throws exception {
return new testclient("127.0.0.1", 8899);
}
}
/** * 测试客户端 */
static class testclient {
/** * 构造函数 * @param host 要连接的服务端ip地址 * @param port 要连接的服务端对应的监听端口 * @throws exception */
public testclient(string host, int port) throws exception {
// 与服务端建立连接
this.client = new socket(host, port);
system.out.println("cliect[port:" + client.getlocalport() + "] 与服务端建立连接...");
}
private socket client;
private writer writer;
/** * 发送消息 * @param msg * @throws exception */
public void send(string msg) throws exception {
// 建立连接后就可以往服务端写数据了
if(writer == null) {
writer = new outputstreamwriter(client.getoutputstream(), "utf-8");
}
writer.write(msg);
writer.write("eof\n");
writer.flush();
// 写完后要记得flush
system.out.println("cliect[port:" + client.getlocalport() + "] 消息发送成功");
}
/** * 接收消息 * @throws exception */
public void receive() throws exception {
// 写完以后进行读操作
reader reader = new inputstreamreader(client.getinputstream(), "utf-8");
// 设置接收数据超时间为10秒
client.setsotimeout(10*1000);
char[] chars = new char[64];
int len;
stringbuilder sb = new stringbuilder();
while ((len = reader.read(chars)) != -1) {
sb.append(new string(chars, 0, len));
}
system.out.println("cliect[port:" + client.getlocalport() + "] 消息收到了，内容:" + sb.tostring());
reader.close();
// 关闭连接
writer.close();
client.close();
}
}
}
接下来模拟一下：
1.首先运行服务端
2.接着运行客户端（开三个客户端请求）
为了演示有所区分，服务端我使用的是eclipse工具,客户端使用的是intellij idea工具。这时可以看到客户端在控制台打印出来的消息
一个port端口号代表一个客户端，回过来看下服务端在控制台打印出来的消息
TCP网络编程 ServerSocket和Socket实现多客户端聊天
目标
使用SeverSocket 和 Socket 实现双人、多人聊天
过程分析
思路
大致说一下，整体思路
1.实现一个群发效果，且需要执行判断，当前的客户端发送的信息，并不需要通过Server端发送给自己。
2.实现循环侦听，因为有多个套接字请求，所以需要将它们“存起来”。
3.根据循环侦听结果创建多个线程，每条线程都是平级关系，每条线程需要实现发送功能，读取功能（将读取到的信息发送出去）
详细分析
1.每条线程需要单独运行一遍，才能实现群发效果
2.每条线程内的：发送方法、run方法、读取方法 都是不同的socket
3.将每一条线程存到集合，使用当前的线程调取群发方法时，遍历判断，然后切换到其他线程进行发送操作。
4.大概就是：循环（侦听、创建新线程）——存储线程——当前线程接收信息——发送信息——调取群发——切换线程完成发送
5.服务器只有及时转发，和循环监听
代码示例
Server端
首先要侦听所有的套接字，侦听到一个，就启动一个线程，并将其存至集合
子线程写了发送方法，run方法，接收方法
还有一个单例，需要保证该群发类只有一个实例对象
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Map.Entry;
import java.util.Vector;
/*服务器端：一个线程专门发送和接收消息 一个线程监听所有Socket。
客户端：一个线程专门发送消息，一个线程专门接收消息。*/
public class QunLiaoServer {
public static void main(String[] args) throws IOException {
ServerAccept sa = new ServerAccept();
sa.start();
}
}
//创建侦听类
class ServerAccept extends Thread{
@Override
public void run() {
try {
System.out.println("等待客户端连接");
ServerSocket ss = new ServerSocket(35555);
//由于可能当有多个客户端连接时，accept方法就会产生多个Socket对象，需加一个while循环监听来自客户端的连接
while(true){
//侦听套接字的连接，accept是一个阻塞的方法，会阻塞当前的线程
Socket s = ss.accept();
//建立连接，表示serverSocket在监听，如果监听到有客户端连接则会调用accept方法，然后返回一个Socket，最后建立连接
System.out.println("连接成功"+s.getPort());
//传递当前连接的客户端套接字
SocketShouFa rs = new SocketShouFa(s);//会产生多条线程
rs.start();
//传递该线程
QunFa.getQunFa().add(rs,s);//只有一个实例
//当第一个socket被侦听到，且被传递下去，会死循环侦听下一个socket，并传递下去
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
//创建接收和发送类线程 (客户端信息接收，发送方法)
class SocketShouFa extends Thread{
Socket socket;
public SocketShouFa (Socket s){
this.socket=s;
}
public void firstSend(String str,Socket nowsocket){
try {
socket.getOutputStream().write((Thread.currentThread().getName()+"端口:"+nowsocket.getPort()+"-->发送:"+str+"\r\n").getBytes());
} catch (IOException e) {
System.out.println("断开了客户端,没有客户端接收信息");//当前接收的客户端断开，无法写给客户端信息会报错
e.printStackTrace();
//需要写一个清除当前该客户端的方法
QunFa.getQunFa().remove(this,socket);
}
}
//重写run方法
//线程执行至此，需要接收客户端的信息
@Override
public void run() {
firstSend("您已经连接到服务器",socket);
try {
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String line=null;
//接收客户端的数据
while ((line=br.readLine())!=null) {
//然后服务器再将所有的信息转发给每一个客户端，调用qunFa方法
QunFa.getQunFa().qunFa(this, line);
}
} catch (IOException e) {
System.out.println(Thread.currentThread().getName()+"客户端已断开");
e.printStackTrace();
}
}
}
//创建群发类(创建单例模型；集合存储 SocketShouFa线程 和套接字 ；实现群发,调取发送方法)
class QunFa{
//创建单例模型
private QunFa(){
}
private static final QunFa si= new QunFa();
public static QunFa getQunFa(){
return si;
}
//创建一个存储 线程 和端口 的Hashtable集合
Hashtable<SocketShouFa,Socket> ht = new Hashtable<SocketShouFa,Socket>();
public void add(SocketShouFa ri,Socket nowsocket){
//将每一个线程 和 对应的socket 加入集合中
ht.put(ri, nowsocket);
}
//线程清除
public void remove(SocketShouFa ri,Socket nowsocket) {
ht.remove(ri, nowsocket);
}
//表示当前的线程给集合中的 非自己 的线程发送的信息
public void qunFa(SocketShouFa ri,String img){
//遍历集合
for (Entry<SocketShouFa, Socket> entry : ht.entrySet()) {
SocketShouFa nowRi = entry.getKey();
//如果遍历线程 和 当前线程不一致，就进入
if(!ri.equals(nowRi)){
//传递 不一致客户端线程，并且发送当前 线程的socket信息
nowRi.firstSend(img, ht.get(ri));
}
}
}
}
Client端
这里有两个线程被启用了，一个是主线程去读取信息，一个子线程发送信息
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
public class ClientB {
public static void main(String[] args) {
// 创建客户端对象
try {
Socket s = new Socket("192.168.0.243", 35555);
SendImgClientB sendclient = new SendImgClientB(s);
sendclient.start();
// 创建读取字符流
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
while(true){
//读取服务端发过来的信息
String serverimg = br.readLine();
System.out.println(serverimg);
}
} catch (IOException e) {
System.out.println("服务器下线了");
e.printStackTrace();
}
}
}
class SendImgClientB extends Thread {
Socket ss;
PrintWriter pw;
Scanner sc =new Scanner(System.in);
public SendImgClientB(Socket s) {
this.ss = s;
try {
this.pw = new PrintWriter(s.getOutputStream());
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void run() {
try {
while (true) {
// 客户端发送信息
String in = sc.next();
pw.println(in);
pw.flush();// 输出流刷新
if (in.equals("end")) {
break;
}
}
} catch (Exception e) {
System.out.println("服务器下线了");
e.printStackTrace();
} finally {
if (pw != null) {
pw.close();
}
if (ss != null) {
try {
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
结果
