Server
/*
* 基于TCP协议的Socket通信,实现用户登陆
* 服务器端(必须早于客户端启动)
*/
public class Server {
public static void main(String[] args) {
try {
// 1.创建一个服务器端的Socket,即ServerSocket,指定绑定的端口,并监听此端口
ServerSocket serverSocket = new ServerSocket(8888);
// 2.调用accept()方法开始监听,等待客户端的连接
System.out.println("***服务器即将启动,等待客户端的连接***");
Socket socket = serverSocket.accept();
// 3.获取输入流,并读取客户端信息
InputStream is = socket.getInputStream(); // 字节输入流
InputStreamReader isr = new InputStreamReader(is); // 将字节流转换为字符流
BufferedReader br = new BufferedReader(isr); // 为输入流添加缓冲
String info = null;
while ((info = br.readLine()) != null) { // 循环读取客户端的信息
System.out.println("我是服务器,客户端说:" + info);
}
socket.shutdownInput();
// 4.获取输出流,响应客户端的请求
OutputStream os = socket.getOutputStream();
PrintWriter pw = new PrintWriter(os); // 包装为打印流
pw.write("欢迎您!");
pw.flush(); // 调用flush()方法将缓冲输出
// 5.关闭资源
pw.close();
os.close();
br.close();
isr.close();
is.close();
socket.close();
serverSocket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
Client
/*
* 客户端
*/
public class Client {
public static void main(String[] args) {
try {
// 1.创建客户端Socket,指定服务器地址和端口
Socket socket = new Socket("localhost", 8888);
// 2.获取输出流,向服务器端发送消息
OutputStream os = socket.getOutputStream(); // 字节输出流
PrintWriter pw = new PrintWriter(os); // 将输出流包装为打印流
pw.write("用户名:admin;密码:123");
pw.flush();
socket.shutdownOutput();
// 3.获取输入流,并读取服务器端的响应信息
InputStream is = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(is));
String info = null;
while ((info = br.readLine()) != null) { //
System.out.println("我是客户端,服务器说:" + info);
}
// 4.关闭资源
br.close();
is.close();
pw.close();
os.close();
socket.close();
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
多线程版
/*
* 服务器线程处理类
*/
public class ServerThread extends Thread {
// 和本线程相关的Socket
Socket socket = null;
public ServerThread(Socket socket) {
this.socket = socket;
}
// 线程执行的操作,响应客户端的请求
public void run() {
InputStream is = null;
InputStreamReader isr = null;
BufferedReader br = null;
OutputStream os = null;
PrintWriter pw = null;
try {
// 获取输入流,并读取客户端信息
is = socket.getInputStream();
isr = new InputStreamReader(is);
br = new BufferedReader(isr);
String info = null;
while ((info = br.readLine()) != null) { // 循环读取客户端的信息
System.out.println("我是服务器,客户端说:"+info);
}
socket.shutdownInput(); // 关闭输入流
// 获取输出流,响应客户端的请求
os = socket.getOutputStream();
pw = new PrintWriter(os);
pw.write("欢迎您!");
pw.flush(); // 调用flush()方法将缓冲输出
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (pw != null)
pw.close();
if (os != null)
os.close();
if (br != null)
br.close();
if (isr != null)
isr.close();
if (is != null)
is.close();
if (socket != null)
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
// 1.创建一个服务器端的Socket,即ServerSocket,指定绑定的端口,并监听此端口
ServerSocket serverSocket = new ServerSocket(8888);
Socket socket = null;
// 记录客户端的数量
int count = 0;
System.out.println("***服务器即将启动,等待客户端的连接***");
// 循環監聽等待客戶端的连接
while (true) {
// 调用accept()方法开始监听,等待客户端的连接
socket = serverSocket.accept();
// 创建一个新的线程
ServerThread serverThread = new ServerThread(socket);
// 启动线程
serverThread.start();
count++; // 统计客户端的数量
System.out.println("客户端的数量:" + count);
InetAddress address = socket.getInetAddress();
System.out.println("当前客户端的IP:" + address.getHostAddress());
基于UDP实现
/*
* 服务器端,实现基于UDP的用户登录
*/
public class UDPServer {
public static void main(String[] args) throws IOException {
/*
* 接收客户端发送的数据
*/
// 1.创建服务器端DatagramSocket,指定端口
DatagramSocket socket = new DatagramSocket(8800);
// 2.创建数据报,用于接收客户端发送的数据
byte[] data = new byte[1024]; // 创建字节数组,指定接收的数据报的大小
DatagramPacket packet = new DatagramPacket(data, data.length);
// 3.接收客户端发送的数据
System.out.println("*****服务器端已经启动,等待客户端发送数据");
socket.receive(packet); // 此方法在接收到数据报之前会一直阻塞
// 4.读取数据
String info = new String(data, 0, packet.getLength());
System.out.println("我是服务器,客户端说:" + info);
/*
* 向客户端响应数据
*/
// 1.定义客户端的地址、端口号、数据
InetAddress address = packet.getAddress();
int port = packet.getPort();
byte[] data2 = "欢迎您!".getBytes();
// 2.创建数据报,包含响应的数据信息
DatagramPacket packet2 = new DatagramPacket(data2, data2.length, address, port);
// 3.响应客户端
socket.send(packet2);
// 4.关闭资源
socket.close();
}
}
/*
* 客户端
*/
public class UDPClient {
public static void main(String[] args) throws IOException {
/*
* 向服务器端发送数据
*/
// 1.定义服务器的地址、端口号、数据
InetAddress address = InetAddress.getByName("localhost");
int port = 8800;
byte[] data = "用户名:admin;密码:123".getBytes();
// 2.创建数据报,包含发送的数据信息
DatagramPacket packet = new DatagramPacket(data, data.length, address, port);
// 3.创建DatagramSocket对象
DatagramSocket socket = new DatagramSocket();
// 4.向服务器端发送数据报
socket.send(packet);
/*
* 接收服务器端响应的数据
*/
// 1.创建数据报,用于接收服务器端响应的数据
byte[] data2 = new byte[1024];
DatagramPacket packet2 = new DatagramPacket(data2, data2.length);
// 2.接收服务器响应的数据
socket.receive(packet2);
// 3.读取数据
String reply = new String(data2, 0, packet2.getLength());
System.out.println("我是客户端,服务器说:" + reply);
// 4.关闭资源
socket.close();
}
}
serverThread.setPriority(4); // 设置线程的优先级,范围为[1,10],默认为5