一般是用一个线程池来处理接受到的请求
直接上代码(一)
ServerThread层
1 import java.io.BufferedReader;
2 import java.io.InputStreamReader;
3 import java.io.PrintWriter;
4 import java.net.Socket;
5
6 public class ServerThread extends Thread {
7 private static int number = 0; // 保存本进程的客户计数
8
9 Socket socket = null; // 保存与本线程相关的Socket对象
10
11 public ServerThread(Socket socket, int clientnum) {
12
13 this.socket = socket;
14 number = clientnum;
15 System.out.println("当前在线的用户数: " + number);
16 }
17
18 @Override
19 public void run() {
20 try {
21
22 // 由Socket对象得到输入流,并构造相应的BufferedReader对象
23 BufferedReader in = new BufferedReader(new InputStreamReader(socket
24 .getInputStream()));
25
26 // 由Socket对象得到输出流,并构造PrintWriter对象
27 PrintWriter out = new PrintWriter(socket.getOutputStream());
28
29 // 由系统标准输入设备构造BufferedReader对象
30 BufferedReader sysin = new BufferedReader(new InputStreamReader(
31 System.in));
32
33 // 在标准输出上打印从客户端读入的字符串
34 System.out.println("[Client " + number + "]: " + in.readLine());
35
36 String line; // 保存一行内容
37
38 // 从标准输入读入一字符串
39 line = sysin.readLine();
40
41 while (!line.equals("bye")) { // 如果该字符串为 "bye",则停止循环
42
43 // 向客户端输出该字符串
44 out.println(line);
45
46 // 刷新输出流,使Client马上收到该字符串
47 out.flush();
48
49 // 在系统标准输出上打印读入的字符串
50 System.out.println("[Server]: " + line);
51
52 // 从Client读入一字符串,并打印到标准输出上
53 System.out.println("[Client " + number + "]: " + in.readLine());
54
55 // 从系统标准输入读入一字符串
56 line = sysin.readLine();
57 }
58
59 out.close(); // 关闭Socket输出流
60 in.close(); // 关闭Socket输入流
61 socket.close(); // 关闭Socket
62 } catch (Exception e) {
63 System.out.println("Error. " + e);
64 }
65 }
66 }
SocketClient层
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
/**
* 客户端Socket
*
* @author Administrator
*
*/
public class SocketClient {
/**
* 客户端Socket构造方法
*/
public SocketClient() {
try {
// 向本机的2121端口发出客户请求
Socket socket = new Socket("localhost", 2121);
System.out.println("Established a connection...");
// 由系统标准输入设备构造BufferedReader对象
BufferedReader sysin = new BufferedReader(new InputStreamReader(
System.in));
// 由Socket对象得到输出流,并构造PrintWriter对象
PrintWriter out = new PrintWriter(socket.getOutputStream());
// 由Socket对象得到输入流,并构造相应的BufferedReader对象
BufferedReader in = new BufferedReader(new InputStreamReader(socket
.getInputStream()));
String line; // 保存一行内容
// 从系统标准输入读入一字符串
line = sysin.readLine();
while (!line.equals("bye")) { // 若从标准输入读入的字符串为 "bye"则停止循环
// 将从系统标准输入读入的字符串输出到Server
out.println(line);
// 刷新输出流,使Server马上收到该字符串
out.flush();
// 在系统标准输出上打印读入的字符串
System.out.println("[Client]: " + line);
// 从Server读入一字符串，并打印到标准输出上
System.out.println("[Server]: " + in.readLine());
// 从系统标准输入读入一字符串
line = sysin.readLine();
}
out.close(); // 关闭Socket输出流
in.close(); // 关闭Socket输入流
socket.close(); // 关闭Socket
} catch (Exception e) {
System.out.println("Error. " + e);
}
}
/**
* 主方法
*
* @param args
*/
public static void main(String[] args) {
new SocketClient();
}
}
SocketServer层
import java.net.ServerSocket;
/**
* 服务器端Socket
*
* @author Administrator
*
*/
public class SocketServer {
/**
* 服务器端Socket构造方法
*/
public SocketServer() {
try {
int clientcount = 0; // 统计客户端总数
boolean listening = true; // 是否对客户端进行监听
ServerSocket server = null; // 服务器端Socket对象
try {
// 创建一个ServerSocket在端口2121监听客户请求
server = new ServerSocket(2121);
System.out.println("Server starts开始启动...");
} catch (Exception e) {
System.out.println("Can not listen to. " + e);
}
while (listening) {
// 客户端计数
clientcount++;
// 监听到客户请求,根据得到的Socket对象和客户计数创建服务线程,并启动之
new ServerThread(server.accept(), clientcount).start();
}
} catch (Exception e) {
System.out.println("Error. " + e);
}
}
/**
* 主方法
*
* @param args
*/
public static void main(String[] args) {
new SocketServer();
}
}
下面是Demo案例
Server端
package cn.kgc.sockettest.demo1;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 服务端
*/
public class Server {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(8080);
System.out.println("服务器启动完成...监听中");
//开启监听，等待客户端的访问
Socket socket = serverSocket.accept();
//获取输入流，因为是客户端向服务端发送了数据
InputStream inputStream = socket.getInputStream();
//创建一个缓冲流
BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
String info = null;
while ((info = br.readLine()) != null) {
System.out.println("这里是服务端 客户端是：" + info);
}
//向客户端做出相应
OutputStream outputStream = socket.getOutputStream();
info = "这里是服务端我们接受到了你消息";
outputStream.write(info.getBytes());
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Client端
package cn.kgc.sockettest.demo1;
import java.io.*;
import java.net.Socket;
/**
* 客户端
*/
public class Client {
public static void main(String[] args) {
try {
//IP地址
Socket socket = new Socket("localhost",8080);
OutputStream outputStream = socket.getOutputStream();
String info ="你好";
//输出！
outputStream.write(info.getBytes());
socket.shutdownOutput();
//接受服务器的响应
InputStream inputStream = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
while((info =br.readLine())!=null){
System.out.println("接收到了服务器的响应:"+info);
}
outputStream.flush();
outputStream.close();
inputStream.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
（二）
User层
package cn.kgc.sockettest.demo1.demo2;
import java.io.Serializable;
public class User implements Serializable {
private String userName;
private String password;
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
@Override
public String toString() {
return "Server{" +
"userName='" + userName + '\'' +
", password='" + password + '\'' +
'}';
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
Server端
package cn.kgc.sockettest.demo1.demo2;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(8080);
System.out.println("服务器启动完成。。。。。");
//开始监听
Socket socket = serverSocket.accept();
InputStream inputStream = socket.getInputStream();
ObjectInputStream stream = new ObjectInputStream(inputStream);
User user =(User)stream.readObject();
System.out.println("客户端发过来的数据是:"+user);
} catch (Exception e) {
e.printStackTrace();
}
}
}
Client层
package cn.kgc.sockettest.demo1.demo2;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;
/**
* 客户端
*/
public class Client {
public static void main(String[] args) {
try {
Socket socket = new Socket("localhost",8080);
OutputStream outputStream = socket.getOutputStream();
User user = new User();
user.setUserName("张三");
user.setPassword("admin");
//创建对象输出流
ObjectOutputStream oos = new ObjectOutputStream(outputStream);
//序列化对象
oos.writeObject(user);
//关闭流
oos.close();
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
