目录
4.6.2.1 拓展知识：每次请求都开一个新线程，到底好不好?
前言
java网络编程笔记复盘【完】，后续更细在java高级技术
一、网络通信的概述
1. 什么是网络编程?
可以让设备中的程序与网络上其他设备中的程序进行数据交互(实现网络通信的)
Java提供了哪些网络编程的解决方案：
java.net.*包下提供了网络编程的解决方案
基本的通信架构
基本的通信架构有2种形式：CS架构(Client客户端/Server服务端)、BS架构(Browser浏览器/Server服务端)
二、网络通信的三要素
2.1 IP地址
- IP(InternetProtocol)：全称”互联网协议地址”，是分配给上网设备的唯一标志。【设备在网络中的地址，是唯一的标识。（可以理解为设备在网络中的身份证号码）】
- IP地址有两种形式：IPV4、IPV6
IPv6地址
- IPv6：共128位，号称可以为地球每一粒沙子编号，
- IPV6分成8段表示，每段每四位编码成一个十六进制位表示，数之间用冒号(:)分开
IP域名
公网IP，内网IP
- 公网IP：是可以连接互联网的IP地址;内网IP:也叫局域网IP，只能组织机构内部使用
- 192.168.开头的就是常见的局域网地址，范围即为192.168.0.0--192.168.255.255，专门为组织机构内部使用。
特殊IP地址
127.0.0.1、localhost：代表本机IP，只会寻找当前所在的主机
IP常用命令:
- ipconfig：查看本机IP地址。
- pingIP地址：检查网络是否连通。
InetAddress
代表IP地址
InetAddressTest.class
package com.itheima.d1_ip;
import java.net.InetAddress;
public class InetAddressTest {
public static void main(String[] args) throws Exception {
//1、获取本机IP地址对象的
InetAddress ip1 = InetAddress.getLocalHost();
System.out.println(ip1.getHostName());
System.out.println(ip1.getHostAddress());
//2、获取指定IP或着域名的IP地址对象
InetAddress ip2 = InetAddress.getByName("www.bilibili.com");
System.out.println(ip2.getHostName());
System.out.println(ip2.getHostAddress());
//相当于ping命令
System.out.println(ip2.isReachable(6000));
}
}
2.2 端口号
标记正在计算机设备上运行的应用程序的，被规定为一个16位的二进制，范围是0~65535
分类
- 周知端口：0~1023，被预先定义的知名应用占用(如:HTTP占用 80，FTP占用21)
- 注册端口：1024~49151，分配给用户进程或某些应用程序
- 动态端口：49152到65535，之所以称为动态端口，是因为它 一般不固定分配某种进程，而是动态分配。
注意：我们自己开发的程序一般选择使用注册端口，且一个设备中不能出现两个程序的端口号一样，否则出错。
2.3 协议
网络上通信的设备，事先规定的连接规则，以及传输数据的规则被称为网络通信协议。
开放式网络互联标准：OSI网络参考模型
- OSI网络参考模型：全球网络互联标准
- TCP/IP网络模型：事实上的国际标准
传输层的2个通信协议
UDP(User Datagram Protocol)：用户数据报协议；TCP(Transmission ControlProtocol)：传输控制协议
UDP协议（通信效率高）
- 特点：无连接、不可靠通信。
- 不事先建立连接，数据按照包发，一包数据包含:自己的IP、程序端口，目的地IP、程序端口和数据(限制在64KB内)等。
- 发送方不管对方是否在线，数据在中间丢失也不管，如果接收方收到数据也不返回确认，故是不可靠的
TCP协议（通信效率相对不高）
- 特点：面向连接、可靠通信。
- TCP的最终目的：要保证在不可靠的信道上实现可靠的传输
- TCP主要有三个步骤实现可靠传输：三次握手建立连接，传输数据进行确认，四次挥手断开连接。
传输数据会进行确认，以保证数据传输的可靠性
三、UDP
3.1 UDP通信-快速入门
- 特点：无连接、不可靠通信。
- 不事先建立连接;发送端每次把要发送的数据(限制在64KB内)、接收端IP、等信息封装成一个数据包，发出去就不管了。
- Java提供了一个java.net.DatagramSocket类来实现UDP通信
DatagramSocket：用于创建客户端、服务端
DatagramPacket：创建数据包
Client.class
package com.itheima.d2_upd1;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class Client {
public static void main(String[] args) throws Exception {
//1、创建客户端对象(发非菜出去的人)
DatagramSocket socket=new DatagramSocket();
//2、创建数据包对象封装要发出去的数据(创建一个韭菜盘子)
//public DatagramPacket(byte buf[],int length,InetAddress address,int port)
//参数一:封装要发出去的数据。
//参数二:发送出去的数据大小(字节个数)
//参数三:服务端的IP地址(找到服务端主机)
//参数四:服务端程序的端口。
byte[] bytes = "我是一个客户端".getBytes();
DatagramPacket packet=new DatagramPacket(bytes,bytes.length, InetAddress.getLocalHost(),6666);
//3、开始正式发送这个数据包的数据出去了
socket.send(packet);
System.out.println("客户端数据发送完毕");
socket.close();//释放资源
}
}
Server.class
package com.itheima.d2_upd1;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class Server {
public static void main(String[] args) throws Exception {
System.out.println("服务端启动！");
//1、创建一个雁务端对象(创建一个接韭菜的人)，注册端口
DatagramSocket socket = new DatagramSocket(6666);
// 2、创建一个数据包对象，用于接收数据的(创建一个韭菜盘子)
byte[] buffer = new byte[1024 * 64];//64KB
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
//3、开始正式使用数据包来接收客户端发来的数据
socket.receive(packet);
//4、从字节数组中，把接收到的数据直接打印出来
//接收多少就倒出多少
// 获取本次数据包接收了多少数据
int length = packet.getLength();
String rs = new String(buffer, 0, length);
System.out.println(rs);
System.out.println(packet.getAddress().getHostAddress());
System.out.println(packet.getPort());
socket.close();//释放资源
}
}
3.2 UDP通信-多发多收
Client.class
package com.itheima.d3_udp2;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;
public class Client {
public static void main(String[] args) throws Exception {
//1、创建客户端对象(发非菜出去的人)
DatagramSocket socket = new DatagramSocket();
//2、创建数据包对象封装要发出去的数据(创建一个韭菜盘子)
//public DatagramPacket(byte buf[],int length,InetAddress address,int port)
//参数一:封装要发出去的数据。
//参数二:发送出去的数据大小(字节个数)
//参数三:服务端的IP地址(找到服务端主机)
//参数四:服务端程序的端口。
// byte[] bytes = "我是一个客户端".getBytes();
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请说");
String msg = sc.nextLine();
//一旦发现用户输入的exit命令，就退出客户端
if ("exit".equals(msg)) {
System.out.println("欢迎您下次使用，退出成功！");
socket.close();//释放资源
break;//退出死循环
}
byte[] bytes = msg.getBytes();
DatagramPacket packet = new DatagramPacket(bytes, bytes.length, InetAddress.getLocalHost(), 6666);
//3、开始正式发送这个数据包的数据出去了
socket.send(packet);
}
}
}
Server.class
package com.itheima.d3_udp2;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class Server {
public static void main(String[] args) throws Exception {
System.out.println("服务端启动！");
//1、创建一个雁务端对象(创建一个接韭菜的人)，注册端口
DatagramSocket socket = new DatagramSocket(6666);
// 2、创建一个数据包对象，用于接收数据的(创建一个韭菜盘子)
byte[] buffer = new byte[1024 * 64];//64KB
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
while (true) {
//3、开始正式使用数据包来接收客户端发来的数据
socket.receive(packet);
//4、从字节数组中，把接收到的数据直接打印出来
//接收多少就倒出多少
// 获取本次数据包接收了多少数据
int length = packet.getLength();
String rs = new String(buffer, 0, length);
System.out.println(rs);
System.out.println(packet.getAddress().getHostAddress());
System.out.println(packet.getPort());
}
}
}
如果要使用多个客户端通信的话，在运行设置中
四、TCP
4.1 TCP通信-快速入门
- 特点：面向连接、可靠通信
- 通信双方事先会采用“三次握手”方式建立可靠连接，实现端到端的通信;底层能保证数据成功传给服务端
- Java提供了一个java.net.Socket类来实现TCP通信
4.2 TCP通信之-客户端开发
客户端程序就是通过java.net包下的Socket类来实现的
Client.class
package com.itheima.d4_tcp1;
import java.io.DataOutputStream;
import java.io.OutputStream;
import java.net.Socket;
public class Client {
public static void main(String[] args) throws Exception {
//1、创建Socket对象，并同时请求与服务端程序的连接
Socket socket = new Socket("127.0.0.0",8888);
//2、从socket通信管道中得到一个字节输出流，用来发数据给服务端程序。
OutputStream os = socket.getOutputStream();
//3、把低级的字节输出流包装成数据输出流
DataOutputStream dos=new DataOutputStream(os);
// 4、开始写数据出去了
dos.writeUTF("你好！");
dos.close();
socket.close();
}
}
4.3TCP通信之-服务器端开发
服务端是通过java.net包下的ServerSocket类来实现的
Client.class
package com.itheima.d4_tcp1;
import java.io.DataOutputStream;
import java.io.OutputStream;
import java.net.Socket;
public class Client {
public static void main(String[] args) throws Exception {
//1、创建Socket对象，并同时请求与服务端程序的连接
Socket socket = new Socket("127.0.0.1",8888);
//2、从socket通信管道中得到一个字节输出流，用来发数据给服务端程序。
OutputStream os = socket.getOutputStream();
//3、把低级的字节输出流包装成数据输出流
DataOutputStream dos=new DataOutputStream(os);
// 4、开始写数据出去了
dos.writeUTF("你好！");
dos.close();
socket.close();
}
}
Server.class
package com.itheima.d4_tcp1;
import java.io.DataInputStream;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static void main(String[] args) throws Exception {
System.out.println("======服务端启动======");
//1、创建ServerSocket的对象，同时为服务端注册口。
ServerSocket serverSocket = new ServerSocket(8888);
//2、使用serverSocket对象，调用个accept方法，等待客户端的连接请求
Socket socket = serverSocket.accept();
//3、从socket迎信管道中得到一个字节输入流。
InputStream is = socket.getInputStream();
// 4、把原始的字节输入流包装成数输入流
DataInputStream dis = new DataInputStream(is);
//5、使用数据输入流读取客户端发送过来的消息
String rs = dis.readUTF();
System.out.println(rs);
// 其实我们也可以获取客户端的IP地址
System.out.println(socket.getRemoteSocketAddress());
dis.close();
socket.close();
}
}
4.4 TCP通信-多发多收
Client.class
package com.itheima.d4_tcp1;
import java.io.DataOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
public class Client {
public static void main(String[] args) throws Exception {
//1、创建Socket对象，并同时请求与服务端程序的连接
Socket socket = new Socket("127.0.0.1",8888);
//2、从socket通信管道中得到一个字节输出流，用来发数据给服务端程序。
OutputStream os = socket.getOutputStream();
//3、把低级的字节输出流包装成数据输出流
DataOutputStream dos=new DataOutputStream(os);
Scanner sc=new Scanner(System.in);
while (true) {
System.out.println("请说：");
String msg = sc.nextLine();
// 一旦用户输入了exit，就退出客户端程片
if("exit".equals(msg)){
System.out.println("欢迎您下您光临！");
dos.close();
socket.close();
break;
}
// 4、开始写数据出去了
dos.writeUTF("你好！");
dos.flush();
}
}
}
Server.class
package com.itheima.d4_tcp1;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static void main(String[] args) throws Exception {
System.out.println("======服务端启动======");
//1、创建ServerSocket的对象，同时为服务端注册口。
ServerSocket serverSocket = new ServerSocket(8888);
//2、使用serverSocket对象，调用个accept方法，等待客户端的连接请求
Socket socket = serverSocket.accept();
//3、从socket迎信管道中得到一个字节输入流。
InputStream is = socket.getInputStream();
// 4、把原始的字节输入流包装成数输入流
DataInputStream dis = new DataInputStream(is);
while (true) {
//5、使用数据输入流读取客户端发送过来的消息
try {
String rs = dis.readUTF();
System.out.println(rs);
} catch (Exception e) {
System.out.println(socket.getRemoteSocketAddress()+"离线了！");
dis.close();
socket.close();
e.printStackTrace();
}
// 其实我们也可以获取客户端的IP地址
//System.out.println(socket.getRemoteSocketAddress());
}
}
}
4.5 TCP通信-支持与多个客户端同时通信
Client.class
package com.itheima.d5_tcp2;
import java.io.DataOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
public class Client {
public static void main(String[] args) throws Exception {
//1、创建Socket对象，并同时请求与服务端程序的连接
Socket socket = new Socket("127.0.0.1",8888);
//2、从socket通信管道中得到一个字节输出流，用来发数据给服务端程序。
OutputStream os = socket.getOutputStream();
//3、把低级的字节输出流包装成数据输出流
DataOutputStream dos=new DataOutputStream(os);
Scanner sc=new Scanner(System.in);
while (true) {
System.out.println("请说：");
String msg = sc.nextLine();
// 一旦用户输入了exit，就退出客户端程片
if("exit".equals(msg)){
System.out.println("欢迎您下您光临！");
dos.close();
socket.close();
break;
}
// 4、开始写数据出去了
dos.writeUTF(msg);
dos.flush();
}
}
}
Server.class
package com.itheima.d5_tcp2;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static void main(String[] args) throws Exception {
System.out.println("======服务端启动======");
//1、创建ServerSocket的对象，同时为服务端注册口。
ServerSocket serverSocket = new ServerSocket(8888);
while (true) {
//2、使用serverSocket对象，调用个accept方法，等待客户端的连接请求
Socket socket = serverSocket.accept();
System.out.print("有人上线了！");
System.out.println(socket.getRemoteSocketAddress());
//3、从socket迎信管道中得到一个字节输入流。
new ServiceReaderThread(socket).start();
}
}
}
ServiceReaderThread.class
package com.itheima.d5_tcp2;
import java.io.DataInputStream;
import java.io.InputStream;
import java.net.Socket;
public class ServiceReaderThread extends Thread {
private Socket socket;
public ServiceReaderThread(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
InputStream is = socket.getInputStream();
DataInputStream dis = new DataInputStream(is);
while (true){
try {
String msg = dis.readUTF();
System.out.println(msg);
} catch (Exception e) {
System.out.println("有人下线了！"+socket.getRemoteSocketAddress());
dis.close();
socket.close();
break;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
4.6 TCP通信-综合案例
4.6.1 群聊实现
Client.class
package com.itheima.d6_tcp3;
import java.io.DataOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
public class Client {
public static void main(String[] args) throws Exception {
//1、创建Socket对象，并同时请求与服务端程序的连接
Socket socket = new Socket("127.0.0.1",8888);
//创建一个独立的线程，负责机从socket中接收服务发送过来的消息。
new ClientReaderThread(socket).start();
//2、从socket通信管道中得到一个字节输出流，用来发数据给服务端程序。
OutputStream os = socket.getOutputStream();
//3、把低级的字节输出流包装成数据输出流
DataOutputStream dos=new DataOutputStream(os);
Scanner sc=new Scanner(System.in);
while (true) {
System.out.println("请说：");
String msg = sc.nextLine();
// 一旦用户输入了exit，就退出客户端程片
if("exit".equals(msg)){
System.out.println("欢迎您下您光临！");
dos.close();
socket.close();
break;
}
// 4、开始写数据出去了
dos.writeUTF(msg);
dos.flush();
}
}
}
Server.java
package com.itheima.d6_tcp3;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
public class Server {
public static List<Socket> onLineSocket = new ArrayList<>();
public static void main(String[] args) throws Exception {
System.out.println("======服务端启动======");
//1、创建ServerSocket的对象，同时为服务端注册口。
ServerSocket serverSocket = new ServerSocket(8888);
while (true) {
//2、使用serverSocket对象，调用个accept方法，等待客户端的连接请求
Socket socket = serverSocket.accept();
onLineSocket.add(socket);
System.out.print("有人上线了！");
System.out.println(socket.getRemoteSocketAddress());
//3、从socket迎信管道中得到一个字节输入流。
new ServiceReaderThread(socket).start();
}
}
}
ServiceReaderThread.class
package com.itheima.d6_tcp3;
import java.io.*;
import java.net.Socket;
public class ServiceReaderThread extends Thread {
private Socket socket;
public ServiceReaderThread(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
InputStream is = socket.getInputStream();
DataInputStream dis = new DataInputStream(is);
while (true) {
try {
String msg = dis.readUTF();
System.out.println(msg);
//把这个消息分发给全部客户端进行接收
sendMsgToAll(msg);
} catch (Exception e) {
System.out.println("有人下线了！" + socket.getRemoteSocketAddress());
Server.onLineSocket.remove(socket);
dis.close();
socket.close();
break;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
private void sendMsgToAll(String msg) throws Exception {
//发送给全部在线的socket管道接收。
for (Socket onLineSocket : Server.onLineSocket) {
OutputStream os = onLineSocket.getOutputStream();
DataOutputStream dos = new DataOutputStream(os);
dos.writeUTF(msg);
dos.flush();
}
}
}
ClientReaderThread.class
package com.itheima.d6_tcp3;
import java.io.DataInputStream;
import java.io.InputStream;
import java.net.Socket;
public class ClientReaderThread extends Thread{
private Socket socket;
public ClientReaderThread(Socket socket){
this.socket=socket;
}
@Override
public void run() {
try {
InputStream is = socket.getInputStream();
DataInputStream dis = new DataInputStream(is);
while (true) {
try {
String msg = dis.readUTF();
System.out.println(msg);
//把这个消息分发给全部客户端进行接收
} catch (Exception e) {
System.out.println("自己下线了！" + socket.getRemoteSocketAddress());
Server.onLineSocket.remove(socket);
dis.close();
socket.close();
break;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
4.6.2 实现一个简易版的BS架构
注意：服务器必须给浏览器响应HTTP协议规定的数据格式，否则浏览器不识别返回的数据
HTTP协议规定：响应给浏览器的数据格式必须满足如下格式
Server.class
package com.itheima.d7_tcp4;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
public class Server {
public static List<Socket> onLineSocket = new ArrayList<>();
public static void main(String[] args) throws Exception {
System.out.println("======服务端启动======");
//1、创建ServerSocket的对象，同时为服务端注册口。
ServerSocket serverSocket = new ServerSocket(8080);
while (true) {
//2、使用serverSocket对象，调用个accept方法，等待客户端的连接请求
Socket socket = serverSocket.accept();
onLineSocket.add(socket);
System.out.print("有人上线了！");
System.out.println(socket.getRemoteSocketAddress());
//3、从socket迎信管道中得到一个字节输入流。
new ServiceReaderThread(socket).start();
}
}
}
ServerReaderThread.class
package com.itheima.d7_tcp4;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
public class ServiceReaderThread extends Thread {
private Socket socket;
public ServiceReaderThread(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
//立即响应一个网页内容:“你好"给测览器展示。
try {
OutputStream os=socket.getOutputStream();
PrintStream ps=new PrintStream(os);
ps.println("HTTP/1.1 200 OK");
ps.println("Content-Type:text/html;charset=UTF-8");
ps.println();//****************必须空一行*********************
ps.println("<div style='color:red;font-size:20px;text-align:center'>你好!</div>");
ps.close();
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
4.6.2.1 拓展知识：每次请求都开一个新线程，到底好不好?
使用线程池进行优化
Server.class
package com.itheima.d8_tcp5;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Server {
public static List<Socket> onLineSocket = new ArrayList<>();
public static void main(String[] args) throws Exception {
System.out.println("======服务端启动======");
//1、创建ServerSocket的对象，同时为服务端注册口。
ServerSocket serverSocket = new ServerSocket(8080);
// 创建出一个线程池负责处理通信管道的任务。
ThreadPoolExecutor pool = new ThreadPoolExecutor(13 * 2, 13 * 2, 0, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(8), Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
while (true) {
//2、使用serverSocket对象，调用个accept方法，等待客户端的连接请求
Socket socket = serverSocket.accept();
onLineSocket.add(socket);
System.out.print("有人上线了！");
System.out.println(socket.getRemoteSocketAddress());
//3、从socket迎信管道中得到一个字节输入流。
pool.execute(new ServerReaderRunnable(socket));
}
}
}
ServerReaderRunnable.class
package com.itheima.d8_tcp5;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
public class ServerReaderRunnable implements Runnable {
private Socket socket;
public ServerReaderRunnable(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
//立即响应一个网页内容:“你好"给测览器展示。
try {
OutputStream os=socket.getOutputStream();
PrintStream ps=new PrintStream(os);
ps.println("HTTP/1.1 200 OK");
ps.println("Content-Type:text/html;charset=UTF-8");
ps.println();//****************必须空一行*********************
ps.println("<div style='color:red;font-size:20px;text-align:center'>你好!</div>");
ps.close();
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
1422
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
