目录
关于synchronized使用和单例模式的原理和代码介绍（线程安全）
一、网络编程的概念
网络编程：指网络上的主机，通过不同的进程，以编程的方式实现网络通信（网络数据传输）
发送端和接收端只是相对的，只是一次网络数据传输产生数据流向后的概念
Socket套接字：由系统提供用于网络通信的技术，是基于TCP/IP协议的网络通信的基本操作单元。基于Socket套接字的网络程序开发就是网络编程。操作系统给应用程序提供的一组API。
TCP的特点：
- 有连接：需要连接成功才能发送数据（类似打电话）
- 可靠传输：发送方知道接收方有没有收到数据（显示已读未读）
- 面向字节流：以字节为单位传输（类似文件操作中的字节流）
- 有接收缓冲区，也有发送缓冲区：
- 全双工：一条通道，双向通信
- 大小不限
UDP的特点：
- 无连接 ：不需要接通，直接发数据（类似发微信）
- 不可靠传输：发送方不知道数据是否已被对方接收到
- 面向数据报：以数据报为单位传输（）
- 有接收缓冲区，无发送缓冲区：
- 大小受限：一次最多传输64k
- 全双工：一条通道，双向通信
二、UDP数据报套接字编程
UDP Socket 主要涉及两个类：DatagramSocket、DatagramPacket
DatagramSocket对象，对应到操作系统的一个socket文件（文件除了普通文件，还包括硬件设备 / 软件资源）
socket文件对应“网卡”这种硬件设备，从socket文件读写数据，就是读写网卡中的信息
2.1 回显服务器代码
构造一个回显服务器（请求和响应相同）：包括客户端和服务器的代码
（1）服务器端代码：
构造函数中关于port的指定：服务器需要手动指定端口号port（客户端需要根据端口号访问服务器），而客户端会自动指定端口（不知道客户端已经被占用了哪些端口），由于客户端为主动发起请求的一方，因此需要知道服务器的地址+端口
1. 启动服务器： start函数
2.读取客户端发来的请求，并将其解析为一个字符串
3.根据请求计算响应（是最复杂的过程）：String response = process(request)
4.把响应写回到客户端(需要先把数据构造成一个数据报)
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
/*回显服务端的代码：
1.先指定端口号接收，便于指定进程处理该信息
2.启动服务器：读取请求(若读到，则需要返回)----->根据请求计算响应
*/
public class UdpEchoServer {
private DatagramSocket socket = null; //创建实例socket，进行网络编程的前提
public UdpEchoServer(int port) throws SocketException { //构造方法传入端口进行绑定
socket = new DatagramSocket(port);
}
// 1. 启动服务器
public void start() throws IOException {
System.out.println("启动服务器！");
while (true) {
//DatagramPacket把一个字节数组(byte[])进行包装
// 2.读取客户端发来的请求，并将其解析为一个字符串
DatagramPacket requestPacket = new DatagramPacket(new byte[1024], 1024);
socket.receive(requestPacket); //接收数据（一个UDP数据报）
String request = new String(requestPacket.getData(),0,requestPacket.getLength(),"UTF-8");
//3. 根据请求计算相应（是最复杂的过程）
String response = process(request);
//4.把响应写回到客户端(需要先把响应 数据构造成一个数据报)，同时指定IP和端口
// response.getBytes()获取响应字节数组，response.getBytes().length获取字节数组长度;requestPacket.getSocketAddress()：指定发回去的地址（也即是客户端）
DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,
requestPacket.getSocketAddress());
socket.send(responsePacket);
//打印日志 %s:打印字符串 %d：打印有符号位十进制整数
String log = String.format("[%s:%d] req: %s; resp: %s",
requestPacket.getSocketAddress().toString(),
requestPacket.getPort(),
request,response);
System.out.println(log);
}
}
//由于是回响服务器，响应和请求是一样的
public String process(String request) {
return request; //返回请求值
}
public static void main(String[] args) throws IOException {
UdpEchoServer server = new UdpEchoServer(9090);
server.start();//启动服务器
}
}
（2）客户端代码：
1.从控制台读取用户输入的信息
2. 把读取的内容构造成一个UDP请求，并发送
3.从服务器读取响应数据，并解析
4.把响应结果显示到控制台
import javax.sound.sampled.Port;
import java.io.IOException;
import java.net.*;
import java.util.Scanner;
/*服务器需要手动指定端口号，而客户端会自动指定端口，无需手动执行
* */
public class UdpEchoClient {
private DatagramSocket socket = null;
private String serverIP;
private int serverPort;
public UdpEchoClient(String ip,int port) throws SocketException { //不需要指定端口port
socket = new DatagramSocket();
serverIP = ip;
serverPort = port;
}
public void start() throws IOException {
Scanner in = new Scanner((System.in));
while (true) {
// 1.从控制台读取用户输入的信息
System.out.println("->");
String request = in.next();
// 2. 把读取的内容构造成一个UDP请求(String数据内容+目的地服务器地址)，并发送
DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,
InetAddress.getByName(serverIP),serverPort); //等价于InetSocketAddress,获取地址和IP
socket.send(requestPacket);
// 3.从服务器读取响应数据，并解析
DatagramPacket responsePacket = new DatagramPacket(new byte[1024],1024);
socket.receive(responsePacket);
String response = new String(responsePacket.getData(),0,responsePacket.getLength(),"utf-8");
// 4.把响应结果显示到控制台
System.out.printf("req: %s, resp: %s\n", request, response);
}
}
public static void main(String[] args) throws IOException {
UdpEchoClient client = new UdpEchoClient("127.0.0.1",9090); //因为此处服务器在本机，所以指定的IP为本机环回IP
client.start();
}
}
开启多个客户端发送数据，按照下图进行配置
服务器输出结果：
2.2 翻译程序（英译汉）
（1）客户端程序不变，如上
（2）只需调整服务器代码，只要是修改process方法（根据请求处理响应）
import java.io.IOException;
import java.net.SocketException;
import java.util.HashMap;
public class UdpDictServer extends UdpEchoServer{
private HashMap<String,String> dict = new HashMap();
public UdpDictServer(int port) throws SocketException { //插入构造方法
super(port);
dict.put("cat","小猫");
dict.put("dog","小狗");
}
// 重写process
@Override //注意重写的UdpEchoServer中的process方法不能是私有的
public String process(String request) {
return dict.getOrDefault(request,"该词无法被查询到");
}
public static void main(String[] args) throws IOException {
UdpDictServer server = new UdpDictServer(9090);
server.start();
}
}
三、TCP数据报套接字编程
- ServerSocket专门给TCP服务器使用
- Socket给服务器和客户端使用
3.1回显服务器
1.读取请求
2.根据请求计算响应
3.把响应返回客户端
（1）服务器代码
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class TcpEpochServer {
private ServerSocket serverSocket = null; 定义一个变量表示服务器 listen 原意为监听
public TcpEpochServer(int port) throws IOException { //服务器需要指定端口号
serverSocket = new ServerSocket(port); //给服务器指定端口号
}
public void start() throws IOException {
System.out.println("启动服务器！！");
while (true) {
//1.由于tcp是有连接的，需要先进行连接才能读数据 若无客户端与其建立连接，accept则会阻塞
Socket clientSocket = serverSocket.accept(); //clientSocket完成后续操作
processConnection(clientSocket);
}
}
private void processConnection(Socket clientSocket) {
System.out.printf("[%s:%d] 客户端建立连接", clientSocket.getInetAddress().toString(),clientSocket.getPort());
try (InputStream inputStream = clientSocket.getInputStream()){
try (OutputStream outputStream = clientSocket.getOutputStream()) {
Scanner in = new Scanner(System.in);
while (true) { //循环处理每个请求
//1.读取请求
if (!in.hasNext()) {
System.out.printf("[%s:%d] 客户端建立连接", clientSocket.getInetAddress().toString(),clientSocket.getPort());
break;
}
String request = in.next();
//2.根据请求计算响应
String response = process(request);
//3.把响应返回客户端
PrintWriter printWriter = new PrintWriter(outputStream);
printWriter.println(response);
printWriter.flush(); //刷新缓冲区
System.out.printf("[%s:%d] req: %s,resp:%s\n",clientSocket.getInetAddress().toString(),
clientSocket.getPort(),request,response);
}
}
}catch (IOException e) {
e.printStackTrace();
}finally {
try {
clientSocket.close();
}catch (IOException e) {
e.printStackTrace();
}
}
}
public String process(String request) {
return request;
}
public static void main(String[] args) throws IOException {
TcpEpochServer server = =new TcpEpochServer(9090);
server.start();
}
}
（2）客户端代码（单个连接）
1.从控制台读取字符串数据
2.根据读取的数据构造请求，并把请求发送给服务器
3.从服务器读取响应，并解析
4.把结果显示到控制台上
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;
public class TcpEpochClient {
private Socket socket = null; //客户端不用指定IP，由系统自动分配即可
public TcpEpochClient(String serverIP,int serverPort) throws IOException {
socket = new Socket(serverIP,serverPort); //此处的端口号和IP表示的是服务器所有的，客户端通过超找到IP和端口进行连接
}
public void start() throws IOException {
System.out.println("和服务器连接成功");
Scanner in = new Scanner(System.in);
try (InputStream inputStream = socket.getInputStream()) {
try (OutputStream outputStream = socket.getOutputStream()) {
while (true) {
// 1.从控制台读取字符串数据
System.out.print("- >");
String request = in.next(); //请求为控制台输入内容
// 2.根据读取的数据构造请求，并把请求发送给服务器
PrintWriter printWriter = new PrintWriter(outputStream);//用·PrintWriter包装outputStream
printWriter.println(request); //打印请求
printWriter.flush(); //写入之后就需要刷新，否则服务器不能及时显示
// 3.从服务器读取响应，并解析
Scanner respScanner = new Scanner(inputStream); //读取输入请求的数据流
String response = respScanner.next();
// 4.把结果显示到控制台上
System.out.printf("req: %s,resp: %s\n",request,response);
}
}
}catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException {
TcpEpochClient client = new TcpEpochClient("127.0.0.1",9090);
client.start();
}
}
（2）客户端代码（建立多个连接）
由于服务器部分while处包含嵌套循环，导致内部循环未结束便不能进行外部循环，导致服务器不能与多个客户端建立连接 。
解决：主线程循环调用accept，有客户端连接时，则主线程创建一个新线程负责对客户端的若干请求（while循环处理请求）。由于多线程是并发执行的（宏观上是同时执行），由我们观察处理时就感觉到是各个线程独立执行，互不干扰，便就实现了多客户端连接。对如下代码进行改进即可。
改进1：每次accept成功，就创建一个线程，由其负责执行客户端的请求
public void start() throws IOException {
System.out.println("服务器启动！！");
while (true) { //此处包含两个循环（processConnection方法内部有一个循环）
//1.由于tcp是有连接的，需要先进行连接才能读数据 若无客户端与其建立连接，accept则会阻塞
Socket clientSocket = serverSocket.accept(); //clientSocket完成后续与客户端之间的沟通
Thread t = new Thread(() ->{ //创建线程，使processConnection在线程内部执行
processConnection(clientSocket);
});
t.start();
}
}改进2：每次accept成功，就创建线程池，由其负责执行客户端的请求
public void start() throws IOException {
System.out.println("服务器启动！！");
ExecutorService pool = Executors.newCachedThreadPool(); //创建线程池
while (true) { //此处包含两个循环（processConnection方法内部有一个循环）
//1.由于tcp是有连接的，需要先进行连接才能读数据 若无客户端与其建立连接，accept则会阻塞
Socket clientSocket = serverSocket.accept(); //clientSocket完成后续与客户端之间的沟通
pool.submit(new Runnable() {
@Override
public void run() {
processConnection(clientSocket);
}
});
}
}完整代码：
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class TcpThreadEpochServer {
private ServerSocket serverSocket = null; //定义一个变量表示服务器
public TcpThreadEpochServer(int port) throws IOException { //服务器需要指定端口号
serverSocket = new ServerSocket(port); //给服务器指定端口号
}
public void start() throws IOException {
System.out.println("服务器启动！！");
while (true) { //此处包含两个循环（processConnection方法内部有一个循环）
//1.由于tcp是有连接的，需要先进行连接才能读数据 若无客户端与其建立连接，accept则会阻塞
Socket clientSocket = serverSocket.accept(); //clientSocket完成后续与客户端之间的沟通
Thread t = new Thread(() ->{ //创建线程，使processConnection在线程内部执行
processConnection(clientSocket);
});
t.start();
}
}
private void processConnection(Socket clientSocket) {
System.out.printf("[%s:%d] 客户端建立连接\n", clientSocket.getInetAddress().toString(),clientSocket.getPort());
try (InputStream inputStream = clientSocket.getInputStream()){
try (OutputStream outputStream = clientSocket.getOutputStream()) {
Scanner in = new Scanner(System.in);
while (true) { //循环处理每个请求
if (!in.hasNext()) { //1.读取请求
System.out.printf("[%s:%d] 客户端断开连接\n", clientSocket.getInetAddress().toString(),clientSocket.getPort());
break;
}
String request = in.next();
String response = process(request); //2.根据请求计算响应
PrintWriter printWriter = new PrintWriter(outputStream); //3.把响应返回客户端
printWriter.println(response);
printWriter.flush(); //刷新缓冲区,可能导致客户端不能第一时间看到响应
System.out.printf("[%s:%d] req: %s,resp:%s\n",clientSocket.getInetAddress().toString(),
clientSocket.getPort(),request,response);
}
}
}catch (IOException e) {
e.printStackTrace();
}finally {
try {
clientSocket.close(); //关闭操作
}catch (IOException e) {
e.printStackTrace();
}
}
}
public String process(String request) {
return request;
}
public static void main(String[] args) throws IOException {
TcpThreadEpochServer server = new TcpThreadEpochServer(9090);
server.start();
}
}
3.2 翻译服务器
客户端内容不做改动，只需对服务器中的process方法改动即可（实现翻译的逻辑），让翻译客户端继承自上面的客户端即可。
import java.io.IOException;
import java.util.HashMap;
public class TcpDictServer extends TcpEpochServer{ //继承之后重写process方法
private HashMap<String,String> map = new HashMap<>(); //创建一个HashMap用于接收翻译之间的映射关系
public TcpDictServer(int port) throws IOException {
super(port);
map.put("cat","猫咪");
map.put("dog","小狗");
map.put("pig","小猪");
map.put("apple","苹果");
map.put("banana","香蕉");
}
@Override
public String process(String request) {
return map.getOrDefault(request,"当前语料库不足以翻译此词条");
}
public static void main(String[] args) throws IOException {
TcpDictServer server = new TcpDictServer(9090);
server.start();
}
}
348
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
