网络编程作用？
可以让程序与网络上的其他设备中的程序进行数据交互的。
网络通信基本模式
2种形式：
- Client-Server(CS)
- Browser-Server(BS)
一、网络通信三要素
要素一：IP地址
1.1 三要素概述、要素一：IP地址
- IP地址：设备在网络中的唯一标识。
- 端口：应用程序在设备中唯一的标识。
- 协议: 数据在网络中传输的规则，常见协议有UDP协议TCP和协议。
IP地址
- IP（Internet Protocol）”互联网协议地址”：分配给上网设备的唯一标志。
- 常见IP分类：IPv4和IPv6
1.2 IP地址操作类-InetAddress
代码：
import java.net.InetAddress;
/**
目标：InetAddress类概述（了解）
一个该类的对象代表一个IP地址对象。
InetAddress类成员方法：
static InetAddress getLocalHost()
* 获得本地主机IP地址对象。
static InetAddress getByName(String host)
* 根据IP地址字符串或主机名获得对应的IP地址对象。
String getHostName()
* 获得主机名。
String getHostAddress()
* 获得IP地址字符串。
*/
public class InetAddressDemo01 {
public static void main(String[] args) throws Exception {
// 1.获取本机地址对象。
InetAddress ip1 = InetAddress.getLocalHost();
System.out.println(ip1);
System.out.println(ip1.getHostName());
System.out.println(ip1.getHostAddress());
System.out.println("------------------");
InetAddress byName = InetAddress.getByName("DESKTOP-LORLSR2");
System.out.println(byName);
System.out.println(byName.getHostName());
System.out.println(byName.getHostAddress());
System.out.println("------------------");
// 2.获取域名ip对象
InetAddress ip2 = InetAddress.getByName("www.baidu.com");
System.out.println(ip2.getHostName());
System.out.println(ip2.getHostAddress());
System.out.println("------------------");
// 3.获取公网IP对象。
InetAddress ip3 = InetAddress.getByName("112.80.248.76");
System.out.println(ip3.getHostName());
System.out.println(ip3.getHostAddress());
System.out.println("------------------");
// 4.判断是否能通： ping 5s之前测试是否可通
System.out.println(ip3.isReachable(5000));
}
}要素二：端口号
- 端口号：标识在计算机上运行的进程，被规定为一个 16 位的二进制，范围是 0~65535。
要素三：协议
- 连接和通信数据的规则
传输层2个常见协议
二、UDP通信
简单发送
代码：
client：
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
/**
* 发送端
*/
public class ClientDemo1 {
public static void main(String[] args) throws Exception {
System.out.println("=====客户端启动======");
// 1、创建发送端对象：发送端自带默认的端口号（人）
DatagramSocket socket = new DatagramSocket(6666);
// 2、创建一个数据包对象封装数据（韭菜盘子）
/**
public DatagramPacket(byte buf[], int length,
InetAddress address, int port)
参数一：封装要发送的数据（韭菜）
参数二：发送数据的大小
参数三：服务端的主机IP地址
参数四：服务端的端口
*/
byte[] buffer = "我是一颗快乐的韭菜，你愿意吃吗？".getBytes();
DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getLocalHost(), 8888);
// 3、发送数据出去
socket.send(packet);
socket.close();
}
}
server：
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
/**
接收端
*/
public class ServerDemo2 {
public static void main(String[] args) throws Exception {
System.out.println("=====服务端启动======");
// 1、创建接收端对象：注册端口（人）
DatagramSocket socket = new DatagramSocket(8888);
// 2、创建一个数据包对象接收数据（韭菜盘子）
byte[] buffer = new byte[1024 * 64];
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
// 3、等待接收数据。
socket.receive(packet);
// 4、取出数据即可
// 读取多少倒出多少
int len = packet.getLength();
String rs = new String(buffer,0, len);
System.out.println("接收到数据：" + rs);
// 获取发送端ip和端口
String ip =packet.getSocketAddress().toString();
System.out.println("对方地址：" + ip);
int port = packet.getPort();
System.out.println("对方端口：" + port);
socket.close();
}
}多发多收
代码：
client：
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.MulticastSocket;
import java.util.Scanner;
/**
* 发送端 多发 多收
*/
public class ClientDemo1 {
public static void main(String[] args) throws Exception {
System.out.println("=====客户端启动======");
// 1、创建发送端对象：发送端自带默认的端口号（人）
DatagramSocket socket = new DatagramSocket();
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请说：");
String msg = sc.nextLine();
if ("exit".equals(msg)) {
System.out.println("离线成功！");
socket.close();
break;
}
// 2、创建一个数据包对象封装数据（韭菜盘子）
byte[] buffer = msg.getBytes();
DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getLocalHost(), 8888);
// 3、发送数据出去
socket.send(packet);
}
}
}server：
import java.net.DatagramPacket;
import java.net.DatagramSocket;
/**
接收端
*/
public class ServerDemo2 {
public static void main(String[] args) throws Exception {
System.out.println("=====服务端启动======");
// 1、创建接收端对象：注册端口（人）
DatagramSocket socket = new DatagramSocket(8888);
// 2、创建一个数据包对象接收数据（韭菜盘子）
byte[] buffer = new byte[1024 * 64];
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
while (true) {
// 3、等待接收数据。
socket.receive(packet);
// 4、取出数据即可
// 读取多少倒出多少
int len = packet.getLength();
String rs = new String(buffer,0, len);
System.out.println("收到了来自：" + packet.getAddress() +", 对方端口是" + packet.getPort() +"的消息：" + rs);
}
}
}UDP通信-广播、组播
组播代码：
client：
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MulticastSocket;
public class Send {
public static void main(String[] args) throws IOException {
/*
组播发送端
*/
MulticastSocket ms = new MulticastSocket();
String s = "你好";
byte[] bytes = s.getBytes();
InetAddress address = InetAddress.getByName("224.0.0.1");
int port = 10000;
DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length, address, port);
ms.send(datagramPacket);
ms.close();
}
}
server：
package com.itheima.d4_upd4;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MulticastSocket;
public class Recive_1/_2/_3 { // 均相同
public static void main(String[] args) throws IOException {
/*
组播接收端
*/
MulticastSocket ms = new MulticastSocket(10000);
InetAddress address = InetAddress.getByName("224.0.0.1");
ms.joinGroup(address);
byte[] bytes = new byte[1024];
DatagramPacket dp = new DatagramPacket(bytes, bytes.length);
ms.receive(dp);
byte[] data = dp.getData();
int len = dp.getLength();
String ip = dp.getAddress().getHostAddress();
String name = dp.getAddress().getHostName();
System.out.println("ip为：" + ip + "m主机名为：" + name + "的人，发送了" + new String(data, 0, len));
ms.close();
}
}
广播代码：
client：
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;
/**
* 发送端 多发 多收
*/
public class ClientDemo1 {
public static void main(String[] args) throws Exception {
System.out.println("=====客户端启动======");
// 1、创建发送端对象：发送端自带默认的端口号（人）
DatagramSocket socket = new DatagramSocket();
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请说：");
String msg = sc.nextLine();
if ("exit".equals(msg)) {
System.out.println("离线成功！");
socket.close();
break;
}
// 2、创建一个数据包对象封装数据（韭菜盘子）
byte[] buffer = msg.getBytes();
// 注意：只要目的地IP是 255.255.255.255 这个消息将以广播的形式对外发送
DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName("255.255.255.255"), 8888);
// 3、发送数据出去
socket.send(packet);
}
}
}
server：
import java.net.DatagramPacket;
import java.net.DatagramSocket;
/**
接收端
*/
public class ServerDemo2 {
public static void main(String[] args) throws Exception {
System.out.println("=====服务端启动======");
// 1、创建接收端对象：注册端口（人）
DatagramSocket socket = new DatagramSocket(8888);
// 2、创建一个数据包对象接收数据（韭菜盘子）
byte[] buffer = new byte[1024 * 64];
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
while (true) {
// 3、等待接收数据。
socket.receive(packet);
// 4、取出数据即可
// 读取多少倒出多少
int len = packet.getLength();
String rs = new String(buffer,0, len);
System.out.println("收到了来自：" + packet.getAddress() +", 对方端口是" + packet.getPort() +"的消息：" + rs);
}
}
}三、TCP通信
简单发送
代码：
client：
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
/**
* 目标：完成Socket网络编程入门案例的客户端开发，实现1发1收。
*/
public class ClientDemo1 {
public static void main(String[] args) {
try {
System.out.println("====客户端启动===");
// 1、创建Socket通信管道请求有服务端的连接
// 参数一：服务端IP地址 参数二：服务端端口
Socket socket = new Socket("127.0.0.1", 7777);
// 2、从socket通信管道中得到一个字节输出流 负责发送数据
OutputStream os = socket.getOutputStream();
// 3、把低级的字节流包装成打印流
PrintStream ps = new PrintStream(os);
// 4、发送消息
ps.println("我是TCP的客户端，我已经与你对接，并发出邀请：约吗？");
ps.flush();
// 关闭资源。
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
server：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 目标：开发Socket网络编程入门代码的服务端，实现接收消息
*/
public class ServerDemo2 {
public static void main(String[] args) {
try {
System.out.println("===服务端启动成功===");
// 1、注册端口
ServerSocket serverSocket = new ServerSocket(7777);
// 2、必须调用accept方法：等待接收客户端的Socket连接请求，建立Socket通信管道
Socket socket = serverSocket.accept();
// 3、从socket通信管道中得到一个字节输入流
InputStream is = socket.getInputStream();
// 4、把字节输入流包装成缓冲字符输入流进行消息的接收
BufferedReader br = new BufferedReader(new InputStreamReader(is));
// 5、按照行读取消息
String msg;
if ((msg = br.readLine()) != null) {
System.out.println(socket.getRemoteSocketAddress() + "说了：: " + msg);
}
socket.close();
br.close();
is.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
多发多收
代码：
client：
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;
/**
* 目标：实现多发和多收
*/
public class ClientDemo1 {
public static void main(String[] args) {
try {
System.out.println("====客户端启动===");
// 1、创建Socket通信管道请求有服务端的连接
// 参数一：服务端IP地址 参数二：服务端端口
Socket socket = new Socket("127.0.0.1", 7777);
// 2、从socket通信管道中得到一个字节输出流 负责发送数据
OutputStream os = socket.getOutputStream();
// 3、把低级的字节流包装成打印流
PrintStream ps = new PrintStream(os);
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请说：");
String msg = sc.nextLine();
if ("886".equals(msg)) {
break;
}
// 4、发送消息
ps.println(msg);
ps.flush();
}
// 关闭资源。
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
server：
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 目标：开发Socket网络编程入门代码的服务端，实现接收消息
*/
public class ServerDemo2 {
public static void main(String[] args) {
try {
System.out.println("===服务端启动成功===");
// 1、注册端口
ServerSocket serverSocket = new ServerSocket(7777);
while (true) {
// 2、必须调用accept方法：等待接收客户端的Socket连接请求，建立Socket通信管道
Socket socket = serverSocket.accept();
// 3、从socket通信管道中得到一个字节输入流
InputStream is = socket.getInputStream();
// 4、把字节输入流包装成缓冲字符输入流进行消息的接收
BufferedReader br = new BufferedReader(new InputStreamReader(is));
// 5、按照行读取消息
String msg;
while ((msg = br.readLine()) != null) {
System.out.println(socket.getRemoteSocketAddress() + "说了：: " + msg);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
服务端同时接受多个客户端消息
代码1：
client：
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;
/**
* 目标：实现服务端可以同时处理多个客户端的消息。
*/
public class ClientDemo1 {
public static void main(String[] args) {
try {
System.out.println("====客户端启动===");
// 1、创建Socket通信管道请求有服务端的连接
// 参数一：服务端IP地址 参数二：服务端端口
Socket socket = new Socket("127.0.0.1", 7777);
// 2、从socket通信管道中得到一个字节输出流 负责发送数据
OutputStream os = socket.getOutputStream();
// 3、把低级的字节流包装成打印流
PrintStream ps = new PrintStream(os);
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请说：");
String msg = sc.nextLine();
// 4、发送消息
ps.println(msg);
ps.flush();
}
// 关闭资源。
// socket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}thread类：
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;
public class ServerReaderThread extends Thread {
private Socket socket;
public ServerReaderThread(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
// 3、从socket通信管道中得到一个字节输入流
InputStream is = socket.getInputStream();
// 4、把字节输入流包装成缓冲字符输入流进行消息的接收
BufferedReader br = new BufferedReader(new InputStreamReader(is));
// 5、按照行读取消息
String msg;
while ((msg = br.readLine()) != null) {
System.out.println(socket.getRemoteSocketAddress() + "说了：: " + msg);
}
} catch (Exception e) {
System.out.println(socket.getRemoteSocketAddress() + "下线了！！！");
}
}
}server：
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;
public class ServerReaderThread extends Thread {
private Socket socket;
public ServerReaderThread(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
// 3、从socket通信管道中得到一个字节输入流
InputStream is = socket.getInputStream();
// 4、把字节输入流包装成缓冲字符输入流进行消息的接收
BufferedReader br = new BufferedReader(new InputStreamReader(is));
// 5、按照行读取消息
String msg;
while ((msg = br.readLine()) != null) {
System.out.println(socket.getRemoteSocketAddress() + "说了：: " + msg);
}
} catch (Exception e) {
System.out.println(socket.getRemoteSocketAddress() + "下线了！！！");
}
}
}
代码2：
client：
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;
/**
拓展：使用线程池优化：实现通信。
*/
public class ClientDemo1 {
public static void main(String[] args) {
try {
System.out.println("====客户端启动===");
// 1、创建Socket通信管道请求有服务端的连接
// 参数一：服务端IP地址 参数二：服务端端口
Socket socket = new Socket("127.0.0.1", 6666);
// 2、从socket通信管道中得到一个字节输出流 负责发送数据
OutputStream os = socket.getOutputStream();
// 3、把低级的字节流包装成打印流
PrintStream ps = new PrintStream(os);
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请说：");
String msg = sc.nextLine();
// 4、发送消息
ps.println(msg);
ps.flush();
}
// 关闭资源。
// socket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Runnable类：
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;
public class ServerReaderRunnable implements Runnable{
private Socket socket;
public ServerReaderRunnable(Socket socket){
this.socket = socket;
}
@Override
public void run() {
try {
// 3、从socket通信管道中得到一个字节输入流
InputStream is = socket.getInputStream();
// 4、把字节输入流包装成缓冲字符输入流进行消息的接收
BufferedReader br = new BufferedReader(new InputStreamReader(is));
// 5、按照行读取消息
String msg;
while ((msg = br.readLine()) != null){
System.out.println(socket.getRemoteSocketAddress() + "说了：: " + msg);
}
} catch (Exception e) {
System.out.println(socket.getRemoteSocketAddress() + "下线了！！！");
}
}
}
server：
import com.itheima.d7_socket3.ServerReaderThread;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.*;
/**
* 目标：实现服务端可以同时处理多个客户端的消息。
*/
public class ServerDemo2 {
// 使用静态变量记住一个线程池对象
private static ExecutorService pool = new ThreadPoolExecutor(
300,
1500, 6, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(2)
, Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
public static void main(String[] args) {
try {
System.out.println("===服务端启动成功===");
// 1、注册端口
ServerSocket serverSocket = new ServerSocket(6666);
// a.定义一个死循环由主线程负责不断的接收客户端的Socket管道连接。
while (true) {
// 2、每接收到一个客户端的Socket管道，
Socket socket = serverSocket.accept();
System.out.println(socket.getRemoteSocketAddress() + "它来了，上线了！");
// 任务对象负责读取消息。
Runnable target = new ServerReaderRunnable(socket);
pool.execute(target);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}线程池优化
即时通信
模拟BS系统[了解]
1486
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
