网络编程
概述
计算机网络就是利用通信设备和线路将地理位置不同的、功能独立的多个计算机系统互连起来，以功能完善的网络软件实现网络中资源共享和信息传递的系统。一个计算机网络是由资源子网和通信子网构成的，资源子网负责信息处理，通信子网负责全网中的信息传递。
网络编程的目的
通过使用套接字来达到进程间通信目的的编程就是网络编程。
javaweb: 网页编程 B/S
网络编程： TCP/IP C/S(客户端)
网络通信的要素
通信双方地址：ip+端口号
规则：网络通信的协议（http，udp，tcp…）
TCP/IP参考模型
ip
ip地址：InetAddress类
- 定位唯一一台计算器
- ip地址的分类
按照地分类
ipv4：127.0.0.1 4个字节组成，每个字节在0~255之间
ipv6：8个无符号数组成
公网（互联网）-私网（局域网）
ABCD类地址
import java.net.InetAddress;
import java.net.UnknownHostException;
public class TestIp {
public static void main(String[] args) {
try {
InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
InetAddress inetAddress2 = InetAddress.getByName("localhost");
InetAddress inetAddress3 = InetAddress.getLocalHost();
System.out.println(inetAddress1);
System.out.println(inetAddress2);
System.out.println(inetAddress3);
InetAddress inetAddress4 = InetAddress.getByName("www.baidu.com");
System.out.println(inetAddress4.getAddress());
System.out.println(inetAddress4.getCanonicalHostName()); //规范的
System.out.println(inetAddress4.getHostAddress());
System.out.println(inetAddress4.getHostName());
} catch (UnknownHostException e) {
e.printStackTrace();
}
}
}
运行结果
端口号
netstat -ano // 查看所有的端口
netstat -ano | findstr "5900" // 查看指定的端口
tasklist | findstr "5900" // 查看指定端口的进程
import java.net.InetSocketAddress;
public class TestPort {
public static void main(String[] args) {
InetSocketAddress inetSocketAddress1 = new InetSocketAddress("127.0.0.1", 8080);
InetSocketAddress inetSocketAddress2 = new InetSocketAddress("localhost", 8080);
System.out.println(inetSocketAddress1);
System.out.println(inetSocketAddress2);
System.out.println(inetSocketAddress2.getAddress());
System.out.println(inetSocketAddress2.getHostName());
System.out.println(inetSocketAddress2.getPort());
}
}
运行结果
通信协议（约定）
TCP协议：用户传输协议
UDP协议：用户数据报协议
IP协议：网络互连协议
TCP UDP对比
TCP（打电话）
连接，稳定
三次握手，四次挥手
三次握手过程分析
第一次：客户端发送请求到服务器，服务器知道客户端发送，自己接收正常。（但是客户端不知道自己发送正 常，所以需要第二次握手）
第二次：服务器发给客户端，客户端知道自己发送、接收正常，服务器接收、发送正常。（第二次握手，服务端回应了客户端，这时候客户端知道自己发送和接收都正常了，也知道服务端发送和接收都正常了，但是服务端不知道自己发送正常，所以需要第三次握手）
第三次：客户端发给服务器：服务器知道客户端发送，接收正常，自己接收，发送也正常.（第三次握手客户端回应服务端，告诉服务端它的发送也正常，此时客户端与服务端都知道自己发送和接收都没问题，才正式连接成功）
四次挥手过程分析
第一次：客户端请求断开FIN （客户端像服务端发出断开申请）
第二次：服务器确认客户端的断开请求 （服务端同意了客户端的申请）
第三次：服务器请求断开FIN （服务端也要像客户端申请自己也要断开了）
第四次：客户端确认服务器的断开 （客户端同意了服务端的申请）
客户端、服务端
传输完成释放连接，效率低
UDP（发短信、导弹攻击、DDOS洪水攻击）
不连接，不稳定
客户端，服务端：没有明确的界限
不管有没有准备好，都可以传输（强制性传输，至于对方能不能就收到就不关发送方的事情了）
TCP
客户端
连接服务器
发送消息
服务端
建立服务的端口
等待客户端的连接
接收消息
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
// 客户端
public class TcpClientDemo01 {
public static void main(String[] args) {
Socket socket = null;
OutputStream outputStream = null;
try {
// 1.需要知道服务端的地址，端口号
InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
int port = 9999;
// 2.创建一个socket连接，为了和服务端连上
socket = new Socket(inetAddress, port);
// 3.给服务器端发消息 通过IO流
outputStream = socket.getOutputStream();
outputStream.write("服务器你好啊".getBytes());
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != outputStream) {
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (null != socket) {
try {
// 关闭socket连接
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
// 服务端
public class TcpServerDemo01 {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket socket = null;
InputStream inputStream = null;
ByteArrayOutputStream baos = null;
try {
// 1.自己得有一个地址
serverSocket = new ServerSocket(9999);
while (true) {
// 2.等待客户端连接过来,接受客户端的连接
socket = serverSocket.accept();
// 3.读取客户端的信息
inputStream = socket.getInputStream();
// 管道流的方式
baos = new ByteArrayOutputStream();
byte[] bytes = new byte[1024];
int len;
while ((len = inputStream.read(bytes)) != -1) {
baos.write(bytes, 0, len);
}
System.out.println(baos.toString());
}
/*
byte[] bytes = new byte[1024];
int len;
while ((len = inputStream.read(bytes)) != -1) {
String msg = new String(bytes, 0, len);
System.out.println(msg);
}
*/
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != baos) {
try {
baos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (null != inputStream) {
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (null != socket) {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (null != serverSocket) {
try {
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
运行结果
上传文件的案例代码
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
// 客户端
// 上传文件
public class TcpClientDemo02 {
public static void main(String[] args) throws Exception {
// 创建连接
Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);
// 创建一个输出流
OutputStream outputStream = socket.getOutputStream();
// 获取文件
FileInputStream fileInputStream = new FileInputStream(new File("1.jpg"));
byte[] bytes = new byte[1024];
int len;
// 输出文件
while ((len = fileInputStream.read(bytes)) != -1) {
// len = 1024
outputStream.write(bytes, 0, len);
}
// 通知服务器我已经传输完了
socket.shutdownOutput();
// 确定服务器接收完毕，才可以断开连接
InputStream inputStream = socket.getInputStream();
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
byte[] bytes1 = new byte[1024];
int len2;
while ((len2 = inputStream.read(bytes1)) != -1) {
byteArrayOutputStream.write(bytes1, 0, len2);
}
System.out.println(byteArrayOutputStream.toString());
// 关闭资源
byteArrayOutputStream.close();
inputStream.close();
fileInputStream.close();
outputStream.close();
socket.close();
}
}
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
// 服务端
public class TcpServerDemo02 {
public static void main(String[] args) throws IOException {
// 创建服务器端口号
ServerSocket serverSocket = new ServerSocket(9000);
// 等待客户端的连接，阻塞式监听
Socket socket = serverSocket.accept();
// 获取信息
InputStream inputStream = socket.getInputStream();
// 文件输出
FileOutputStream fileOutputStream = new FileOutputStream(new File("copy1.jpg"));
int len;
byte[] bytes = new byte[1024];
while ((len = inputStream.read(bytes)) != -1) {
// len = 1024
fileOutputStream.write(bytes, 0, len);
}
// 通知客户端我已经接收完了，可以断开连接了
OutputStream outputStream = socket.getOutputStream();
outputStream.write("我已经接收完毕，可以断开连接了".getBytes());
// 关闭资源
fileOutputStream.close();
inputStream.close();
socket.close();
serverSocket.close();
}
}
运行结果
Tomcat
端口号的修改（conf目录下面的server.xml文件）
修改用户名密码（conf目录下的tomcat-users.xml文件）
修改tomcat启动时日志的乱码问题（conf目录下的logging.properties文件，改为GBK）
Udp
代码案例
import java.io.IOException;
import java.net.*;
// 没有明确界限说明谁是客户端，谁是服务端
public class UdpClientDemo01 {
public static void main(String[] args) throws IOException {
// 建立一个socket
DatagramSocket socket = new DatagramSocket();
// 创建包
// 信息
String msg = "你好啊，服务器!";
// 数据信息，数据的起始长度，发给谁
DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, InetAddress.getByName("127.0.0.1"), 9090);
// 发送包
socket.send(packet);
// 关闭资源
socket.close();
}
}
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class UdpServerDemo01 {
public static void main(String[] args) throws IOException {
// 创建连接
DatagramSocket socket = new DatagramSocket(9090);
byte[] bytes = new byte[1024];
// 接收包
DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length);
socket.receive(packet); // 阻塞式接收
System.out.println(packet.getAddress().getHostAddress());
System.out.println(new String(packet.getData(), 0, packet.getData().length));
// 关闭资源
socket.close();
}
}
运行结果
模拟聊天准备工作代码
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
public class UdpClientDemo02 {
public static void main(String[] args) throws Exception {
// 创建一个socket
DatagramSocket socket = new DatagramSocket(8888);
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
while (true) {
String readLine = reader.readLine();
byte[] bytes = readLine.getBytes();
// 创建包
DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length, InetAddress.getByName("localhost"), 6666);
// 发送包
socket.send(packet);
if ("bye".equals(readLine)) {
break;
}
}
// 关闭资源
reader.close();
socket.close();
}
}
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class UdpServerDemo02 {
public static void main(String[] args) throws Exception {
// 创建一个socket
DatagramSocket socket = new DatagramSocket(6666);
while (true) {
byte[] bytes = new byte[1024];
// 接收包
DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length);
socket.receive(packet);
String receiveData = new String(packet.getData(), 0, packet.getData().length);
System.out.println(receiveData);
if ("bye".equals(receiveData)) {
break;
}
}
// 关闭资源
socket.close();
}
}
开启多线程实现聊天效果
发送消息类
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
public class TalkSend implements Runnable {
DatagramSocket socket = null;
BufferedReader reader = null;
int fromPort; // 从哪个端口发的
String toIP; // 发送到哪个地址
int toPort; // 发送到哪个端口号
public TalkSend(int fromPort, String toIP, int toPort) {
this.fromPort = fromPort;
this.toIP = toIP;
this.toPort = toPort;
try {
socket = new DatagramSocket(fromPort);
reader = new BufferedReader(new InputStreamReader(System.in));
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void run() {
try {
while (true) {
String readLine = reader.readLine();
byte[] bytes = readLine.getBytes();
// 创建包
DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length, InetAddress.getByName(toIP), toPort);
// 发送包
socket.send(packet);
if ("bye".equals(readLine)) {
break;
}
}
} catch (Exception e) {
e.printStackTrace();
}
// 关闭资源
socket.close();
}
}
接收消息类
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class TalkReceive implements Runnable {
DatagramSocket socket = null;
int fromPort; // 等待发来消息的端口
String msgFrom; // 来自谁发的消息
public TalkReceive(int fromPort, String msgFrom) {
this.fromPort = fromPort;
this.msgFrom = msgFrom;
try {
socket = new DatagramSocket(fromPort);
} catch (SocketException e) {
e.printStackTrace();
}
}
@Override
public void run() {
try {
while (true) {
byte[] bytes = new byte[1024];
// 接收包
DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length);
socket.receive(packet);
String receiveData = new String(packet.getData(), 0, packet.getData().length);
System.out.println(msgFrom + ": " +receiveData);
if ("bye".equals(receiveData)) {
break;
}
}
} catch (Exception e) {
e.printStackTrace();
}
// 关闭资源
socket.close();
}
}
学生类
public class TalkStudent {
public static void main(String[] args) {
new Thread(new TalkSend(1111, "localhost", 1234)).start();
new Thread(new TalkReceive(2234, "老师")).start();
}
}
老师类
public class TalkTeacher {
public static void main(String[] args) {
new Thread(new TalkSend(2222, "localhost", 2234)).start();
new Thread(new TalkReceive(1234, "学生")).start();
}
}
运行效果
URL
统一资源定位符
小试牛刀
import java.net.MalformedURLException;
import java.net.URL;
public class URLDemo01 {
public static void main(String[] args) throws MalformedURLException {
URL url = new URL("http://localhost:8080/helloworld/index.jsp?username=cjl&password=123");
System.out.println(url.getProtocol()); // 协议
System.out.println(url.getPort()); // 端口
System.out.println(url.getHost()); // 主机ip
System.out.println(url.getPath()); // 文件
System.out.println(url.getFile()); // 全路径
System.out.println(url.getQuery()); // 参数
}
}
运行结果
url下载网络资源
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
public class URLDown {
public static void main(String[] args) throws Exception {
// 地址
URL url = new URL("http://localhost:8080/cjl/file.txt");
// 开启连接
HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
// 获取资源
InputStream inputStream = urlConnection.getInputStream();
// 建立输出流
FileOutputStream fileOutputStream = new FileOutputStream(new File("file.txt"));
byte[] bytes = new byte[1024];
int len;
while ((len = inputStream.read(bytes)) != -1) {
fileOutputStream.write(bytes, 0, len);
}
// 关闭资源
fileOutputStream.close();
inputStream.close();
urlConnection.disconnect();
}
}
扫一扫
1055
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
