文章目录
- 网络TCP,UDP基础
- InetAddress,InetSocketAddress
- TCP
- 模拟网站的登录,客户端录入账号密码,然后服务器端进行验证。
- UDP
- 模拟:完成网站的咨询聊天
网络TCP,UDP基础
设备之间进行传输的时候,必须遵照一定的规则 —》通信协议:
TCP协议:可靠建立连接,三次握手:
释放连接:四次挥手
UDP:并不可靠
InetAddress,InetSocketAddress
- InetAddress: —>封装了IP
public class Test {
public static void main(String[] args) throws UnknownHostException {
//封装IP
//InetAddress address = new InetAddress();不能直接创建对象,因为InetAddress()被default修饰了。
InetAddress n = InetAddress.getByName("192.168.5.10");
System.out.println(n);
InetAddress n1 = InetAddress.getByName("localhost");
System.out.println(n1);
InetAddress n2 = InetAddress.getByName("DESKTOP------");
System.out.println(n2);
InetAddress n3 = InetAddress.getByName("www.baidu.com");
System.out.println(n3);
System.out.println(n2.getHostAddress());
System.out.println(n.getHostName());
}
}
- InetSocketAddress: —>封装了IP,端口号
public class Test1 {
public static void main(String[] args) {
InetSocketAddress i = new InetSocketAddress("192.168.2.102", 8080);
System.out.println(i);
System.out.println(i.getHostName());
System.out.println(i.getPort());
InetAddress address = i.getAddress();
System.out.println(address.getHostName());
System.out.println(address.getHostAddress());
}
}
TCP
模拟网站的登录,客户端录入账号密码,然后服务器端进行验证。
先开启客户端还是先开启服务器:先开服务器,再开启客户端
- 单向通信
public class TestClient {
public static void main(String[] args) throws IOException {
//1.创建套接字:指定服务器的ip和端口号:
Socket s = new Socket("127.0.0.1",8888);
//2.对于程序员来说,向外发送数据 感受 --》利用输出流:
OutputStream os = s.getOutputStream();
DataOutputStream dos = new DataOutputStream(os);
//利用这个OutputStream就可以向外发送数据了,但是没有直接发送String的方法
//所以我们又在OutputStream外面套了一个处理流:DataOutputStream
dos.writeUTF("Hello World!你好,世界!");
// 3.关闭流 + 关闭网络资源:
dis.close();
dos.close();
os.close();
s.close();
}
}
public class TestServer {
public static void main(String[] args) throws IOException {
//1.创建套接字: 指定服务器的端口号
ServerSocket ss = new ServerSocket(8888);
//2.等着客户端发来的信息:
Socket s = ss.accept();//阻塞方法:等待接收客户端的数据,什么时候接收到数据,什么时候程序继续向下执行。
//accept()返回值为一个Socket,这个Socket其实就是客户端的Socket
//接到这个Socket以后,客户端和服务器才真正产生了连接,才真正可以通信了
//3.感受到的操作流:
InputStream is = s.getInputStream();
DataInputStream dis = new DataInputStream(is);
//4.读取客户端发来的数据:
String str = dis.readUTF();
System.out.println("客户端发来的数据为:"+str);
//5.关闭流+关闭网络资源:
dos.close();
dis.close();
is.close();
s.close();
ss.close();
}
}
- 双向通信
public class TestClient {
public static void main(String[] args) throws IOException {
//1.创建套接字:指定服务器的ip和端口号:
Socket s = new Socket("127.0.0.1",8888);
//2.对于程序员来说,向外发送数据 感受 --》利用输出流:
OutputStream os = s.getOutputStream();
DataOutputStream dos = new DataOutputStream(os);
//利用这个OutputStream就可以向外发送数据了,但是没有直接发送String的方法
//所以我们又在OutputStream外面套了一个处理流:DataOutputStream
dos.writeUTF("Hello World!你好,世界!");
//接收服务端的会话-->输入流
InputStream is = s.getInputStream();
DataInputStream dis = new DataInputStream(is);
System.out.println(dis.readUTF());
// 3.关闭流 + 关闭网络资源:
dis.close();
dos.close();
os.close();
s.close();
}
}
public class TestServer {
public static void main(String[] args) throws IOException {
//1.创建套接字: 指定服务器的端口号
ServerSocket ss = new ServerSocket(8888);
//2.等着客户端发来的信息:
Socket s = ss.accept();//阻塞方法:等待接收客户端的数据,什么时候接收到数据,什么时候程序继续向下执行。
//accept()返回值为一个Socket,这个Socket其实就是客户端的Socket
//接到这个Socket以后,客户端和服务器才真正产生了连接,才真正可以通信了
//3.感受到的操作流:
InputStream is = s.getInputStream();
DataInputStream dis = new DataInputStream(is);
//4.读取客户端发来的数据:
String str = dis.readUTF();
System.out.println("客户端发来的数据为:"+str);
//向客户端输出一句话
OutputStream os = s.getOutputStream();
DataOutputStream dos = new DataOutputStream(os);
dos.writeUTF("收到!");
//5.关闭流+关闭网络资源:
dos.close();
dis.close();
is.close();
s.close();
ss.close();
}
}
- 对象流传送:完成登录功能
public class Users implements Serializable {
private static final long serialVersionUID = -7978385655236428680L;
private String name ;
private String pwd ;
public Users(String name, String pwd) {
this.name = name;
this.pwd = pwd;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
}
public class TestClient {
public static void main(String[] args) throws IOException {
//1.创建套接字:指定服务器的ip和端口号:
Socket s = new Socket("127.0.0.1",8888);
//录入用户的帐号和密码
Scanner sc = new Scanner(System.in);
System.out.print("请输入帐号:");
String name = sc.next();
System.out.print("请输入密码:");
String pwd = sc.next();
//将账号和密码封装成一个User对象
Users users = new Users(name, pwd);
//2.对于程序员来说,向外发送数据 感受 --》利用输出流:
OutputStream os = s.getOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(os);
oos.writeObject(users);
//接收服务端的会话-->输入流
InputStream is = s.getInputStream();
DataInputStream dis = new DataInputStream(is);
boolean b = dis.readBoolean();
if (b){
System.out.println("登录成功!");
}else {
System.out.println("登录失败!");
}
// 3.关闭流 + 关闭网络资源:
dis.close();
oos.close();
os.close();
s.close();
}
}
public class TestServer {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//1.创建套接字: 指定服务器的端口号
ServerSocket ss = new ServerSocket(8888);
//2.等着客户端发来的信息:
Socket s = ss.accept();//阻塞方法:等待接收客户端的数据,什么时候接收到数据,什么时候程序继续向下执行。
//accept()返回值为一个Socket,这个Socket其实就是客户端的Socket
//接到这个Socket以后,客户端和服务器才真正产生了连接,才真正可以通信了
//3.感受到的操作流:
InputStream is = s.getInputStream();
ObjectInputStream ois = new ObjectInputStream(is);
Users users = (Users)ois.readObject();
boolean flag = false;
if (users.getName().equals("lili")&& users.getPwd().equals("123")){
flag = true;
}
//向客户端输出一句话-->输出结果
OutputStream os = s.getOutputStream();
DataOutputStream dos = new DataOutputStream(os);
dos.writeBoolean(flag);
//5.关闭流+关闭网络资源:
dos.close();
ois.close();
is.close();
s.close();
ss.close();
}
}
- 为上述代码功能加入完整的处理异常方式
public class TestClient {
public static void main(String[] args) {
Socket s = null;
OutputStream os = null;
ObjectOutputStream oos = null;
DataInputStream dis = null;
//1.创建套接字:指定服务器的ip和端口号:
try {
s = new Socket("127.0.0.1",8888);
//录入用户的帐号和密码
Scanner sc = new Scanner(System.in);
System.out.print("请输入帐号:");
String name = sc.next();
System.out.print("请输入密码:");
String pwd = sc.next();
//将账号和密码封装成一个User对象
Users users = new Users(name, pwd);
//2.对于程序员来说,向外发送数据 感受 -->利用输出流:
os = s.getOutputStream();
oos = new ObjectOutputStream(os);
oos.writeObject(users);
//接收服务端的会话-->输入流
InputStream is = s.getInputStream();
dis = new DataInputStream(is);
boolean b = dis.readBoolean();
if (b){
System.out.println("登录成功!");
}else {
System.out.println("登录失败!");
}
} catch (IOException e) {
e.printStackTrace();
} finally {
// 3.关闭流 + 关闭网络资源:
try {
if (dis!=null)
dis.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if (oos!=null)
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if (os!=null)
os.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if (s!=null) {
s.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
```java
public class TestServer {
public static void main(String[] args){
//1.创建套接字: 指定服务器的端口号
ServerSocket ss = null;
Socket s = null;
InputStream is = null;
ObjectInputStream ois = null;
DataOutputStream dos = null;
try {
ss = new ServerSocket(8888);
//2.等着客户端发来的信息:
s = ss.accept();//阻塞方法:等待接收客户端的数据,什么时候接收到数据,什么时候程序继续向下执行。
is = s.getInputStream();
ois = new ObjectInputStream(is);
Users users = (Users)ois.readObject();
boolean flag = false;
if (users.getName().equals("lili")&& users.getPwd().equals("123")){
flag = true;
}
//向客户端输出一句话-->输出结果
OutputStream os = s.getOutputStream();
dos = new DataOutputStream(os);
dos.writeBoolean(flag);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally{
//5.关闭流+关闭网络资源:
try {
if (dos!=null){
dos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if (ois!=null)
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if (is!=null)
is.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if (s!=null)
s.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if (ss!=null)
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
- 多线程接收用户请求
可以看到上面代码经过一次客户端请求之后,服务器便就停止运行了,所以将代码改为多线程接收用户请求。即服务器针对一个请求服务,之后服务器就关闭了(程序自然结束了)
现在需要解决:服务器必须一直在监听 ,一直开着,等待客户端的请求
在当前代码中,客户端不用动了
修改之后的服务器端:
public class TestServer {
public static void main(String[] args){
System.out.println("服务器启动了");
//1.创建套接字: 指定服务器的端口号
Socket s = null;
ServerSocket ss = null;
int count = 0;
try {
ss = new ServerSocket(8888);
while (true){//加入死循环,服务器一直监听客户端是否发送数据
//阻塞方法:等待接收客户端的数据,什么时候接收到数据,什么时候程序继续向下执行。
s = ss.accept();
//每次过来的客户端的请求 靠 线程处理:
new ServerThread(s).start();
count++;
System.out.println("当前是第"+count+
"个用户访问我们的服务器,对应的用户是:"+
s.getInetAddress());
}
} catch (IOException e) {
e.printStackTrace();
} finally{
try {
if (ss!=null) {
ss.close();
}
}catch (IOException e) {
e.printStackTrace();
}
try {
if (s!=null) {
s.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
新增线程类来处理客户端需求
public class ServerThread extends Thread{//线程:专门处理客户端请求
ServerSocket ss = null;
Socket s = null;
InputStream is = null;
ObjectInputStream ois = null;
DataOutputStream dos = null;
public ServerThread(Socket s){
this.s = s ;
}
@Override
public void run() {
try {
//3.感受到的操作流:
is = s.getInputStream();
ois = new ObjectInputStream(is);
Users users = (Users)ois.readObject();
boolean flag = false;
if (users.getName().equals("lili")&& users.getPwd().equals("123")){
flag = true;
}
//向客户端输出一句话-->输出结果
OutputStream os = s.getOutputStream();
dos = new DataOutputStream(os);
dos.writeBoolean(flag);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
} finally {
//5.关闭流+关闭网络资源:
try {
if (dos!=null){
dos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if (ois!=null)
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if (is!=null)
is.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if (ss!=null)
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
UDP
模拟:完成网站的咨询聊天
注意先启动接收方,后启动发送方,不然发送方发的数据会丢失
- 单向通信:学生向老师发送信息
public class TestReceive {
public static void main(String[] args) throws IOException {
System.out.println("老师上线了。");
//1.创建套接字:指定接收方的端口
DatagramSocket ds = new DatagramSocket(9999);
//2.有一个空的数据包,打算用来接收对方传过来的数据包
byte[] b = new byte[1024];
DatagramPacket dp = new DatagramPacket(b,b.length);
//3.接受对方的数据包,然后放入我们的dp数据包中填充
ds.receive(dp);
//4.取出数据
byte[] data = dp.getData();
String s = new String(data,0,dp.getLength());//dp.getLength()数组包中的有效长度
System.out.println("学生对我说:"+s);
//5. 关闭
ds.close();
}
}
public class TestSend {
public static void main(String[] args) throws IOException {
System.out.println("学生上线。");
//1.准备套接字,指定发送方的端口
DatagramSocket ds = new DatagramSocket(8888);
//2.准备数据包
String str = "Hello World!你好,世界!";
byte[] bytes = str.getBytes();
/*
需要四个参数:
1.指的是传送数据转为字节数组
2.字节数组的长度
3.封装接收方的IP
4.指定接收方的端口号
*/
DatagramPacket dp = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),9999);
ds.send(dp);
//关闭资源
ds.close();
}
}
- 双向通信:老师给学生发,学生给老师发
public class TestSend {//发送方:
//这是一个main方法,是程序的入口:
public static void main(String[] args){
System.out.println("学生上线。。。");
//1.准备套接字: 指定发送方的端口号
try (DatagramSocket ds = new DatagramSocket(8888)) {
//2.准备数据包
Scanner sc = new Scanner(System.in);
System.out.print("学生:");
String str = sc.next();
byte[] bytes = str.getBytes();
/*
需要四个参数:
1.指的是传送数据转为Z字节数组
2.字节数组的长度
3.封装接收方的ip
4.指定接收方的端口号
*/
DatagramPacket dp = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("localhost"), 9999);
//发送:
ds.send(dp);
//接收老师发送回来的信息:
byte[] b = new byte[1024];
DatagramPacket dp2 = new DatagramPacket(b, b.length);
ds.receive(dp2);//接收完以后 dp2里面就填充好内容了
//取出数据:
byte[] data = dp2.getData();
String s = new String(data, 0, dp2.getLength());//dp.getLength()数组包中的有效长度
System.out.println("老师对我说:" + s);
} catch (IOException e) {
e.printStackTrace();
}
//关闭资源
}
}
public class TestReceive {//接收方
//这是一个main方法,是程序的入口:
public static void main(String[] args){
System.out.println("老师上线了。。");
//1.创建套接字:指定接收方的端口
try (DatagramSocket ds = new DatagramSocket(9999)) {
//2.有一个空的数据包,打算用来接收 对方传过来的数据包:
byte[] b = new byte[1024];
DatagramPacket dp = new DatagramPacket(b, b.length);
//3.接收对方的数据包,然后放入我们的dp数据包中填充
ds.receive(dp);//接收完以后 dp里面就填充好内容了
//4.取出数据:
byte[] data = dp.getData();
String s = new String(data, 0, dp.getLength());//dp.getLength()数组包中的有效长度
System.out.println("学生对我说:" + s);
//老师进行回复:
Scanner sc = new Scanner(System.in);
System.out.print("老师:");
String str = sc.next();
byte[] bytes = str.getBytes();
//封装数据,并且指定学生的ip和端口号
DatagramPacket dp2 = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("localhost"), 8888);
//发送:
ds.send(dp2);
} catch (IOException e) {
e.printStackTrace();
}
//5.关闭资源:
}
}
- 完整通信
public class TestSend {//发送方:
//这是一个main方法,是程序的入口:
public static void main(String[] args){
System.out.println("学生上线。。。");
//1.准备套接字: 指定发送方的端口号
try (DatagramSocket ds = new DatagramSocket(8888)) {
while (true) {
//2.准备数据包
Scanner sc = new Scanner(System.in);
System.out.print("学生:");
String str = sc.next();
byte[] bytes = str.getBytes();
/*
需要四个参数:
1.指的是传送数据转为Z字节数组
2.字节数组的长度
3.封装接收方的ip
4.指定接收方的端口号
*/
DatagramPacket dp = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("localhost"), 9999);
//发送:
ds.send(dp);
if ("byebye".equals(str)){
System.out.println("学生下线了。");
break;
}
//接收老师发送回来的信息:
byte[] b = new byte[1024];
DatagramPacket dp2 = new DatagramPacket(b, b.length);
ds.receive(dp2);//接收完以后 dp2里面就填充好内容了
//取出数据:
byte[] data = dp2.getData();
String s = new String(data, 0, dp2.getLength());//dp.getLength()数组包中的有效长度
System.out.println("老师对我说:" + s);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
public class TestReceive {//接收方
//这是一个main方法,是程序的入口:
public static void main(String[] args){
System.out.println("老师上线了。。");
//1.创建套接字:指定接收方的端口
try (DatagramSocket ds = new DatagramSocket(9999)) {
while (true){
//2.有一个空的数据包,打算用来接收 对方传过来的数据包:
byte[] b = new byte[1024];
DatagramPacket dp = new DatagramPacket(b, b.length);
//3.接收对方的数据包,然后放入我们的dp数据包中填充
ds.receive(dp);//接收完以后 dp里面就填充好内容了
//4.取出数据:
byte[] data = dp.getData();
String s = new String(data, 0, dp.getLength());//dp.getLength()数组包中的有效长度
System.out.println("学生对我说:" + s);
if ("byebye".equals(s)){
System.out.println("学生下线了,老师也下了");
break;
}
//老师进行回复:
Scanner sc = new Scanner(System.in);
System.out.print("老师:");
String str = sc.next();
byte[] bytes = str.getBytes();
//封装数据,并且指定学生的ip和端口号
DatagramPacket dp2 = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("localhost"), 8888);
//发送:
ds.send(dp2);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}