socket 长连接

[代码] web.xml 跳至 [1] [2] [3] [4]
?
1
2
3
4
5
6
<!-- socket监听 start -->
<listener>
<description>Socket服务随web服务启动而启动</description>
<listener-class>demo.socket.SocketListener</listener-class>
</listener>
<!-- socket监听 end -->
[2].[代码] SocketListener.java(服务端代码) 跳至 [1] [2] [3] [4]
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class SocketListener implements ServletContextListener {
private ListenSocket socketThread;

/**
* 销毁 当servlet容器终止web应用时调用该方法
*/
public void contextDestroyed(ServletContextEvent arg0) {
if(null != socketThread && !socketThread.isInterrupted()){
socketThread.closeSocketServer();//关闭线程
socketThread.interrupt();//中断线程
}
}

/**
* 初始化 当servlet容器启动web应用时调用该方法
*/
public void contextInitialized(ServletContextEvent arg0) {
if(null == socketThread){
socketThread = new ListenSocket();
socketThread.start();
}
}

}
[3].[代码] ListenSocket.java(服务端代码) 跳至 [1] [2] [3] [4]
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
public class ListenSocket extends Thread {
private static final int SERVER_PORT = 10000; //端口号
private int count = 0;//连接客户端数
private ServerSocket ss = null;//服务端socket

public ListenSocket(){
try {
if(null==ss){
this.ss = new ServerSocket(SERVER_PORT);
}
} catch (IOException e) {
e.printStackTrace();
}
}

public void run() {
System.out.println("-------主监听线程----------start----------");
try {
while(true){
Socket client = ss.accept();
count += 1;
Thread c_thread = new CreateServerThread(client,count);
c_thread.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}



class CreateServerThread extends Thread {
private Socket client; //当前所连接客户端
private int index;//当前线程编号
private BufferedReader in = null;//从客户端接受到的信息
private OutputStream out = null;//返回给客户端的信息

public CreateServerThread(Socket client,int index) throws IOException {
this.client = client;
this.index = index;
}

public void run(){
System.out.println("-------当前连接的客户端数为----------" + index + "----------");
String ms = "Callback accepted " + client.getInetAddress() + ":" + client.getPort();
System.out.println(ms);

try {
in = new BufferedReader(new InputStreamReader(client.getInputStream()));//接收请求的流
out = client.getOutputStream();//写入缓存
int len = 0;//监听到的字符串长度
String str = "";//监听到的字符串
char buf[] = new char[4096];
while((len = in.read(buf)) > 0){
//读取
str += new String(buf,0,len);
System.out.println("---------获取到第"+index+"个客户端的报文："+str);
if(str!=null && !"".equals(str)){
out.write(("服务端已接受到第"+index+"个客户端发送的报文").getBytes());
}else{
System.out.println("---------第"+index+"个客户端所传报文为空");
out.write("-1".getBytes());
break;
}
}
} catch (IOException e) {
System.out.println("---------服务端与第"+index+"个客户端交互时异常："+e.getMessage());
}finally{
try {
if(client!=null){
client.close();
count -= 1;
System.out.println("---------关闭第"+index+"个客户端连接，当前连接的客户端个数为"+count);
}
} catch (IOException e) {
System.out.println("---------第"+index+"个客户端关闭异常："+e.getMessage());
}
}
}
}

public void closeSocketServer(){
try{
if(ss!=null && !ss.isClosed()){
ss.close();
}
}catch(IOException e){
e.printStackTrace();
}
}
}
[4].[代码] Client.java（客户端代码） 跳至 [1] [2] [3] [4]
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class Client extends Thread{
Socket socket;
BufferedReader in;
OutputStream out;
String str;

public Client(String str){
this.str = str;
}

public void run() {
try {
socket = new Socket("127.0.0.1", 10000);
//客户端发送给服务端消息
out = socket.getOutputStream();
out.write(str.getBytes());

//接收到的服务端返回信息
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
int len = 0;
String msg = "";
char buf[] = new char[4096];
while((len = in.read(buf)) > 0){
msg += new String(buf,0,len);
System.out.println("------服务端返回信息："+msg);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public static void main(String[] args){
new Client("hello_1").start();
new Client("hello_2").start();
new Client("hello_3").start();
new Client("hello_4").start();
}
}