1.网络编程入门
1.网络编程概述
计算机网络:指将地理位置不同的具有独立功能的多台计算机及其外部设备,通过通信线路连接起来,在网络操作系统,网络管理软件及网络通信协议的管理和协调下,实现资源共享和信息传递的计算机系统。
网络编程:在网络通信协议下,实现网络互连的不同计算机上运行的程序间可以进行数据交换
2.网络编程三要素
3.IP地址
网络中设备的唯一标识
常用命令:
ipconfig:查看本机IP地址
ping IP地址:检查网络是否连通
特殊IP地址:127.0.0.1 :回送地址,可以代表本机地址
4.InetAddress的使用
为了方便对IP地址的获取和操作,Java提供了一个类InetAddress,
InetAddress:此类表示Interner协议(IP)地址
方法名 | 说明 |
---|---|
static InetAddress getByName(String host) | 确定主机名称的IP地址。主机名称可以是机器名称,也可以是IP地址 |
String getHostName() | 获取此IP地址的主机名。 |
String getHostAddress() | 返回文本显示中的IP地址字符串。 |
import java.net.InetAddress;
import java.net.UnknownHostException;
public class InetAddressDemo {
public static void main(String[] args) throws UnknownHostException {
InetAddress address = InetAddress.getByName("192.168.1.13"); //可以是主机名也可以是IP地址
String name = address.getHostName();
String ip = address.getHostAddress();
System.out.println(name);
System.out.println(ip);
}
}
5.端口
设备上应用程序的唯一标识。
6.协议
计算机网咯中,连接和通信的规则被称为网络通信协议
2.UDP通信程序
1. UDP通信原理
UDP协议是一种不可靠的网络协议,它在通信的两端各建立了一个Socket对象,但是这两个Socket只是发送,接受数据的对象。因此对于基于UDP协议的通信双方而言,没有所谓的客户端和服务器的概念。
Java提供了DatagramSocket类作为基于UDP协议的Socket
2.UDP发送数据
步骤:
1.创建发送端的Socket对象(DatagramSocket)
2.创建数据,并把数据打包
3.调用DatagramSocket对象的方法发送数据
4.关闭发送端
import java.io.IOException;
import java.net.*;
public class SendDemo {
public static void main(String[] args) throws IOException {
//1.创建发送端的Socket对象(DatagramSocket)
DatagramSocket ds = new DatagramSocket();
//2.创建数据,并把数据打包
//DatagramPacket(byte[] buf, int length, InetAddress address, int port)
// 构造一个数据包,发送长度为 length的数据包到指定主机上的指定端口号。
byte[] bys = "hello,udp".getBytes();
int length = bys.length;
InetAddress address = InetAddress.getByName("192.168.1.13");
int port = 10086; // 0-65535 之间就可
DatagramPacket dp = new DatagramPacket(bys,length,address,port);
// DatagramPacket dp = new DatagramPacket(bys, bys.length,InetAddress.getByName("192.168.1.13"),10086);
//3.调用DatagramSocket对象的方法发送数据
//void send(DatagramPacket p) 从此套接字发送数据报包。
ds.send(dp);
//4.关闭发送端
ds.close();
}
}
3.UDP接收数据
步骤:
1.创建接收端的Socket对象(DatagramSocket)
2.创建一个数据包,用于接受数据
3.调用DatagramSocket对象的方法接收数据
4.解析数据包,并把数据在控制台显示
5.关闭发送端
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class ReceiveDemo {
public static void main(String[] args) throws IOException {
//1.创建接收端的Socket对象(DatagramSocket)
DatagramSocket ds = new DatagramSocket(10086);
//2.创建一个数据包,用于接受数据
//DatagramPacket(byte[] buf, int length) 构造一个 DatagramPacket用于接收长度为 length数据包。
byte[] bys = new byte[1024];
DatagramPacket dp = new DatagramPacket(bys, bys.length);
//3.调用DatagramSocket对象的方法接收数据
//void receive(DatagramPacket p) 从此套接字接收数据报包。
ds.receive(dp);
//4.解析数据包,并把数据在控制台显示
//byte[] getData() 返回数据缓冲区。
byte[] dates = dp.getData();
//int getLength() 返回要发送的数据的长度或接收到的数据的长度。
int len = dp.getLength();
String dateString = new String(dates,0,len);
System.out.println("数据是:" + dateString);
ds.close();
}
}
4.UDP通信程序练习
按照下面的要求实现程序:
UDP发送数据:数据来自于键盘录入,直到输入的数据是886,发送数据结束
UDP接收数据:因为接收端不知道发生端什么时候停止发送,故采用死循环
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class SendDemo {
public static void main(String[] args) throws IOException {
//创建发送端的Socket对象(DatagramSocket)
DatagramSocket ds = new DatagramSocket();
//自己封装键盘录入数据
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line;
while ((line = br.readLine()) != null) {
if ("886".equals(line)) {
break;
}
//创建数据,并把数据打包
byte[] bys = line.getBytes();
DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("127.0.0.1"), 12345);
//调用DatagramSocket对象的方法发送数据
ds.send(dp);
}
//关闭发送端
ds.close();
}
}
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class ReceiveDemo {
public static void main(String[] args) throws IOException {
DatagramSocket ds = new DatagramSocket(12345);
while (true){
//创建一个数据包,用于接收数据
byte[] bys = new byte[1204];
DatagramPacket dp = new DatagramPacket(bys, bys.length);
ds.receive(dp);
//解析数据包
System.out.println("数据是:"+new String(dp.getData(),0,dp.getLength()));
}
}
}
3.TCP通信程序
1.TCP通信原理
TCP通信协议是一种可靠的网络协议,它在通信的两端各建立一个Socket对象,从而在通信的两端形成网络虚拟链路,一旦建立了虚拟的网络链路,两端的程序就可以通过虚拟链路进行通信
Java对基于TCP协议的网络提供了良好的封装,使用Socket对象来代表两端的通信端口,并通过Socket产生IO流来进行网络通信
Java为客户端提供了Socket类,为服务器端提供了ServerSocket类
2.TCP发送数据
步骤:
1.创建客户端的Socket对象(Socket)
2.获取输出流,写数据
3.释放资源
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
public class ClientDemo {
public static void main(String[] args) throws IOException {
//1.创建客户端的Socket对象(Socket)
//Socket(InetAddress address, int port) 创建流套接字并将其连接到指定IP地址的指定端口号。
// Socket s = new Socket(InetAddress.getByName("127.0.0.1"),10000);
//Socket(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号。
Socket s = new Socket("192.168.1.13",10000);
//2.获取输出流,写数据
OutputStream os = s.getOutputStream();
os.write("hello,TCP".getBytes());
//3.释放资源
s.close();
}
}
3.TCP接收数据
步骤:
1.创建服务器端的Socket对象(ServerSocket)
2.获取输入流,读数据,并把数据显示在控制台
3.释放资源
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerDemo {
public static void main(String[] args) throws IOException {
//1.创建服务器端的Socket对象(ServerSocket)
//ServerSocket(int port) 创建绑定到指定端口的服务器套接字。
ServerSocket ss = new ServerSocket(1234);
//Socket accept() 侦听要连接到此套接字并接受它。
Socket s = ss.accept();
//2.获取输入流,读数据,并把数据显示在控制台
InputStream is = s.getInputStream();
byte[] bys = new byte[1024];
int len = is.read(bys);
String data = new String(bys, 0, len);
System.out.println("数据是:" + data);
//3.释放资源
ss.close();
s.close();
}
}
4.TCP通信程序练习
练习1:
客户端:发送数据,接收服务器反馈
服务器:接收数据,给出反馈
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/*
服务器:接收数据,给出反馈
*/
public class ServerDemo {
public static void main(String[] args) throws IOException {
ServerSocket ss = new ServerSocket(12366);
Socket s = ss.accept();
//获取输出流读数据
InputStream is = s.getInputStream();
byte[] bys = new byte[1024];
int len = is.read(bys);
String date = new String(bys, 0, len);
System.out.println("服务器:" + date);
//给出反馈
OutputStream os = s.getOutputStream();
os.write("数据已经收到".getBytes());
ss.close();
s.close();
}
}
/*
客户端:发送数据,接收服务器反馈
*/
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
public class ClientDemo {
public static void main(String[] args) throws IOException {
Socket s = new Socket("127.0.0.1", 12366);
OutputStream os = s.getOutputStream();
os.write("hello,tcp".getBytes());
//接收服务器反馈
InputStream is = s.getInputStream();
byte[] bys = new byte[1024];
int len = is.read(bys);
String date = new String(bys, 0, len);
System.out.println("客户端:" + date);
s.close();
}
}
练习2:
客户端:数据来自键盘录入,直到输入的数据是886,发送数据结束
服务器:接收到的数据在控制台输出
import java.io.*;
import java.net.Socket;
/*
客户端:数据来自键盘录入,知道输入的数据是886,发送数据结束
*/
public class ClientDemo {
public static void main(String[] args) throws IOException {
Socket s = new Socket("127.0.0.1",12345);
//数据来自键盘录入,知道输入的数据是886,发送数据结束
BufferedReader br =new BufferedReader(new InputStreamReader(System.in));
//封装输出流对象
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
String line;
while ((line=br.readLine())!=null){
if(line.equals("886")){
break;
}
//获取输出流对象
// OutputStream os = s.getOutputStream();
// os.write(line.getBytes());
bw.write(line);
bw.newLine();
bw.flush();
}
s.close();
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerDemo {
public static void main(String[] args) throws IOException {
ServerSocket ss = new ServerSocket(12345);
//监听客户端的连接,返回对应的Socket对象
Socket s = ss.accept();
//获取输入流
InputStream is = s.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
String line;
while ((line=br.readLine())!=null){
System.out.println(line);
}
ss.close();
}
}
练习3:
客户端:数据来自键盘录入,直到输入的数据是886,发送数据结束
服务器:接收到的数据写入文本文件
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/*
服务器:接收到的数据写入文本文件
*/
public class ServerDemo {
public static void main(String[] args) throws IOException {
ServerSocket ss = new ServerSocket(12354);
//监听
Socket s = ss.accept();
//接受数据
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
//把数据写入文本文件
BufferedWriter bw = new BufferedWriter(new FileWriter("myNet\\s.txt"));
String line;
while ((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
ss.close();
bw.close();
}
}
练习4:
客户端:数据来自文本文件
服务器:接收到的数据写入文本文件
import java.io.*;
import java.net.Socket;
/*
客户端:数据来自文本文件
*/
public class ClientDemo {
public static void main(String[] args) throws IOException {
Socket s = new Socket("127.0.0.1",12345);
//封装文本文件的数据
BufferedReader br = new BufferedReader(new FileReader("myNet\\src\\Test_08\\Demo.java"));
//封装输出流写数据
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
String line;
while ((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
s.close();
br.close();
}
}
练习5:
客户端:数据来自文本文件,接收服务器反馈
服务器:接收到的数据写入文本文件,给出反馈
出现问题:程序一直等待
原因:读数据的方法是阻塞式的
解决办法 :自定义结束标记;使用shutdownOutput()方法
import java.io.*;
import java.net.Socket;
public class ClientDemo {
public static void main(String[] args) throws IOException {
Socket s = new Socket("127.0.0.1", 12345);
//封装文本文件的数据
BufferedReader br = new BufferedReader(new FileReader("myNet\\src\\Test_09\\Demo.java"));
//封装输出流写数据
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
String line;
while ((line = br.readLine()) != null) { //等待结束
bw.write(line);
bw.newLine();
bw.flush();
}
//自定义结束语
// bw.write("886");
// bw.newLine();
// bw.flush();
//void shutdownOutput() 禁用此套接字的输出流。
s.shutdownOutput();
//接收反馈
BufferedReader brClient = new BufferedReader(new InputStreamReader(s.getInputStream()));
String date = brClient.readLine(); //等待读取数据
System.out.println("服务器的反馈" + date);
br.close();
s.close();
}
}
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerDemo {
public static void main(String[] args) throws IOException {
ServerSocket ss = new ServerSocket(12345);
Socket s = ss.accept();
//接受数据
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
//把数据写入文本文件
BufferedWriter bw = new BufferedWriter(new FileWriter("myNet\\src\\Test_09\\s.java"));
String line;
while ((line = br.readLine()) != null) {
// if("886".equals(line)){
// break;
// }
bw.write(line);
bw.newLine();
bw.flush();
}
//给出反馈
BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
bwServer.write("文件上传成功!");
bwServer.newLine();
bwServer.flush();
bw.close();
ss.close();
}
}
练习6:
客户端:数据来自文本文件,接收服务器反馈
服务器:接收到的数据写入文本文件,给出反馈,代码用线程进行封装,为每一个客户端开启一个线程
import java.io.*;
import java.net.Socket;
public class ServerThread implements Runnable {
private Socket s;
public ServerThread(Socket s) {
this.s = s;
}
@Override
public void run() {
//接收数据写到文本文件
try {
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
// BufferedWriter bw = new BufferedWriter(new FileWriter("myNet\\src\\Test_10\\s.java"));
//解决名称冲突问题
int count = 0;
File file = new File("myNet\\src\\Test_10\\s[" + count + "].java");
while (file.exists()) {
count++;
file = new File("myNet\\src\\Test_10\\s[" + count + "].java");
}
BufferedWriter bw = new BufferedWriter(new FileWriter(file));
String line;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
bw.flush();
}
//给出反馈
BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
bwServer.write("文件上传成功!");
bwServer.newLine();
bwServer.flush();
s.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerDemo {
public static void main(String[] args) throws IOException {
ServerSocket ss = new ServerSocket(12345);
while (true){
Socket s = ss.accept();
//为每一个客户端开启一个线程
new Thread(new ServerThread(s)).start();
}
// ss.close();
}
}