DAY11
1.软件结构概述
- ip 4 32为 分四组 8字
- ip6 128 分八组 16字
- 端口65535
- 协议
package com.itheima._01软件结构概述;
/**
目标:能够说出常见的软件结构及其优缺点
讲解:
1. 常见的软件结构
小结:
1. 常见的软件结构有:
CS:客户端服务器结构
优点:用户体验好,可以将一些运算交给客户端完成,减轻服务器端压力。
缺点:开发成本高,维护成本高,开发周期长
BS:浏览器服务器结构
优点:只需要开发一个端,开发成本低,维护成本低,开发周期短。
缺点:所有的运算都必须在服务器端完成,服务器压力大。用户体验差。
*/
public class Demo01 {
}
package com.itheima._01软件结构概述;
import java.io.File;
public class Demo {
public static void main(String[] args) {
File dir = new File("/Users/pkxing/Documents/119期就业班/课堂视频/day11");
// 02-软件结构概述-[理解]-compress-20190813095735.mp4
File[] files = dir.listFiles();
for (File file : files) {
String name = file.getName();
if (name.contains("-compress")){
int index = name.lastIndexOf(".");
String ext = name.substring(index);
String[] strs = name.split("-compress");
File newName = new File(dir, strs[0] + ext);
file.renameTo(newName);
}
}
}
}
2.网络编程三要素
package com.itheima._02网络编程三要素;
/**
目标:能够说出网络编程三要素的作用
小结:
网络编程三要素是什么:
IP地址:网络设备的唯一标识
端口号:进程的唯一标识
通讯协议:确定数据的传输格式
小结:通过IP找主机,通过端口找程序,通过协议确定如何传输数据。
*/
public class Demo02 {
}
3.UDP协议概述
-
特点:UDP==》
- User DatagramPacket Protocol 用户数据包协议
- 面向无连接的协议
- 只管发送,不确认对方是否能收到
- 基本数据包进行数据传输:将数据,源以及目的地封装到数据包中
- 数据包大小限制在64k以内
- 因为面向无连接,速度快但不可靠(不安全)
-
UDP协议的应用场景
- 即时通讯(QQ,陌陌…)
- 在线网络视频
- 网络电话
-
UDP协议相关的类
- DatagramPacket:数据包对象:将数据,源以及目的地封装到数据包中 可以理解为:集装箱
- DatagramSocket:发送或接收对象 码头
-
package com.itheima._03UDP协议概述; /** 目标:理解UDP协议的特点(记忆) 面试题 讲解: 1. UDP协议的特点 UDP ==> User DatagramPacket Protocol 用户数据包协议 面向无连接协议 只管发送,不确认对方是否能收到 基于数据包进行数据传输:将数据,源以及目的地封装到数据包中 数据包大小限制在64k以内 因为面向无连接,速度快但不可靠(不安全) 2. UDP协议的应用场景 即时通讯(QQ,内网通,微信,陌陌...) 在线网络视频 网络电话 3. UDP协议相关的类 DatagramPacket:数据包对象:将数据,源以及目的地封装到数据包中 可以理解为:集装箱 DatagramSocket:发送或接收对象 可以理解为:码头 小结: 1. UDP协议的特点:无连接协议,只管发送,不确认对方是否收到 基于数据包传输,大小限制在64k,速度快但不可靠 */ public class Demo03 { }
4.UDP协议通信
package com.itheima._04UDP协议通信;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/**
需求:使用UDP协议实现发送端和接收端程序:发送端发送数据,接收端接收数据。
目标:使用UDP协议实现发送端程序(了解)
讲解:
1. UDP发送端实现步骤
1. 创建数据包对象:用来封装要发送的数据
2. 创建发送对象:用来发送数据包
3. 调用发送对象的方法发送数据包
4. 关闭发送对象释放资源
网络编程就是Socket编程,Socket编程就是网络编程。
Socket:套接字,插座
2. DatagramPacket类常用构造方法
* DatagramPacket(byte[] buf, int length, InetAddress address, int port)
* 创建发送端数据包对象
* buf:字节数组:要发送的实际内容
* length:发送内容的长度,单位字节
* address: 接收端的IP地址
* port: 接收端的端口号
* DatagramPacket(byte[] buf, int length)
* 创建接收端的数据包对象
* buf:字节数组,用来存储接收到的数据
* length:可以接收内容的长度,单位字节
3. DatagramSocket类常用构造方法
* DatagramSocket()
* 创建发送端的Socket对象:相当于开启了一个进程,随机分配一个端口号。
* DatagramSocket(int port)
* 创建接收端的Socket对象并指定端口号。
4. DatagramSocket类常用方法
* void send(DatagramPacket dp) 发送数据包
* void receive(DatagramPacket dp) 接收数据包
5. InetAddress类静态方法
* InetAddress对象代表一个IP地址
* static InetAddress getByName(String host)
* 根据ip地址字符串或主机名或域名获得IP地址对象
* static InetAddress getLocalHost() 获得本机IP地址对象
小结:
1. UDP发送端实现步骤
1. 创建数据包对象:用来封装要发送的数据
2. 创建发送对象:用来发送数据包
3. 调用发送对象的方法发送数据包
4. 关闭发送对象释放资源
*/
public class Demo041 {
public static void main(String[] args) throws Exception{
// 0. 要发送的数据
byte[] msg = "你好,UDP接收端,约吗".getBytes();
// 1. 创建数据包对象:用来封装要发送的数据
DatagramPacket dp = new DatagramPacket(msg, msg.length, InetAddress.getLocalHost(), 6666);
// 2. 创建发送对象:用来发送数据包
// 相当于开启了一个进程,随机分配一个端口号。
DatagramSocket ds = new DatagramSocket();
// 3. 调用发送对象的方法发送数据包
ds.send(dp);
// 4. 关闭发送对象释放资源
ds.close();
}
}
package com.itheima._04UDP协议通信;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
/**
目标:使用UDP协议实现接收端程(了解)
讲解:
1. UDP接收端实现步骤
1. 创建数据包对象:用来封装接收到的数据
2. 创建接收对象
3. 调用接收对象的方法接收数据包
4. 关闭资源
小结:
1. UDP接收端实现步骤
1. 创建数据包对象:用来封装接收到的数据
2. 创建接收对象
3. 调用接收对象的方法接收数据包
4. 关闭资源
*/
public class Demo042 {
public static void main(String[] args)throws Exception {
// 0. 创建字节数组:存储接收到数据
byte[] buf = new byte[1024];
// 1. 创建数据包对象:用来封装接收到的数据
DatagramPacket dp = new DatagramPacket(buf, buf.length);
// 2. 创建接收对象
DatagramSocket ds = new DatagramSocket(6666);
System.out.println("接收端......");
// 3. 调用接收对象的方法接收数据包
// 阻塞方法
ds.receive(dp);
// 获得实际接收到的字节个数
int len = dp.getLength();
System.out.println("接收到了"+len+"个字节");
// 将字节数组转换为字符串输出
System.out.println("接收到内容:" + new String(buf,0,len));
// 获得发送端的IP地址字符串
// 127.0.0.1 本机ip地址
String sendIP = dp.getAddress().getHostAddress();
System.out.println("sendIP = " + sendIP);
// 4. 关闭资源
ds.close();
}
}
5.TCP协议的概述
-
特点
- 面向连接的协议
- 通过三次握手建立:形成数据传输通道
- 通过四次挥手断开连接
- 基于IO流进行数据传输
- 传输数据大小没有限制
- 因为面向连接,速度慢但可靠
-
应用场景
- 上传和下载文件
- 发送和接收邮件
- 远程登录:用户名和密码
-
TCP协议相关的类
-
Socket:客户端Socket对象:一个Socket对象就代表一个客户端程序
-
ServerSocket:服务器端Socket对象:一个ServerSocket对象就代表一个服务器端程序
-
package com.itheima._05TCP协议概述; /** 目标:理解TCP协议的特点(记忆) 面试题 讲解: 1. TCP协议的特点 面向连接的协议 通过三次握手建立:形成数据传输通道 通过四次挥手断开连接 基于IO流进行数据传输 传输数据大小没有限制 因为面向连接,速度慢但可靠 2. TCP协议的应用场景 上传和下载文件 发送和接收邮件 远程登录:用户名和密码 3. TCP协议相关的类 Socket:客户端Socket对象:一个Socket对象就代表一个客户端程序 ServerSocket:服务器端Socket对象:一个ServerSocket对象就代表一个服务器端程序 小结: 1. TCP协议的特点 面向连接 通过三次握手建立连接 通过四次挥手断开连接 基于IO流进行数据传输 传输数据大小无限制 速度慢,但可靠 */ public class Demo05 { }
-
-
6.TCP协议的通信
package com.itheima._06TCP协议通信;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
/**
需求:使用TCP协议实现客端户和服务器端之间的数据传输。
目标:使用TCP协议实现客户端程序
讲解:
1. TCP客户端代码实现步骤
1. 创建客户端Socket对象:Socket
2. 调用Socket对象的方法获得字节输出流:OutputStream
3. 调用字节输出流的write方法输出数据到服务器端
4. 调用Socket对象的方法获得字节输入流:InputStream
5. 调用字节输入流的read方法读取服务器返回的数据
6. 关闭Socket断开连接释放资源
2. Socket类构造方法
* Socket(String host, int port)
* 根据IP地址和端口号创建客户端Socket
* host:服务器端的IP地址
* port:服务器端的端口号
3. Socket类常用方法
* OutputStream getOutputStream(); 获得字节输出流
* InputStream getInputStream(); 获得字节输入流
*/
public class Demo061 {
public static void main(String[] args) throws Exception{
// 1. 创建客户端Socket对象:Socket
Socket socket = new Socket("127.0.0.1", 9999);
// 2. 调用Socket对象的方法获得字节输出流:OutputStream
OutputStream out = socket.getOutputStream();
// 3. 调用字节输出流的write方法输出数据到服务器端
out.write("约吗".getBytes());
// 4. 调用Socket对象的方法获得字节输入流:InputStream
InputStream in = socket.getInputStream();
// 5. 调用字节输入流的read方法读取服务器返回的数据
// 创建字节数组:用来存储服务器返回的数据
byte[] buf = new byte[1024];
// 读取服务器返回数据
int len = in.read(buf);
System.out.println("len = " + len);
System.out.println("服务器返回的数据:" + new String(buf,0,len));
// 6. 关闭Socket断开连接释放资源
socket.close();
}
}
package com.itheima._06TCP协议通信;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
目标:使用TCP协议实现服务器端程序
讲解:
1. TCP服务器端代码实现步骤
1. 创建ServerSocket对象并指定端口号:开启了服务器端
2. 调用ServerSocket对象accept方法:等待客户端连接并获得Socket对象
3. 调用Socket对象getInputStream方法获得字节输入流
4. 调用字节输入流对象的read方法读取客户端发送的数据
5. 调用Socket对象的getOutputStream方法获得字节输出流
6. 调用字节输出流的write方法返回数据给客户端
7. 关闭服务器(实际开发不会关闭)
2. ServerSocket类构造方法
* ServerSocket(int port) 开启服务器并指定端口号
3. ServerSocket类常用方法
* Socket accept() 等待客户端连接并获得与客户端关联的socket对象
*/
public class Demo062 {
public static void main(String[] args)throws Exception {
// 1. 创建ServerSocket对象并指定端口号:开启了服务器端
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("开启了服务器...");
// 2. 调用ServerSocket对象accept方法:等待客户端连接并获得Socket对象
Socket socket = serverSocket.accept();
// 3. 调用Socket对象getInputStream方法获得字节输入流
InputStream in = socket.getInputStream();
// 4. 调用字节输入流对象的read方法读取客户端发送的数据
// 4.1 创建字节数组:用来存储客户端发送的数据
byte[] buf = new byte[1024];
// 4.2 读取客户端发送的数据
int len = in.read(buf);
System.out.println("len = " + len);
System.out.println("客户端发送的数据:" + new String(buf,0,len));
// 5. 调用Socket对象的getOutputStream方法获得字节输出流
OutputStream out = socket.getOutputStream();
// 6. 调用字节输出流的write方法返回数据给客户端
out.write("不约儿童".getBytes());
// 7. 关闭服务器(实际开发不会关闭)
serverSocket.close();
}
}
7.TCP文件上传案例
单用户上传
package com.itheima._07TCP文件上传案例.单用户上传;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
/**
目标:实现上传文件客户端程序
实现步骤:
1. 创建客户端Socket对象指定服务器地址和端口号
2. 创建字节输入流关联源文件:要上传的文件
3. 调用Socket对象getOutputStream方法获得字节输出流
4. 循环读取图片数据
5. 将读取到的图片数据输出到服务器端
6. 调用Socket对象的getInputStream方法获得字节输入流
7. 调用字节输入流的read方法读取服务器返回的上传状态信息字符串
8. 关闭字节输入流和Socket对象
*/
public class UploadFileClient {
public static void main(String[] args) throws Exception{
// 1. 创建客户端Socket对象指定服务器地址和端口号
Socket socket = new Socket("192.168.90.72", 8888);
// 2. 创建字节输入流关联源文件:要上传的文件
FileInputStream fis = new FileInputStream("/Users/pkxing/documents/a.jpg");
// 3. 调用Socket对象getOutputStream方法获得字节输出流
OutputStream out = socket.getOutputStream();
// 4. 循环读取图片数据
// 4.1 创建字节数组:存储读取到的图片数据
byte[] buf = new byte[1024];
// 4.2 定义整型变量:接收实际读取到的字节个数
int len = -1;
while((len = fis.read(buf)) != -1){ // len = -1
// 5. 将读取到的图片数据输出到服务器端
out.write(buf, 0, len);
}
// out.write("-1".getBytes());
// 告诉服务器端数据传输完毕:输出一个结束标记给服务器端
socket.shutdownOutput();
// 关闭流释放资源
fis.close();
// 6. 调用Socket对象的getInputStream方法获得字节输入流
InputStream in = socket.getInputStream();
// 7. 调用字节输入流的read方法读取服务器返回的上传状态信息字符串
len = in.read(buf);
System.out.println(new String(buf,0,len));
// 8. 关闭Socket对象
socket.close();
}
}
package com.itheima._07TCP文件上传案例.单用户上传;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;
/**
目标:实现上传文件服务器程序--单用户上传
实现步骤
1. 创建ServerSocket对象并指定端口号:开启服务器
2. 调用ServerSocket对象的accept方法:等待客户端连接并获得Socket对象
3. 调用Socket对象的getInputStream方法:获得字节输入流:InputStream
4. 创建字节输入流关联目标文件:FileOutputStream
5. 循环读取客户端发送的图片数据
6. 将图片输出输出到目标文件中
7. 调用Socket对象的getOutputStream方法:获得字节输出流:OutputStream
8. 调用字节输出流的write方法返回数据给客户端
9. 关闭流和服务器
*/
public class UploadFileServer {
public static void main(String[] args) throws Exception{
// 1. 创建ServerSocket对象并指定端口号:开启服务器
ServerSocket serverSocket = new ServerSocket(8888);
System.out.println("开启了服务器...");
// 2. 调用ServerSocket对象的accept方法:等待客户端连接并获得Socket对象
Socket socket = serverSocket.accept();
File destFile = null;
try{
// 3. 调用Socket对象的getInputStream方法:获得字节输入流:InputStream
InputStream in = socket.getInputStream();
// 4. 创建字节输出流关联目标文件:FileOutputStream
// 4.1 创建随机数对象
Random r = new Random();
// 4.2 随机产生一个整数
int randomNumber = r.nextInt(999999999);
// 4.3 获得当前时间毫秒值和整数进行拼接:得到文件名
String fileName = System.currentTimeMillis()+""+randomNumber+".jpg"; // 15665352414.jpg
// 4.4 创建文件对象
destFile = new File("/Users/pkxing/documents/aaa/", fileName);
FileOutputStream fos = new FileOutputStream(destFile);
// 5. 循环读取客户端发送的图片数据
// 5.1 创建字节数组:用来存储客户端发送的图片数据
byte[] buf = new byte[1024];
// 5.2 定义整型变量:接收实际读取到的字节个数
int len = -1;
while ((len = in.read(buf)) !=-1) {
// 6. 将图片输出输出到目标文件中
fos.write(buf, 0,len);
}
// 关闭流释放资源
fos.close();
// 获得客户端ip地址
String clientIP = socket.getInetAddress().getHostAddress();
System.out.println("恭喜ip为:"+ clientIP +"用户上传成功");
// 7. 调用Socket对象的getOutputStream方法:获得字节输出流:OutputStream
OutputStream out = socket.getOutputStream();
// 8. 调用字节输出流的write方法返回数据给客户端
out.write("上传成功".getBytes());
} catch(Exception e){
// 返回上传失败给客户端
// 7. 调用Socket对象的getOutputStream方法:获得字节输出流:OutputStream
OutputStream out = socket.getOutputStream();
// 8. 调用字节输出流的write方法返回数据给客户端
out.write("上传失败".getBytes());
destFile.delete();
}
}
}
多用户上传
package com.itheima._07TCP文件上传案例.多用户上传;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
/**
目标:实现上传文件客户端程序
*/
public class UploadFileClient {
public static void main(String[] args) throws Exception{
// 1. 创建客户端Socket对象指定服务器地址和端口号
Socket socket = new Socket("192.168.90.72", 8888);
// 2. 创建字节输入流关联源文件:要上传的文件
FileInputStream fis = new FileInputStream("/Users/pkxing/documents/a.jpg");
// 3. 调用Socket对象getOutputStream方法获得字节输出流
OutputStream out = socket.getOutputStream();
// 4. 循环读取图片数据
// 4.1 创建字节数组:存储读取到的图片数据
byte[] buf = new byte[1024];
// 4.2 定义整型变量:接收实际读取到的字节个数
int len = -1;
while((len = fis.read(buf)) != -1){ // len = -1
// 5. 将读取到的图片数据输出到服务器端
out.write(buf, 0, len);
}
// out.write("-1".getBytes());
// 告诉服务器端数据传输完毕:输出一个结束标记给服务器端
socket.shutdownOutput();
// 关闭流释放资源
fis.close();
// 6. 调用Socket对象的getInputStream方法获得字节输入流
InputStream in = socket.getInputStream();
// 7. 调用字节输入流的read方法读取服务器返回的上传状态信息字符串
len = in.read(buf);
System.out.println(new String(buf,0,len));
// 8. 关闭Socket对象
socket.close();
}
}
package com.itheima._07TCP文件上传案例.多用户上传;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;
/**
目标:实现上传文件服务器程序--多用户上传
实现步骤
1. 开启一个服务器程序
2. 使用死循环保证服务器程序永不退出
3. 等待客户端连接,创建线程处理用户的上传文件请求
*/
public class UploadFileServer {
public static void main(String[] args) throws Exception{
// 1. 开启一个服务器程序
ServerSocket serverSocket = new ServerSocket(8888);
System.out.println("开启了服务器...");
// 2. 使用死循环保证服务器程序永不退出
while (true){
// 3. 等待客户端连接
Socket socket = serverSocket.accept();
// 4. 创建线程处理用户的上传文件请求
new UploadThread(socket).start();
}
}
}
package com.itheima._07TCP文件上传案例.多用户上传;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Random;
/**
上传线程
*/
public class UploadThread extends Thread {
private Socket socket;
public UploadThread(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try{
// 3. 调用Socket对象的getInputStream方法:获得字节输入流:InputStream
InputStream in = socket.getInputStream();
// 4. 创建字节输出流关联目标文件:FileOutputStream
// 4.1 创建随机数对象
Random r = new Random();
// 4.2 随机产生一个整数
int randomNumber = r.nextInt(999999999);
// 4.3 获得当前时间毫秒值和整数进行拼接:得到文件名
String fileName = System.currentTimeMillis()+""+randomNumber+".jpg"; // 15665352414.jpg
// 4.4 创建文件对象
File destFile = new File("/Users/pkxing/documents/aaa/", fileName);
FileOutputStream fos = new FileOutputStream(destFile);
// 5. 循环读取客户端发送的图片数据
// 5.1 创建字节数组:用来存储客户端发送的图片数据
byte[] buf = new byte[1024];
// 5.2 定义整型变量:接收实际读取到的字节个数
int len = -1;
while ((len = in.read(buf)) !=-1) {
// 6. 将图片输出输出到目标文件中
fos.write(buf, 0,len);
}
// 关闭流释放资源
fos.close();
// 获得客户端ip地址
String clientIP = socket.getInetAddress().getHostAddress();
System.out.println("恭喜ip为:"+ clientIP +"用户上传成功");
// 7. 调用Socket对象的getOutputStream方法:获得字节输出流:OutputStream
OutputStream out = socket.getOutputStream();
// 8. 调用字节输出流的write方法返回数据给客户端
out.write("上传成功".getBytes());
} catch(Exception e){
// 返回上传失败给客户端
try{
// 7. 调用Socket对象的getOutputStream方法:获得字节输出流:OutputStream
OutputStream out = socket.getOutputStream();
// 8. 调用字节输出流的write方法返回数据给客户端
out.write("上传失败".getBytes());
} catch(Exception ee){
}
}
}
}
8.模拟BS服务器案例
package com.itheima._08模拟BS服务器案例;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
目标:模拟网站BS服务器,使用浏览器访问自己编写的服务端程序,查看网页效果。
讲解:
1. 准备网页数据,保存到baidu.txt文本中。
2. 当使用浏览器访问服务端程序时,返回网页数据显示。
localhost 代表本机域名
http://127.0.0.1:6666/
*/
public class Demo08 {
public static void main(String[] args) throws Exception {
// 开启服务器程序:ServerSocket对象
ServerSocket serverSocket = new ServerSocket(6666);
System.out.println("开启服务器....");
// 等待浏览器连接得到Socket对象
Socket socket = serverSocket.accept();
// 获得字节输入流
InputStream in = socket.getInputStream();
byte[] buf = new byte[1024];
int len = in.read(buf);
System.out.println(len);
System.out.println(new String(buf,0,len));
// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("day11_课堂代码/baidu.txt"));
// 读取网页文件的数据
String line = br.readLine();
// 获得字节输出流
OutputStream out = socket.getOutputStream();
// 将网页文件的数据返回给浏览器解析显示
out.write(line.getBytes());
// 关闭流释放资源
br.close();
// 关闭服务器
serverSocket.close();
}
}
/*
网页数据:使用标签编写代码,浏览器负责解析标签
<!DOCTYPE html><!--STATUS OK--><html> <head><meta http-equiv=content-type content=text/html;charset=utf-8><meta http-equiv=X-UA-Compatible content=IE=Edge><meta content=always name=referrer><link rel=stylesheet type=text/css href=http://s1.bdstatic.com/r/www/cache/bdorz/baidu.min.css><title>百度一下,你就知道</title></head> <body link=#0000cc> <div id=wrapper> <div id=head> <div class=head_wrapper> <div class=s_form> <div class=s_form_wrapper> <div id=lg> <img hidefocus=true src=//www.baidu.com/img/bd_logo1.png width=270 height=129> </div> <form id=form name=f action=//www.baidu.com/s class=fm> <input type=hidden name=bdorz_come value=1> <input type=hidden name=ie value=utf-8> <input type=hidden name=f value=8> <input type=hidden name=rsv_bp value=1> <input type=hidden name=rsv_idx value=1> <input type=hidden name=tn value=baidu><span class="bg s_ipt_wr"><input id=kw name=wd class=s_ipt value maxlength=255 autocomplete=off autofocus></span><span class="bg s_btn_wr"><input type=submit id=su value=百度一下 class="bg s_btn"></span> </form> </div> </div> <div id=u1> <a href=http://news.baidu.com name=tj_trnews class=mnav>新闻</a> <a href=http://www.hao123.com name=tj_trhao123 class=mnav>hao123</a> <a href=http://map.baidu.com name=tj_trmap class=mnav>地图</a> <a href=http://v.baidu.com name=tj_trvideo class=mnav>视频</a> <a href=http://tieba.baidu.com name=tj_trtieba class=mnav>贴吧</a> <noscript> <a href=http://www.baidu.com/bdorz/login.gif?login&tpl=mn&u=http%3A%2F%2Fwww.baidu.com%2f%3fbdorz_come%3d1 name=tj_login class=lb>登录</a> </noscript> <script>document.write('<a href="http://www.baidu.com/bdorz/login.gif?login&tpl=mn&u='+ encodeURIComponent(window.location.href+ (window.location.search === "" ? "?" : "&")+ "bdorz_come=1")+ '" name="tj_login" class="lb">登录</a>');</script> <a href=//www.baidu.com/more/ name=tj_briicon class=bri style="display: block;">更多产品</a> </div> </div> </div> <div id=ftCon> <div id=ftConw> <p id=lh> <a href=http://home.baidu.com>关于百度</a> <a href=http://ir.baidu.com>About Baidu</a> </p> <p id=cp>©2017 Baidu <a href=http://www.baidu.com/duty/>使用百度前必读</a> <a href=http://jianyi.baidu.com/ class=cp-feedback>意见反馈</a> 京ICP证030173号 <img src=//www.baidu.com/img/gs.gif> </p> </div> </div> </div> </body> </html>
*/
9.junit基本使用
package com.itheima._09junit基本使用;
/**
目标:能够说出junit的作用
讲解:
1. 什么是Junit
Junit是第三方Java语言编写的单元测试工具。
框架 ==> 类的集合 ==> 类库 junit.jar
什么是单元:在Java中一个类就是一个单元。
单元测试:开发者编写的一小段代码对某个类中的某个方法进行测试,保证方法的正确性和
稳定性。
2. Junit的作用
对类的方法进行测试,保证方法的正确性和稳定性,最大限避免出现bug。
在实际开发,分层开发的
* 表现层:直接和用户打交道,展示数据给用户看和接收用户输入的数据。
* 业务层:处理业务逻辑的
* 数据访问层:直接和数据库打交道:对数据库执行增删改查操作
小结:
1. Junit的作用:用来对类的方法进行测试,保证方法的正确性和稳定性,最大限避免出现bug。
*/
public class Demo091 {
}
package com.itheima._09junit基本使用;
/**
目标:掌握junit常用注解
讲解:
Junit4.0
@Before: 用来修饰方法,该方法会在每一个测试方法执行之前执行1次。
@After: 用来修饰方法,该方法会在每一个测试方法执行之后执行1次。
Junit5.0
@BeforeEach: 用来修饰方法,该方法会在每一个测试方法执行之前执行1次。
@AfterEach: 用来修饰方法,该方法会在每一个测试方法执行之后执行1次。
小结:
1. @Before注解修饰方法的执行时机:每个测试方法执行之前执行1次
2. @After注解修饰方法的执行时机:每个测色方法执行之后执行1次
*/
public class Demo093 {
}
package com.itheima._09junit基本使用;
/**
* @author pkxing
* @version 1.0
* @Package com.itheima._09junit基本使用
* @date 2019-08-13 16:39
*/
public class Student {
}
package com.itheima._09junit基本使用;
/**
* 业务类:对学生进行增删改查操作
*/
public class StudentDao {
// 业务方法:保存学生
public boolean saveStudent(Student stu){
System.out.println("保存学生:" + stu);
return true;
}
// 业务方法:根据id删除学生
public void deleteById(int id){
System.out.println("删除id为"+id+"学生");
}
}
package com.itheima._09junit基本使用;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
/**
目标:能够使用junit进行单元测试
讲解:
1. Junit的使用步骤
1.1 编写业务类:实现某一个业务逻辑的类,比如要对象学生进行增删改查
编写业务方法:实现某一个功能的方法,比如添加学生
1.2 编写测试类:对业务类中的方法进行测试
编写测试方法:编程测试代码测试业务方法
2. 测试方法的要求
测试类命名要求:一般以Test开头,以业务类名结尾
比如业务类名:StudentDao,那么测试类名:TestStudentDao
测试方法的命名要求:一般以test,以业务方法名结尾
比如业务方法名:saveStudent,则测试方法名为:testSaveStudent
测试方法的声明要求:
必须是public修饰,必须没有返回值,必须没有参数,必须使用@Test注解修饰
3. 测试方法的运行方式
选中测试方法名 --> 右键 --> run '测试方法名' 执行选中的测试方法
选中测试类名 --> 右键 --> run '测试类名' 执行当前测试类的所有测试方法
选中项目名 --> 右键 --> run 'All Tests' 执行当前项目下所有测试类中的所有测试方法
4. 如何查看测试结果
绿色:代表测试通过,没有异常
红色:代表测试失败,有异常
小结:
1. 测试方法的要求
必须是public,必须没有返回值,必须没有参数,必须使用@Test注解
*/
// 测试类
public class TestStudentDao {
// 成员变量
StudentDao stuDao = null;
@Before // 该方法会在每一个测试方法执行之前执行1次。
public void init(){
System.out.println("init");
// 创建数据访问层对象
stuDao = new StudentDao();
}
@After // 该方法会在每一个测试方法执行之后执行1次。
public void close(){
System.out.println("close");
stuDao = null;
}
// 测试方法:编写测试代码对业务方法进行测试
@Test
public void testSaveStudent(){
// 创建学生
Student stu = new Student();
// 保存学生信息
boolean result = stuDao.saveStudent(stu);
/*
断言:预先判断某个条件一定成立,如果条件不成立则直接抛出异常
Assert.assertEquals(String message, Object expected , Object actual);
message:提示信息字符串
expected:期望值
actual:实际值
*/
Assert.assertEquals("期望值和实际值不一致", true, result);
System.out.println("result = " + result);
}
@Test
public void testDeleteById(){
stuDao.deleteById(1);
}
}
10.总结
/**
- 能够辨别UDP和TCP协议特点
UDP协议
面向无连接
只管发送,不确认是否收到
速度快但不可靠
基于数据包进行传输
数据包大小限制在64k
TCP协议 TCP ==> Transfer Control Protocol 传输控制协议
面向连接协议
通过三次握手建立连接
通过四次挥手断开连接
基于IO流进行传输
传输数据大小无限制
速度慢但可靠
- 能够说出TCP协议下两个常用类名称
Socket:代表客户端程序
ServerSocket:代表服务器端程序
- 能够编写TCP协议下字符串数据传输程序
TCP客户端实现步骤
1.创建客户端Socket关联服务器ip和端口号
2.获得字节输出流对象
3.调用字节输出流对象的write输出数据
4.获得字节输入流对象
5.调用字节输入流对象的read方法读取服务器返回数据
6.关闭socket断开连接
TCP服务器端实现步骤
1. 创建服务器端ServerSocket对象并指定端口号
2. 调用accept方法等待客户端连接并获得Socket对象
3. 获得字节输入流对象
4. 调用字节输入流对象的read方法读取客户端发送的数据
5. 获得字节输出流对象
6. 调用字节输出流对象的write输出数据给客户端
7. 关闭服务器端
- 能够理解TCP协议下文件上传案例
* 参考代码 类似文件复制
- 能够理解TCP协议下模拟B\S服务器案例
* 参考代码
知识回顾
1. 缓冲流原理:内部准备了一个缓冲区数组,用来临时存储数据,当数组满了或调用close或flush方法
才会将数组的数据输出到目标文件中:减少底层资源的调用次数,提高读写速度。
字节缓冲输入流:BufferedInputStream 包装 FileInputStream 方法:read
字节缓冲输入流:BufferedOutputStream 包装 FileOutputStream 方法:write
字符缓冲输入流:BufferedReader 包装 FileReader 方法:readLine read
字符缓冲输出流:BufferedWriter 包装 FileWriter 方法:newLine write
2. 转换流:本质就是字符流
字符转换输入流:InputStreamReader 包装 FileInputStream
转换过程:字节转字符
1. 先通过字节输入流FileInputStream从目标文件中读取数据,读取到的是二进制数据
2. 然后将二进制数据交给字符转换输入流InputStreamReader查询码表解码成字符。
字符转换输出流:OutputStreamWriter 包装 FileOutputStream
转换过程:字符转字节
1. 先通过字符转换输出流OutputStreamWriter将字符查询指定的码表转换为二进制数据
2. 然后将二进制数据交给字节输出流FileOutputStream输出目标文件中
3. 序列化流
实现对象序列化操作:保存自定义对象到文件中 ObjectOutputStream 方法:writeObject(Object obj)
实现对象反序列化操作:从文件中读取自定义对象 ObjectInputStream 方法:Object readObject()
自定义对象要想实现序列化则必须要实现一个Serializable接口,并自定义序列号。
4. 打印流:方便原样直接输出各种数据类型的值。
5. Properties集合
保存键值对:String setProperty(String key,String value)
根据键获得值:String getProperty(String key)
根据键删除键值对:String remove(String key)
获得键集合:Set<String> stringPropertyNames();
保存集合数据到文件中:store(OutputStream out,String comments);
从文件中读取数据到集合中:load(InputStream in)
属性文件中键值对的格式:一个键值对占据一行:键=值
*/
public class Demo10 {
}
##