（一）Socket概念：
socket时TCP/IP协议的抽象，是操作系统对外开放的接口
socket起源于unix，京客户端和服务端各自管理一个文件，是其能分别对文件进行读写操作
socket的通信流程：
(二)代码实现：
运行代码时要先运行服务器端，在运行客户端
编写TCP和UDP实现服务端与客户端的通信：
只能固定发送数据
TCP实现：
服务器端实现：
- 创建Socket，并将socket绑定端口
- while循环使得socket一直在等待状态
- 监听端口
- 获取客户端请求信息后，执行相关业务逻辑
import java.net.ServerSocket;
import java.net.Socket;
public class TCPServer{
public static void main(String []agrs)throws Exception{
ServerSocket ss=new ServerSocket(65000); //创建Socket，并将socket绑定端口
while(true){ //while循环使得socket一直在等待状态
Socket socket=ss.accept(); //监听端口
new LengthCalculator(socket).start(); //获取客户端请求信息后，执行相关业务逻辑
}
}
}
线程运行持续获得客户端的请求后，回送信息：
- 获取socket输入流
- 获取socket输出流
- buff读取输入内容
- 将接受流的byte数组转化为字符串
- 回送客户端字符串长度
- 关闭
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
public class LengthCalculator extends Thread{
private Socket socket;
public LengthCalculator(Socket socket){
this.socket=socket;
}
public void run(){
try{
//获取socket输入流
OutputStream os=socket.getOutputStream();
//获取socket输出流
InputStream is=socket.getInputStream();
int ch=0;
//buff读取输入内容
byte[]buff=new byte[1024];
ch=is.read(buff);
//将接受流的byte数组转化为字符串
String content=new String(buff,0,ch);
//回送客户端字符串长度
os.write(String.valueOf(content.length()).getBytes());
//关闭
is.close();
os.close();
socket.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
客户端的实现：
- 创建socket，并指定连接端口
- 获取输出流
- 获取输入流
- 将要传递给server的字符串转换为byte数组
- buff读取输入内容
- ch获取读取长度
- 关闭输入流及socket
import java.io.OutputStream;
import java.io.InputStream;
import java.net.Socket;
import java.net.Socket;
public class TCPClient{
public static void main(String []args)throws Exception{
//创建socket，并指定连接端口
Socket socket=new Socket(new InetSocketAddress("127.0.0.1",65000);
//获取输出流
OutputStream os=socket.getOutputStream();
//获取输入流
InputStream is=socket.getInputStream();
//将要传递给server的字符串转换为byte数组
os.write(new String("hello world").getBytes());
int ch=0;
//buff读取输入内容
byte[]buff=new byte[1024];
//ch获取读取长度
ch=is.read(buff);
String connect=new String (buff,0,ch);
System.out.println(connect);
//关闭输入流及socket
is.close();
os.close();
socket.close();
}
}
UDP实现：
运行代码时要先运行服务器端，在运行客户端
服务器端：
- 服务器端接受客户端发送的数据报
- 监听端口号
- 存储从客户端接收的内容
- 将客户端发送的内容封装进入DatagramPacket中
- 将数据从二进制转化为字符串的形式
- 将要发送的信息转化为二进制
- 服务端发送数据报
- 从DatagramPacket对象中获取到数据的来源地址和端口号
- 发送数据给客户端
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class UDPServer{
public static void main(String []args) throws Exception{
//服务器端接受客户端发送的数据报
//监听端口号
DatagramSocket socket=new DatagramSocket(65001);
//存储从客户端接收的内容
byte[]buff=new byte[100];
//将客户端发送的内容封装进入DatagramPacket中
DatagramPacket packet=new DatagramPacket(buff,buff.length);
socket.receive(packet);
//将数据从二进制转化为字符串的形式
byte[]data=packet.getData();
String content=new String(data,0,packet.getLength());
System.out.println(content);
// 将要发送的信息转化为二进制
byte[]sendedContent=String.valueOf(content.length()).getBytes();
//服务端发送数据报
//从DatagramPacket对象中获取到数据的来源地址和端口号
DatagramPacket packetToClient=new DatagramPacket(sendedContent,sendedContent.length,packet.getAddress(),packet.getPort());
//发送数据给客户端
socket.send(packetToClient);
}
}
客户端实现：
- 客户端给服务器端发送数据
- 存储要发送的数据
- 将IP地址封装成InetAddres对象
- 将要发送给服务器端的数据封装为DatagramPacket对象，要写上ip与端口号
- 发送数据给服务器
- 客户端接收服务器的数据
- 创建DatagramPacket对象来存储服务器发送的数据
- 将服务器端发送的数据取出并打印到控制台
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class UDPClient{
public static void main(String[]args)throws Exception{
//客户端给服务器端发送数据
DatagramSocket socket=new DatagramSocket();
//存储要发送的数据
byte[]buf="hello world".getBytes();
//将IP地址封装成InetAddres对象
InetAddress address=InetAddress.getByName("127.0.0.1");
//将要发送给服务器端的数据封装为DatagramPacket对象，要写上ip与端口号
DatagramPacket packet=new DatagramPacket(buf,buf.length,address,65001);
//发送数据给服务器
socket.send(packet);
//客户端接收服务器的数据
byte[]data=new byte[100];
//创建DatagramPacket对象来存储服务器发送的数据
DatagramPacket receivedPacket=new DatagramPacket(buf,buf.length);
socket.receive(receivedPacket);
//将服务器端发送的数据取出并打印到控制台
String content=new String(receivedPacket.getData(),0,receivedPacket.getLength());
System.out.println(content);
}
}
（三）升级版
可从键盘输入数据并发送
import java.io.*;
import java.net.Inet4Address;
import java.net.InetSocketAddress;
import java.net.Socket;
public class Client {
public static void main(String[] args) throws IOException {
Socket socket = new Socket();
// 连接本地
socket.setSoTimeout(3000);
// 连接本地，端口2000；超时时间3000ms
socket.connect(new InetSocketAddress(Inet4Address.getLocalHost(), 2000), 3000);
System.out.println("已发起服务器连接，并进入后续流程～");
System.out.println("客户端信息：" + socket.getLocalAddress() + " P:" + socket.getLocalPort());
System.out.println("服务器信息：" + socket.getInetAddress() + " P:" + socket.getPort());
try {
// 发送接收数据
todo(socket);
} catch (Exception e) {
System.out.println("异常关闭");
}
// 释放资源
socket.close();
System.out.println("客户端已退出～");
}
private static void todo(Socket client) throws IOException {
// 构建键盘输入流
InputStream in = System.in;
BufferedReader input = new BufferedReader(new InputStreamReader(in));
// 得到Socket输出流，并转换为打印流
OutputStream outputStream = client.getOutputStream();
PrintStream socketPrintStream = new PrintStream(outputStream);
// 得到Socket输入流，并转换为BufferedReader
InputStream inputStream = client.getInputStream();
BufferedReader socketBufferedReader = new BufferedReader(new InputStreamReader(inputStream));
boolean flag = true;
do {
// 键盘读取一行
String str = input.readLine();
// 发送到服务器
socketPrintStream.println(str);
// 从服务器读取一行
String echo = socketBufferedReader.readLine();
if ("bye".equalsIgnoreCase(echo)) {
flag = false;
}else {
System.out.println(echo);
}
}while (flag);
// 资源释放
socketPrintStream.close();
socketBufferedReader.close();
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static void main(String[] args) throws IOException {
ServerSocket server = new ServerSocket(2000);
System.out.println("服务器准备就绪～");
System.out.println("服务器信息：" + server.getInetAddress() + " P:" + server.getLocalPort());
// 等待客户端连接
for (; ; ) {
// 得到客户端
Socket client = server.accept();
// 客户端构建异步线程
ClientHandler clientHandler = new ClientHandler(client);
// 启动线程
clientHandler.start();
}
}
/**
* 客户端消息处理
*/
private static class ClientHandler extends Thread {
private Socket socket;
private boolean flag = true;
ClientHandler(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
super.run();
System.out.println("新客户端连接：" + socket.getInetAddress() +
" P:" + socket.getPort());
try {
// 得到打印流，用于数据输出；服务器回送数据使用
PrintStream socketOutput = new PrintStream(socket.getOutputStream());
// 得到输入流，用于接收数据
BufferedReader socketInput = new BufferedReader(new InputStreamReader(
socket.getInputStream()));
do {
// 客户端拿到一条数据
String str = socketInput.readLine();
if ("bye".equalsIgnoreCase(str)) {
flag = false;
// 回送
socketOutput.println("bye");
} else {
// 打印到屏幕。并回送数据长度
System.out.println(str);
socketOutput.println("回送：" + str.length());
}
} while (flag);
socketInput.close();
socketOutput.close();
} catch (Exception e) {
System.out.println("连接异常断开");
} finally {
// 连接关闭
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("客户端已退出：" + socket.getInetAddress() +
" P:" + socket.getPort());
}
}
}
服务器端运行后如图：
客户端运行后如图：
在客户端输入数据后如图效果
输入bye时退出：
运行代码时要先运行服务器端，在运行客户端
