本篇文章给大家带来的内容是关于socket编程的实现过程，有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。
1.socket 服务器搭建
实例化socket服务器，循环获取请求
package com.orange.util;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* socket服务器
*
* @author Chengjq
*
*/
public class SocketServer {
public static int count = 0;
public static void main(String[] args) {
// TODO 自动生成的方法存根
int port = 4404;
// 首先直接创建serversocket
ServerSocket serverSocket = null;
Socket socket = null;
try {
serverSocket = new ServerSocket(port);
System.out.println("启动socketServer成功,等待客户端的连接");
while (true) {
socket = serverSocket.accept();
System.out.println("有新的客户端请求连接");
SocketThread st = new SocketThread(socket);
st.start();
ChatManager.getChatManager().add(st);
//启动定时任务，如果10s内没有进程
/*Runnable runnable = new Runnable() {
int clientNum = 0;
public void run() {
// task to run goes here
clientNum = ChatManager.getChatManager().vector.size();
System.out.println("剩余客户端数量:"+clientNum);
if(clientNum ==0 ){
System.out.println("连接超时，或者无客户端连接，关闭serverSocket");
//关闭socket
//.....
}
}
};
ScheduledExecutorService service = Executors
.newSingleThreadScheduledExecutor();
// 第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间
service.scheduleAtFixedRate(runnable, 2, 10, TimeUnit.SECONDS); */
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
System.out.println("serverSocket已超时");
try {
socket.close();
serverSocket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}SocketThread类实现多线程通信
package com.orange.util;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
/**
* SocketThread实现多线程通信
*
* @author Administrator
*
*/
public class SocketThread extends Thread {
ServerSocket serverSocket = null;
Socket socket = null;
public SocketThread(ServerSocket serverSocket,Socket socket) {
super();
this.serverSocket = serverSocket;
this.socket = socket;
}
public SocketThread(Socket socket) {
super();
this.socket = socket;
}
public void out(String out) {
try {
socket.getOutputStream().write(out.getBytes("utf-8"));
} catch (IOException e) {
e.printStackTrace();
}
}
public void publish(String out){
ChatManager.getChatManager().publish(this, out);
}
@Override
public void run() {
// TODO Auto-generated method stub
BufferedReader socketIn = null;
PrintWriter socketOut = null;
String inMess = null;
try {
socketIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
socketOut = new PrintWriter(socket.getOutputStream());
while (true) {
inMess = socketIn.readLine();
publish(inMess);
if("bye".equals(inMess)){
ChatManager.getChatManager().remove(this);
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
System.out.println("已结束当前会话");
socketOut.close();
socketIn.close();
socket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}单例Chatmanage，对所有客户端线程管控处理
立即学习“Java免费学习笔记（深入）”；
package com.orange.util;
import java.util.Vector;
public class ChatManager {
// 实现单例化
private ChatManager() {
};
private static final ChatManager cm = new ChatManager();
public static ChatManager getChatManager() {// 返回值为ChatManager
return cm;
}
// 单例化完成
Vector vector = new Vector();
public void add(SocketThread st) {// 为当前集合添加SocketThread对象
vector.add(st);
}
public void remove(SocketThread st) {// 当前客户端关闭连接
vector.remove(st);
}
public void removeall() {// 关闭所有连接
for (int i = 0; i < vector.size(); i++) {// 遍历所有的线程
SocketThread csChatSocket = vector.get(i);
if(csChatSocket!=null){
vector.remove(csChatSocket);
}
}
}
// 某一个线程向其他的客户端发送信息
public void publish(SocketThread st, String out) {
for (int i = 0; i < vector.size(); i++) {// 遍历所有的线程
SocketThread csChatSocket = vector.get(i);
if (csChatSocket != st)// 判断不是当前线程就发送此消息
csChatSocket.out(out + "\n");
}
}
// 向当前线程发信息
public void publish_present(SocketThread st, String out) {
st.out(out + "\n");
}
} 至此，服务器搭建完成
2.客户端（创建两个客户端）
客户端1（监听指定服务器，通过控制台输入消息进行服务器与客户端以及客户端之间的通信，）
package com.orange;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
/**
* 客户端1
* @author Chengjq
*
*/
public class SocketClient1 {
@SuppressWarnings("static-access")
public static void main(String[] args) {
try {
//初始化客户端
Socket socket = new Socket("127.0.0.1", 4404);
BufferedReader readline = new BufferedReader(new InputStreamReader(System.in));
//获取输出打印流
PrintWriter socketOut = new PrintWriter(socket.getOutputStream());
String outTemp = null;
System.out.println("开始准备向服务器端发起请求---\n自己:");
// 已启动连接socket服务器，准备实时接收来自其他客户端的消息
GetMess getMess = new GetMess(socket);
getMess.start();
// 通过控制台发送消息给其他客户端，以“bye”为结束语
while ((outTemp = readline.readLine()) != null) {
//发送信息
socketOut.println(outTemp);
socketOut.flush();
if("bye".equals(outTemp)){
break;
}
}
getMess.currentThread().interrupt();
//依次关闭各种流
readline.close();
socketOut.close();
socket.close();
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}客户端2
package com.orange;
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 SocketClient2 {
@SuppressWarnings("static-access")
public static void main(String[] args) {
try {
//初始化客户端
Socket socket = new Socket("127.0.0.1", 4404);
BufferedReader readline = new BufferedReader(new InputStreamReader(System.in));
//获取输出打印流
PrintWriter socketOut = new PrintWriter(socket.getOutputStream());
String outTemp = null;
System.out.println("开始准备向服务器端发起请求---\n自己:");
// 已启动连接socket服务器，准备实时接收来自其他客户端的消息
GetMess getMess = new GetMess(socket);
getMess.start();
// 通过控制台发送消息给其他客户端，以“bye”为结束语
while ((outTemp = readline.readLine()) != null) {
//发送信息
socketOut.println(outTemp);
socketOut.flush();
if("bye".equals(outTemp)){
break;
}
}
getMess.currentThread().interrupt();
//依次关闭各种流
readline.close();
socketOut.close();
socket.close();
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}GetMess（多线程处理获取其他客户端的消息并且展示）
package com.orange;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;
public class GetMess extends Thread {
Socket socket = null;
public GetMess(Socket socket) {
super();
this.socket = socket;
}
@Override
public void run() {
// TODO Auto-generated method stub
BufferedReader socketIn = null;
try {
InputStream is = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(is);
socketIn = new BufferedReader(isr);
String inTemp = null;
while(true){
inTemp = socketIn.readLine();
if(inTemp != null && !"bye".equals(inTemp) ){
System.out.println("好友:\n"+inTemp);
}else{
System.out.println("好友:\n已下线，关闭当前回话");
break;
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
try {
Thread.currentThread().interrupt();
socketIn.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}ok，简单的sockte服务与客户端完成了
先启动server
在分别启动client
输入结束bye,关闭当前会话
