一、网络编程
学习目标
1 网络编程
1.1 软件架构
- C/S结构 ：全称为Client/Server结构，是指客户端和服务器结构。常见程序有ＱＱ、迅雷等软件
- B/S结构 ：全称为Browser/Server结构，是指浏览器和服务器结构。常见浏览器有谷歌、火狐等
- 两种架构各有优势，但是都离不开网络的支持。网络编程 , 就是在一定的协议下，实现两台计算机的通信的程序
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G15SJeup-1678110595198)(D:\传智播客\上海-JavaSE进阶面授\day13【网络编程，Junit单元测试，单例模式，多例模式，工厂模式】\笔记\imgs\image-20210418000257329.png)]](https://i-blog.csdnimg.cn/blog_migrate/f48cb7800daab6fb7383b675bc000d6d.png)
1.2 什么是网络编程
- 在网络通信协议下，不同计算机上运行的程序，可以进行数据传输
1.3 网络编程三要素
- IP地址 : 设备在网络中的地址，是唯一的标识。
- 端口 : 设备在网络中的地址，是唯一的标识。
- 数据在网络中传输的规则，常见的协议有UDP协议和TCP协议。
1.4 IP地址
-
IP：全称”互联网协议地址”，也称IP地址。是分配给上网设备的数字标签。常见的IP分类为：ipv4和ipv6
简单来说 : 就是设备在网络中的唯一标识 , 想要连接哪一台电脑 , 就找到此电脑在网络中的ip地址
-
IP地址常见分类 : ipv4和ipv6
-
常用命令：
- ipconfig：查看本机IP地址
- IP地址：检查网络是否连通
-
特殊IP地址：
- 127.0.0.1：是回送地址也称本地回环地址，可以代表本机的IP地址，一般用来测试使用
-
为了方便我们对IP地址的获取和操作，Java提供了一个类InetAddress 供我们使用
InetAddress：此类表示Internet协议（IP）地址-
static InetAddress getByName(String host) 在给定主机名的情况下确定主机的 IP 地址 String getHostName() 获取此 IP 地址的主机名 String getHostAddress() 返回 IP 地址字符串（以文本表现形式）。
-
1.5 端口
-
端口：应用程序在设备中唯一的标识。
-
端口号：应用程序的唯一标识方式 , 用两个字节表示的整数，它的取值范围是0~65535。
其中0~1023之间的端口号用于一些知名的网络服务或者应用。
我们自己使用1024以上的端口号就可以了。 -
注意：一个端口号只能被一个应用程序使用。
1.6 通信协议
- 协议：计算机网络中，连接和通信的规则被称为网络通信协议
- UDP协议
- 用户数据报协议(User Datagram Protocol)
- UDP是面向无连接通信协议。
- 速度快，有大小限制一次最多发送64K，数据不安全，易丢失数据。
- TCP协议
- 传输控制协议 (Transmission Control Protocol)
- TCP协议是面向连接的通信协议。
- 速度慢，没有大小限制，数据安全
2 TCP通信
2.1 TCP发送数据
package com.itheima.tcp_demo.demo1;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
/*
客户端 :
发送数据的步骤
1 创建客户端的Socket对象 : Socket(String host, int port) 与指定服务端连接
参数说明：
host 表示服务器端的主机名，也可以是服务器端的IP地址，只不过是String类型的
port 表示服务器端的端口
2 通获Socket对象取网络中的输出流，写数据
OutputStream getOutputStream()
3 释放资源
void close()
*/
public class ClientDemo {
public static void main(String[] args) throws IOException {
// 创建客户端的Socket对象(Socket) 与指定服务端连接
Socket socket = new Socket("127.0.0.1", 10010);
// 通获Socket对象取网络中的输出流，写数据
OutputStream os = socket.getOutputStream();
os.write("hello".getBytes());
// while(true){}
// 释放资源
os.close();
socket.close();
}
}
2.2 TCP接收数据
package com.itheima.tcp_demo.demo1;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
/*
服务端接收数据 :
1 创建服务器端的Socket对象 : ServerSocket类
ServerSocket(int port) : 构造方法需要绑定一个端口号 , port就是端口号
2 监听客户端连接,并接受连接，返回一个Socket对象
Socket accept() : 该方法会一直阻塞直到建立连接
3 获取网络中的输入流，用来读取客户端发送过来的数据
InputStream getInputStream()
4 释放资源 : 服务端一般不会关闭
void close()
*/
public class ServerDemo {
public static void main(String[] args) throws IOException {
// 1 创建服务器端的Socket对象 : ServerSocket类
// ServerSocket(int port) : 构造方法需要绑定一个端口号 , port就是端口号
ServerSocket serverSocket = new ServerSocket(10010);
// 2 监听客户端连接,并接受连接，返回一个Socket对象
// Socket accept() : 该方法会一直阻塞直到建立连接
Socket socket = serverSocket.accept();
//
// 3 获取网络中的输入流，用来读取客户端发送过来的数据
// InputStream getInputStream()
InputStream is = socket.getInputStream();
int by;
System.out.println("read方法执行前");
while ((by = is.read()) != -1) {
System.out.print((char) by);
}
System.out.println("read方法执行后");
}
}
2.3 TCP通信原理分析
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z9WtxECH-1678110595205)(imgs\image-20210418001010941.png)]](https://i-blog.csdnimg.cn/blog_migrate/b5a35f3ab8d11ed3c2e9ae8b1b27a20c.png)
2.4 TCP三次握手
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6n1VHPzl-1678110595216)(imgs\image-20210418001256988.png)]](https://i-blog.csdnimg.cn/blog_migrate/41e4519102835ba3d0f344e3063997c7.png)
2.5 TCP练习1
package com.itheima.tcp_demo.test1;
import java.io.*;
import java.net.Socket;
/*
客户端 :
发送数据的步骤
1 创建客户端的Socket对象 : Socket(String host, int port) 与指定服务端连接
参数说明：
host 表示服务器端的主机名，也可以是服务器端的IP地址，只不过是String类型的
port 表示服务器端的端口
2 通获Socket对象取网络中的输出流，写数据
OutputStream getOutputStream()
3 释放资源
void close()
*/
public class ClientDemo {
public static void main(String[] args) throws IOException {
// 创建客户端的Socket对象(Socket) 与指定服务端连接
Socket socket = new Socket("127.0.0.1", 10010);
// 通获Socket对象取网络中的输出流，写数据
OutputStream os = socket.getOutputStream();
os.write("hello".getBytes());
// 像服务端写入结束标记
socket.shutdownOutput();
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String line = br.readLine();
System.out.println(line);
// 释放资源
br.close();
os.close();
socket.close();
}
}
package com.itheima.tcp_demo.test1;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/*
服务端接收数据 :
1 创建服务器端的Socket对象 : ServerSocket类
ServerSocket(int port) : 构造方法需要绑定一个端口号 , port就是端口号
2 监听客户端连接,并接受连接，返回一个Socket对象
Socket accept() : 该方法会一直阻塞直到建立连接
3 获取网络中的输入流，用来读取客户端发送过来的数据
InputStream getInputStream()
4 释放资源 : 服务端一般不会关闭
void close()
*/
public class ServerDemo {
public static void main(String[] args) throws IOException {
// 1 创建服务器端的Socket对象 : ServerSocket类
// ServerSocket(int port) : 构造方法需要绑定一个端口号 , port就是端口号
ServerSocket serverSocket = new ServerSocket(10010);
// 2 监听客户端连接,并接受连接，返回一个Socket对象
// Socket accept() : 该方法会一直阻塞直到建立连接
Socket socket = serverSocket.accept();
//
// 3 获取网络中的输入流，用来读取客户端发送过来的数据
// InputStream getInputStream()
InputStream is = socket.getInputStream();
int by;
while ((by = is.read()) != -1) {
System.out.print((char) by);
}
BufferedWriter bos = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
bos.write("你谁啊");
bos.close();
is.close();
socket.close();
serverSocket.close();
}
}
2.6 TCP练习2
package com.itheima.tcp_demo.test2;
import java.io.*;
import java.net.Socket;
public class ClientDemo {
public static void main(String[] args) throws IOException {
// 创建客户端Socket对象
Socket socket = new Socket("127.0.0.1", 10086);
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\传智播客\\安装包\\好看的图片\\liqin.jpg"));
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
int by;
while ((by = bis.read()) != -1) {// 从本地中读一个字节
bos.write(by);// 往服务器写一个字节
bos.flush();
}
// 写结束标记
socket.shutdownOutput();
// 把网络中的字节输入流 , 封装成高效的字符输入流
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
// String line;
// while ((line = br.readLine()) != null) {
// System.out.println(line);
// }
String msg = br.readLine();// 读到换行才叫读到一行, 所以必须写服务器必须写newLine
System.out.println(msg);
// 释放资源
bis.close();
socket.close();
}
}
package com.itheima.tcp_demo.test2;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerDemo {
public static void main(String[] args) throws IOException {
// 创建服务端的连接对象
ServerSocket serverSocket = new ServerSocket(10086);
Socket socket = null;
BufferedInputStream bis = null;
BufferedWriter socketBw = null;
while (true) {
// 获取Socket对象
socket = serverSocket.accept();
// 获取网络中的字节输入流 在封装成高效的字节输入流对象
bis = new BufferedInputStream(socket.getInputStream());
// 创建本地的字节输出流 , 封装成高效的字节输出流
BufferedOutputStream bw = new BufferedOutputStream(new FileOutputStream("day13_demo\\图片\\a.jpg"));
int by;
while ((by = bis.read()) != -1) {
bw.write(by);
bw.flush();
}
//关闭本地流
bw.close();
// 获取网络中的字节输出流 , 封装成高效的字符输出流
socketBw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
socketBw.write("谢谢你");
socketBw.newLine();// 必须有换行 , 因为readLine读到换行结束
socketBw.flush();
}
// 释放资源
// socketBw.close();
// bis.close();
// socket.close();
// serverSocket.close();
}
}
2.7 TCP练习3
package com.itheima.tcp_demo.test3;
import java.io.*;
import java.net.Socket;
public class ClientDemo {
public static void main(String[] args) throws IOException {
// 创建客户端Socket对象
Socket socket = new Socket("127.0.0.1", 10086);
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\传智播客\\安装包\\好看的图片\\liqin.jpg"));
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
int by;
while ((by = bis.read()) != -1) {// 从本地中读一个字节
bos.write(by);// 往服务器写一个字节
bos.flush();
}
// 写结束标记
socket.shutdownOutput();
// 把网络中的字节输入流 , 封装成高效的字符输入流
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
// String line;
// while ((line = br.readLine()) != null) {
// System.out.println(line);
// }
String msg = br.readLine();// 读到换行才叫读到一行, 所以必须写服务器必须写newLine
System.out.println(msg);
// 释放资源
bis.close();
socket.close();
}
}
package com.itheima.tcp_demo.test3;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ServerDemo {
public static void main(String[] args) throws IOException {
// 创建服务端的连接对象
ServerSocket serverSocket = new ServerSocket(10086);
ExecutorService executorService = Executors.newFixedThreadPool(10);
while (true) {
// 获取Socket对象
Socket socket = serverSocket.accept();
executorService.submit(new ServerThread(socket));
}
// 释放资源
// socketBw.close();
// bis.close();
// socket.close();
// serverSocket.close();
}
}
package com.itheima.tcp_demo.test3;
import javax.management.relation.RoleUnresolved;
import java.io.*;
import java.net.Socket;
import java.util.UUID;
public class ServerThread implements Runnable {
Socket socket = null;
BufferedOutputStream bw = null;
public ServerThread(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
// 获取网络中的字节输入流 在封装成高效的字节输入流对象
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
// 创建本地的字节输出流 , 封装成高效的字节输出流
bw = new BufferedOutputStream(new FileOutputStream("day13_demo\\图片\\" + UUID.randomUUID() + ".jpg"));
int by;
while ((by = bis.read()) != -1) {
bw.write(by);
bw.flush();
}
// 获取网络中的字节输出流 , 封装成高效的字符输出流
BufferedWriter socketBw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
socketBw.write("谢谢你");
socketBw.newLine();// 必须有换行 , 因为readLine读到换行结束
socketBw.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭本地流
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
3 Junit单元测试
3.1 Junit4单元测试概述
-
单元测试就是编写测试代码，可以准确、快速地保证程序的正确性，Junit是Java单元测试的框架。
-
JUnit4可以通过注解的方式来标记方法 , 让方法存某种意义 ，常见的注解有：
- @BeforeClass 全局只会执行一次，而且是第一个运行（标记的方法需要是一个静态无参无返回值方法）
- @Before 在测试方法运行之前运行（非静态无参无返回值方法）
- **@Test 测试方法（此方法必须是非静态无参无返回值方法）, 主要用于测试的方法 **
- @After 在测试方法运行之后运行（非静态无参无返回值方法）
- @AfterClass 全局只会执行一次，而且是最后一个运行（标记的方法需要是一个静态无参无返回值方法）
- @Ignore 忽略此方法
3.2 Junit的基本使用
- 已知存在需要测试的类Calculator ，这是一个能够简单实现加减乘除、平方、开方的计算器类，然后对这些功能进行单元测试。
// 计算器类
public class Calculator {
// 静态变量，用于存储运行结果
private static int result;
// 加法运算
public void add(int n) {
result = result + n;
}
// 减法运算
public void subtract(int n) {
// Bug: 正确的应该是 result = result - n
result = result - 1;
}
// 乘法运算
public void multiply(int n) {
// 此方法尚未写好
}
// 除法运算
public void divide(int n) {
result = result / n;
}
// 平方运算
public void square(int n) {
result = n * n;
}
// 平方根运算
public void squareRoot(int n) {
// Bug : 死循环
for (; ;) ;
}
// 将结果清零
public void clear() {
result = 0;
}
// 返回运算结果
public int getResult(){
return result;
}
}
-
引入Junit4的jar包到模块中
-
第一步 : 在模块中新建文件夹lib，拷贝今天资料中junit4的jar包到模块中
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3AMLQNCS-1678110595217)(\imgs\03_通讯协议.png)]](https://i-blog.csdnimg.cn/blog_migrate/471ab91401209858abf36016bc40cbd0.png)
-
第二步 : 选中jar文件 , 右键选择 Add as Library
-
-
生成Junit测试框架
-
使用IDEA能够直接给需要测试的类生成测试框架，如下：0
-
选中本类任何位置右键选择 Generate（Alt+Insert）/ go to 选项 , 选择Test…
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FkAlb4ky-1678110595220)(/imgs/image-20210304072444630.png)]](https://i-blog.csdnimg.cn/blog_migrate/9443e9a2eba9b943964767f61eaadebd.png)
-
选择需要进行测试的方法
-
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R1GFOFUJ-1678110595222)(/imgs/image-20210304074059399.png)]](https://i-blog.csdnimg.cn/blog_migrate/46080865554ef3cc71f5bec8b553531d.png)
-
在上一步OK后系统会自动生成一个新类CalculatorTest，里面包含一些空的测试用例。
你只需要将这些测试用例稍作修改即可使用，完整的CalculatorTest代码如下：
package com.itheima.junit_demo; import org.junit.Assert; import org.junit.Before; import org.junit.Ignore; import org.junit.Test; import static org.junit.Assert.*; /* 测试类 */ public class CalculatorTest { Calculator calculator = new Calculator(); @Before public void setUp() throws Exception { calculator.clear(); // System.out.println("优先于Test注解修饰的方法之前执行..."); } @Test public void add() { System.out.println("Test修饰的方法执行了.."); calculator.add(10); calculator.add(20); calculator.add(30); /* 第一个参数表示期望值 第二个参数表示实际值 如果实际值和期望值相同，说明结果正确就测试通过,如果不相同，说明结果是错误的,就会报错 Assert.assertEquals( 期望值, 实际值); */ int result = calculator.getResult(); Assert.assertEquals(60 , result); } @Test public void subtract() { calculator.add(100); calculator.add(200); calculator.subtract(70); int result = calculator.getResult(); Assert.assertEquals(230 , result); } @Ignore // 此方法不需要测试 , 不会执行 @Test public void multiply() { } @Test public void divide() { calculator.add(100); calculator.divide(0); int result = calculator.getResult(); // Assert.assertEquals(5 , result); } @Test public void square() { calculator.squareRoot(10); } @Test(timeout = 3000) public void squareRootTest() { calculator.squareRoot(10); } } -
限时测试
对于那些逻辑很复杂，循环嵌套比较深的程序，很有可能出现死循环，因此一定要采取一些预防措施。限时测试是一个很好的解决方案。我们给这些测试函数设定一个执行时间，超过了这个时间，他们就会被系统强行终止，并且系统还会向你汇报该函数结束的原因是因为超时，这样你就可以发现这些Bug了。要实现这一功能，只需要给@Test标注加一个参数即可，代码如下：
被测方法：
public void squareRoot(int n) { //Bug : 死循环 for (; ; ) ; }测试方法：
@Test(timeout = 1000) // Timeout参数表明了你要设定的时间，单位为毫秒，因此1000就代表1秒。 public void squareRoot() { calculator.squareRoot(4); assertEquals(2 , calculator.getResult()); }
-
3.3 断言
预先判断某个条件一定成立，如果条件不成立，则直接报错。
-
使用 :
//第一个参数表示期望值 //第二个参数表示实际值 //如果实际值和期望值相同，说明结果正确就测试通过,如果不相同，说明结果是错误的,就会报错 Assert.assertEquals( 期望值, 实际值); Assert.assertEquals("异常原因"， 期望值, 实际值); //例如： int result = add(100,200); Assert.assertEquals(300, result); -
小结 : 如何进行断言
Assert.assertEquals(期望值,实际值)
4 单例设计模式
学习目标
- 能够使用单例设计模式设计代码
内容讲解
- 正常情况下一个类可以创建多个对象
public static void main(String[] args) {
// 正常情况下一个类可以创建多个对象
Person p1 = new Person();
Person p2 = new Person();
Person p3 = new Person();
}
- 如果说有时一个对象就能搞定的事情 , 非要创建多个对象 , 浪费内存!!!
4.1 单例设计模式的作用
-
单例模式，是一种常用的软件设计模式。通过单例模式可以保证项目中，应用该模式的这个类只有一个实例。
即一个类只有一个对象实例。
-
好处 ：可以节省内存，共享数据
4.2 单例设计模式实现步骤
- 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
- 在该类内部产生一个唯一的实例化对象，并且将其封装为private static 类型的成员变量。
- 定义一个静态方法返回这个唯一对象。
4.3 单例设计模式的类型
根据创建对象的时机单例设计模式又分为以下两种:
-
饿汉单例设计模式
-
懒汉单例设计模式
=============================================================================================
4.4 饿汉单例设计模式
-
饿汉单例设计模式就是使用类的时候已经将对象创建完毕
不管以后会不会使用到该实例化对象，先创建了再说。很着急的样子，故被称为“饿汉模式”。
-
代码如下：
public class Singleton { // 1.将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。 private Singleton() {} // 2.在该类内部产生一个唯一的实例化对象，并且将其封装为private static 类型的成员变量。 private static Singleton instance = new Singleton(); // 3.定义一个静态方法返回这个唯一对象。 public static Singleton getInstance() { return instance; } } -
需求：定义一个皇帝类，要求对象只能存在一个。
=============================================================================================
4.5 懒汉单例设计模式
-
懒汉单例设计模式就是调用getInstance()方法时对象才被创建
也就是说先不急着实例化出对象，等要用的时候才实例化出对象。不着急，故称为“懒汉模式”。
代码如下：
public class Singleton {
// 2.在该类内部产生一个唯一的实例化对象，并且将其封装为private static类型的成员变量。
private static Singleton instance;// 0x001
// 1.将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
private Singleton() {}
// 3.定义一个静态方法返回这个唯一对象。要用的时候才例化出对象
public static synchronized Singleton getInstance() {
if(instance == null) {
instance = new Singleton();// 0x001
}
return instance;
}
}
- ##### 注意 ：
- 懒汉单例设计模式在多线程环境下可能会实例化出多个对象，不能保证单例的状态，所以加上关键字：synchronized，保证其同步安全。
- 需求：使用懒汉单例 ，改写皇帝类的单例模式
```java
知识小结
-
单例模式可以保证系统中一个类只有一个对象实例。
-
实现单例模式的步骤：
- 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
- 在该类内部产生一个唯一的实例化对象，并且将其封装为private static类型的成员变量。
- 定义一个静态方法返回这个唯一对象。
5 多例设计模式
学习目标
- 能使用多例设计模式设计代码
内容讲解
5.1 多例设计模式的作用
-
多例模式，是一种常用的设计模式之一。通过多例模式可以保证项目中，应用该模式的类有固定数量的实例。
多例类要自我创建并管理自己的实例，还要向外界提供获取本类实例的方法。
-
使用场景：线程池
线程池 = Executors.newFixedThreadPool(3);
5.2.实现步骤
1.创建一个类, 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
2.在类中定义该类被创建对象的总数量
3.在类中定义存放类实例的list集合
4.在类中提供静态代码块,在静态代码块中创建类的实例
5.提供获取类实例的静态方法
5.3.实现代码
-
某一个学科有固定3位老师，年级中上该课程的老师就是这三位老师其中一位
要求使用多例模式 ,每次获取的都是这三位老师其中一位
package com.itheima.moreinstance_demo;
import com.itheima.homework.Test;
import java.time.Period;
import java.util.ArrayList;
import java.util.Random;
/*
需求 : 某一个学科有固定3位老师，年级中上该课程的老师就是这三位老师其中一位
要求使用多例模式 ,每次获取的都是这三位老师其中一位
实现步骤 :
1.创建一个类, 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
2.在类中定义该类被创建对象的总数量
3.在类中定义存放类实例的list集合
4.在类中提供静态代码块,在静态代码块中创建类的实例
5.提供获取类实例的静态方法
*/
public class Teacher {
// 1.创建一个类, 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
private Teacher() {
}
// 2.在类中定义该类被创建对象的总数量
private static final int maxCount = 3;
// 3.在类中定义存放类实例的list集合
private static ArrayList<Teacher> list = new ArrayList<>();//{三个老师对象}
// 4.在类中提供静态代码块,在静态代码块中创建类的实例
static {
for (int i = 0; i < maxCount; i++) {
list.add(new Teacher());
}
}
// 5.提供获取类实例的静态方法
public static Teacher getInstance() {
Random r = new Random();
// 返回集合中的某一个老师
return list.get(r.nextInt(list.size()));
}
}
package com.itheima.moreinstance_demo;
import org.junit.Test;
public class TeacherTest {
@Test
public void getInstance() {
for (int i = 0; i < 10; i++) {
Teacher teacher = Teacher.getInstance();
System.out.println(teacher);
}
}
}
5.4 小结
-
多例模式作用 : 可以保证项目中一个类有固定个数的实例, 在实现需求的基础上, 能够提高实例的复用性.
实现多例模式的步骤 ：
- 创建一个类, 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
- 在类中定义该类被创建的总数量
- 在类中定义存放类实例的list集合
- 在类中提供静态代码块,在静态代码块中创建类的实例
- 提供获取类实例的静态方法
6 工厂设计模式
学习目标
- 能够使用工厂设计模式设计代码
内容讲解
6.1 概述
- 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。之前我们创建类对象时, 都是使用 new 对象的形式创建, 除new 对象方式以外, 工厂模式也可以创建对象.
6.2作用
- 解决类与类之间的耦合问题
6.3案例实践
-
需求：定义汽车工厂类，生产各种品牌的车
-
实现步骤
- 编写一个Car接口, 提供run方法
- 编写一个Falali类实现Car接口,重写run方法
- 编写一个Benchi类实现Car接口
- 提供一个CarFactory(汽车工厂),用于生产汽车对象
- 定义CarFactoryTest测试汽车工厂
实现代码
package com.itheima.factorydesign_demo;
/*
- 需求：定义汽车工厂类，生产各种品牌的车
- 实现步骤
- 编写一个Car接口, 提供run方法
- 编写一个Falali类实现Car接口,重写run方法
- 编写一个Benchi类实现Car接口
- 提供一个CarFactory(汽车工厂),用于生产汽车对象
- 定义CarFactoryTest测试汽车工厂
*/
public class CarTest {
public static void main(String[] args) {
// 多态
// Car falali = CarFactory.getCar("Falali");
// Car falali = CarFactory.getCar("fghjkl");
// falali.run();
// 调用此方法getCar , 只能传入枚举项
CarFactory.getCar(CarBrand.FALALI);
}
}
// 汽车接口
interface Car {
public abstract void run();// 行驶
}
// 编写一个Falali类实现Car接口,重写run方法
class Falali implements Car {
@Override
public void run() {
System.out.println("法拉利3秒破百...");
}
}
// 编写一个Benchi类实现Car接口
class Benchi implements Car {
// public Benchi(int price) {
//
// }
@Override
public void run() {
System.out.println("法拉利5秒破百...");
}
}
// 枚举
enum CarBrand {
// 枚举项 : 每个枚举项都相当于枚举的对象
BENCHI, FALALI, DAZHONG, LASILAISI, AODI;
}
// 提供一个CarFactory(汽车工厂),用于生产汽车对象
class CarFactory {
public static Car getCar(CarBrand carBrand) {
switch (carBrand) {
case BENCHI:
return new Benchi();
case FALALI:
return new Falali();
//...
default:
return null;
}
}
}
提供一个CarFactory(汽车工厂),用于生产汽车对象
//class CarFactory {
// public static Car getCar(String carName) {
// if (carName.equals("Falali")) {
// return new Falali();
// } else if (carName.equals("Benchi")) {
// return new Benchi(1000000);
// }
// return null;// 传入的不是Falali或者Benchi 则返回null
// }
//}
知识小结
- 工厂模式的存在可以改变创建对象的方式,降低类与类之间的耦合问题.
二、【注解，动态代理模式】
1 注解
学习目标
- 能够理解注解类型的作用
- 能够列举已经学习过的注解
1.1 注解的概述
-
注解是一种JDK5新出现的一种引用数据类型，表示一种标志，可以去辅助描述说明类中成分的信息。
-
作用 ：
- 编译检测 : 例如 @Override , 在编译时期对方法的一种检测
- 框架数据的配置 : 例如 SSM (XML+注解）
-
已经学过的注解 :
- @Override ：用来修饰方法声明，告诉编译器该方法是重写父类中的方法，如果父类不存在该方法，则编译失败。
- @FunctionnalInterface：修饰接口，表示该接口为函数式接口
- @Test：Junit测试方法的注解
==================================================================================================
1.2 自定义注解
学习目标
- 能够自定义注解
内容讲解
【1】注解
- 注解本质上是一个就是一个接口，但与接口类型定义不一样。
【2】定义格式
-
复习 ：接口可以定义哪些成分
常量 方法 1.抽象方法 2.默认方法 3.静态方法 4.私有方法 -
注解可以定义什么成分？
常量 抽象方法【属性】 只能抽象方法（返回值类型必须是特定的，必须是无参的） 特定的返回值类型 : String，Class，注解类型，枚举类型 , 基本数据类型，以及这些类型的一维数组。 -
格式 ：@interface
修饰符 @interface 注解名{ // 常量 // 抽象方法 【注解中的抽象方法我们称为属性】 类型 属性名(); // 使用的过程在给属性赋值 类型 属性名() default 值; // 也可以在定义的过程中给出默认值 }
【3】代码实践
-
定义一个书(Book)的注解，包含属性书名(name)，价格(price)（默认100），作者(author) , 作者要求可以有多名作者
package com.itheima.annotation_demo; /* 书的注解 需求 : 定义一个书(Book)的注解，包含属性书名(name)，价格(price)（默认100），作者(author) , 作者要求可以有多名作者 */ public @interface Book { String name(); // 书名 double price() default 100; // 价格 String[] author(); // 作者 }
内容小结
请写出注解定义的格式？
修饰符 @interface 注解名{
属性类型 属性名();
属性类型 属性名() default 值;
}
注解中属性类型可以是哪些？
String ，Class ，注解 ，枚举，基本数据 , 以及这些类型的一维数组
================================================================================================================
1.3 注解的使用
学习目标
- 能够知道如何使用注解
- 熟悉特殊属性名value使用
内容讲解
【1】注解使用格式
-
格式 ：
@注解名(属性=值 , 属性=值) 举例 : @Book(name="红楼梦" , price = 200 , author={"曹雪芹" , "高鹗"} ) -
自定义注解主要是可以给某些成分注入信息,注入一些数据
- 可以使用在类上，成员变量上，构造方法上，方法上 …
- 有默认值的属性，可以不用进行赋值,也可以重新修改值
- 如果属性是数组，赋值时若有多个数据需要使用大括号括起来，逗号分隔数据 , 如果数组中只有一个元素, 那么大括号可以省略
【2】代码实践
-
将Book注解使用起来
public @interface Book { String name(); double price() default 100.0; String[] author(); } -
创建一个BookStore的类，在类中定义成员变量，构造方法，成员方法 , 使用注解给这些成分注入信息
package com.itheima.annotation_demo; /* 需求 : 创建一个BookStore的类，在类中定义成员变量，构造方法，成员方法 使用注解给这些成分注入信息 给成员注入四大名著信息 : 西游记 --- 吴承恩 水浒传 --- 施耐庵 三国演义 --- 罗贯中 红楼梦 --- 曹雪芹 , 高鹗 */ // 类 @Book(name = "西游记", author = {"吴承恩"}) public class BookStore { // 成员变量 @Book(name = "红楼梦", price = 200 , author = {"曹雪芹" , "高鹗"}) private String bookName; // 构造方法 @Book(name = "水浒传", author = {"施耐庵"}) public BookStore(String bookName) { this.bookName = bookName; } // 成员方法 @Book(name = "三国演义", author = {"罗贯中"}) public void buy() { } }
【3】注解中特殊的属性名value
-
如果注解中只有一个属性要赋值，而且名字是value。可以将value给省略，可以直接给值
public class Demo01 { @A("Hello") public void test1() { } @B("World") public void test2() { } @B(value = "Hello", price = 10) public void test3() { } } @interface A { String value(); } @interface B { String value(); int price() default 100; }
内容小结
注解使用格式 ？
@注解名(属性名=值 , ...)
1 如果是具有默认值的属性，可以不赋值
2 如果属性类型是数组，赋值多个值时要用大括号 , 数组中如果只有一个数据值, 大括号可以省略
特殊属性名value，赋值特点 ？
如果注解只有一个属性要赋值，而且名字是value，可以直接给值
===============================================================================================================
1.4 元注解
学习目标
- 能够理解什么是元注解
- 熟悉Target和Retention两个元注解的作用
内容讲解
【1】什么是元注解
- Java官方提供的注解 ，元注解是用来限定任何官方提供的非元注解 , 简单理解 : 修饰注解的注解是元注解
**元注解的作用：**用来限定其他注解的生命周期，还可以限定可以使用的位置
-
生命周期 ：源码阶段 ，字节码阶段 ，运行阶段
-
使用的地方 ：类 ，字段 ，构造方法，方法…
【2】常用元注解
1）@Target
-
作用：用来标识注解使用的位置，如果没有使用该注解标识，则自定义的注解可以使用在任意位置。
例如我们刚才自己定义的Book注解 , 就没有使用@Target元注解, 那么就可以使用在任何的位置
@Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.ANNOTATION_TYPE) public @interface Target { ElementType[] value(); } -
ElementType是一个枚举类型：
TYPE ，类，接口,枚举，注解 FIELD, 成员变量 METHOD , 成员方法 PARAMETER , 方法参数 CONSTRUCTOR , 构造方法 LOCAL_VARIABLE , 局部变量 -
使用
@Target(ElementType.METHOD) // Override注解只能作用在方法上 @Retention(RetentionPolicy.SOURCE) public @interface Override { }
2）@Retention
-
作用 ：用来限定注解的生命周期 (有效范围 )
@Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.ANNOTATION_TYPE) public @interface Retention { RetentionPolicy value(); } -
RetentionPolicy也是一个枚举，里面包含三个枚举项 ：
public enum RetentionPolicy { /** * Annotations are to be discarded by the compiler. */ SOURCE ,// 只能在源码阶段 /** * Annotations are to be recorded in the class file by the compiler * but need not be retained by the VM at run time. This is the default * behavior. */ CLASS , // 可以到字节码阶段，默认 /** * Annotations are to be recorded in the class file by the compiler and * retained by the VM at run time, so they may be read reflectively. * * @see java.lang.reflect.AnnotatedElement */ RUNTIME // 可以到运行的时候 // 如果要想通过反射获取注解的数据 , 那么需要设置运行时 , 因为反射需要在运行时动态获取数据 } -
例如：
@Target(ElementType.METHOD) // Override注解只能作用在方法上 @Retention(RetentionPolicy.SOURCE) // 只到源码阶段 public @interface Override { } -
@Target({ElementType.METHOD, ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) public @interface Book{ } // 该Book注解，只能用在方法或者类上面，生命周期可以作用到运行时
内容小结
什么是元注解？
简单理解 : 修饰注解的注解是元注解
Java提供的用来限定自定义注解其生命周期，限定作用位置的注解
有哪些元注解？
Target : 限定作用位置
Retention : 限定生命周期
===========================================================================================================
1.4 注解解析
学习目标
- 能够使用反射的技术完成注解数据的解析
内容讲解
【1】API
AnnotatedElement : 是一个接口，定义了解析注解的方法
1. boolean isAnnotationPresent(Class<Annotation> annotationClass)
参数 : 注解的字节码对象
作用 : 判断当前对象是否使用了指定的注解，如果使用了则返回true，否则false
2. T getAnnotation(Class<T> annotationClass)
参数 : 注解的字节码对象
返回值 : 根据注解类型获得对应注解对象 , 有了注解对象就可以调用属性(抽象方法),获取属性值
Class，Constructor，Method，Field都会实现AnnotatedElement 接口。
- 解析类上的注解：借助字节码对象（Class对象）
- 解析构造方法上的注解 ：借助构造器对象（Constructor对象）
- 解析方法上的注解 ：借助方法对象（Method对象）
- 解析字段上的注解 ：借助字段对象（Field对象）
【2】代码实践
需求如下：
- 定义注解Book，要求如下：
- 包含属性：String value() 书名
- 包含属性：double price() 价格，默认值为 100
- 包含属性：String[] authors() 多位作者
- 限制注解使用的位置 ：类和成员方法上 【Target】
- 指定注解的有效范围 ：RUNTIME 【Retention】
- 定义BookStore类，在类和成员方法上使用Book注解
- 定义TestAnnotation测试类获取Book注解上的数据
给成员注入四大名著信息 :
西游记 --- 施耐庵
水浒传 --- 吴承恩
三国演义 --- 罗贯中
红楼梦 --- 曹雪芹 , 高鹗
Book注解 ：
package com.itheima.annotation_demo.test;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/*
书的注解
需求 : 定义一个书(Book)的注解，包含属性书名(name)，价格(price)（默认100），作者(author) , 作者要求可以有多名作者
*/
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Book {
String value(); // 书名
double price() default 100; // 价格
String[] authors(); // 多位作者
}
BookStore类 ：
package com.itheima.annotation_demo.test;
@Book(value = "三国演义", authors = "罗贯中")
public class BookStore {
@Book(value = "红楼梦" , price = 200 , authors = {"曹雪芹" , "高鹗"})
public void buy(){
}
}
TestAnnotation类：
思路：
- 类型上的注解，使用Class对象解析
- 方法上的注解，使用Method对象解析
**解析 : **
package com.itheima.annotation_demo.test;
import java.lang.reflect.Method;
import java.util.Arrays;
/*
1. 定义注解Book，要求如下：
- 包含属性：String value() 书名
- 包含属性：double price() 价格，默认值为 100
- 包含属性：String[] authors() 多位作者
- 限制注解使用的位置 ：类和成员方法上 【Target】
- 指定注解的有效范围 ：RUNTIME 【Retention】
2. 定义BookStore类，在类和成员方法上使用Book注解
给成员注入四大名著信息 :
西游记 --- 施耐庵
水浒传 --- 吴承恩
三国演义 --- 罗贯中
红楼梦 --- 曹雪芹 , 高鹗
3. 定义Test测试类获取Book注解上的数据
思路 :
1. 类型上的注解，使用Class对象解析
2. 方法上的注解，使用Method对象解析
API :
1. boolean isAnnotationPresent(Class<Annotation> annotationClass)
参数 : 注解的字节码对象
作用 : 判断当前对象是否使用了指定的注解，如果使用了则返回true，否则false
2. T getAnnotation(Class<T> annotationClass)
参数 : 注解的字节码对象
返回值 : 根据注解类型获得对应注解对象 , 有了注解对象就可以调用属性(抽象方法),获取属性值
*/
class Test {
public static void main(String[] args) throws NoSuchMethodException {
Class<BookStore> bookStoreClass = BookStore.class;
// method(bookStoreClass);
Method buyMethod = bookStoreClass.getMethod("buy");
boolean annotationPresent = buyMethod.isAnnotationPresent(Book.class);
if(annotationPresent){
// 说明方法buy方法上存在Book注解
Book annotation = buyMethod.getAnnotation(Book.class);
String value = annotation.value();
double price = annotation.price();
String[] authors = annotation.authors();
System.out.println(value);
System.out.println(price);
System.out.println(Arrays.toString(authors));
}
}
private static void method(Class<BookStore> bookStoreClass) {
/*
boolean isAnnotationPresent(Class<Annotation> annotationClass)
参数 : 注解的字节码对象
作用 : 判断当前对象是否使用了指定的注解，如果使用了则返回true，否则false
*/
boolean annotationPresent = bookStoreClass.isAnnotationPresent(Book.class);
if (annotationPresent) {
/*
T getAnnotation(Class<T> annotationClass)
参数 : 注解的字节码对象
返回值 : 根据注解类型获得对应注解对象 , 有了注解对象就可以调用属性(抽象方法),获取属性值
*/
// 获取书的注解对象
Book annotation = bookStoreClass.getAnnotation(Book.class);
String value = annotation.value();
double price = annotation.price();
String[] authors = annotation.authors();
System.out.println(value);
System.out.println(price);
System.out.println(Arrays.toString(authors));
}
}
}
内容小结
如何解析方法上的注解？
先获取字节码对象
获取方法Method对象
判断是否存在注解： isAnnotationPresent()
如果存在获取注解对象: getAnnotation()
================================================================================================================
2 代理模式概述
学习目标
- 能够理解在代码设计中，代理模式的作用
学习内容
1）概述
为什么要有 “代理” ？
- 生活中就有很多例子，比如委托业务，黄牛（票贩子）等等
- 代理就是被代理者没有能力或者不愿意去完成某件事情，需要找个人代替自己去完成这件事，这才是“代理”存在的原因。
- 例如要租房子，房产中介可以在我们住房前代理我们找房子。中介就是代理，而自己就是被代理了。
在代码设计中，代理模式作用主要就是让 “被代理对象” 的某个方法执行之前或者执行之后加入其他增强逻辑。
前增强 : 例如获取当前时间
被代理对象调用方法
后增强 : 例如获取当前时间
计算方法执行的时间
2）代理的前提条件 : 掌握 !
- 抽象角色 ：声明功能
- 代理角色 ：实现抽象功能 , 完成代理逻辑
- 被代理角色 ：实现抽象功能
意味着被代理角色和代理角色有着共同的父类型（既抽象角色） , 例如我要租房子, 我只能找房产中介, 不能找票贩子
-
代理模式存在两种实现方式：
- 静态代理 (了解 , 用于对动态代理做铺垫)
- 动态代理 (为后面学习的框架做铺垫)
知识小结
-
请说出代码中代理模式的作用？
代理角色对 被代理就角色某个方法执行的前或者后进行 功能增强 -
请说出代理模式中的三个角色？
抽象角色 代理角色 被代理角色
==============================================================================================================
2.1 静态代理
学习目标
- 能够写出静态代理模式代码
内容讲解
-
静态代理是由程序员创建 或 工具生成代理类的源码，再编译代理类。
在程序运行前就已经存在代理类的字节码文件，代理类和被代理类的关系在运行前就确定了。
简单理解 : 在程序运行之前 , 代理类就存在了,这就是静态代理 ; 动态代理是程序运行时动态生成代理类
-
静态代理实现的步骤 :
- 存在一个抽象角色
- 定义被代理角色
- 定义代理，增强被代理角色的功能
案例实践 ：
- 以现实中经纪人代理明星
已知存在接口：
// 1.抽象角色
interface Star {
// 真人秀方法
double liveShow(double money);
void sleep();
}
定义被代理类：
- 定义王宝强类，实现Star方法
// - 定义被代理角色(宝强)
class BaoQiang implements Star {
@Override
public double liveShow(double money) {
System.out.println("宝强参加了一个真人秀活动赚了" + money + "钱");
return money;
}
@Override
public void sleep() {
System.out.println("宝强累了 , 睡觉...");
}
}
定义代理类：
- 定义宋喆经纪人类
// - 定义代理角色(宋喆)，增强被代理角色的功能
class SongZhe implements Star {
private BaoQiang baoQiang;
public SongZhe(BaoQiang baoQiang) {
this.baoQiang = baoQiang;
}
@Override
public double liveShow(double money) {
// 前增强
System.out.println("宋喆帮宝强拉了一个真人秀的活动,获取佣金" + money * 0.8 + "元");
// 被代理角色的功能
double result = baoQiang.liveShow(money * 0.2);
// 后增强
System.out.println("宋喆帮宝强把赚的钱存了起来...");
return result;
}
@Override
public void sleep() {
// 前增强
System.out.println("宋喆帮宝强定了一家五星级大酒店");
baoQiang.sleep();
// 后增强
System.out.println("宋喆帮宝强退房...");
}
}
定义测试类进行测试
/*
静态代理实现的步骤 :
- 存在一个抽象角色
- 定义被代理角色(宝强)
- 定义代理角色(宋喆)，增强被代理角色的功能
*/
public class StaticAgentDemo {
public static void main(String[] args) {
// 创建被代理角色 , 没有任何增强
BaoQiang baoQiang = new BaoQiang();
double result = baoQiang.liveShow(1000);
System.out.println(result);
baoQiang.sleep();
System.out.println("===========================");
// 创建代码角色对象 , 可以对被代理角色功能做前后增强
SongZhe songZhe = new SongZhe(baoQiang);
double result2 = songZhe.liveShow(1000);
System.out.println(result2);
songZhe.sleep();
}
}
关系图 ：
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vEEjvu3V-1678111473046)(imgs/image-20200908092851064.png)]](https://i-blog.csdnimg.cn/blog_migrate/5fa458031f0acefc28190b937a62128f.png)
宋喆和宝强都有共同的父类型。他们的业务方法都是一样。
静态代理和装饰模式的对比 :
BufferedRead(FileRead)
1 装饰设计模式是功能扩展功能,在原有的功能基础之上增加了新的功能
2 而代理主要对功能的前后做了增强
知识小结
-
请问什么叫做静态代理？
代码执行前，已经确定了代理的代码逻辑。
20 动态代理
学习目标
- 能够知道什么是动态代理
- 能够熟悉动态代理相关API
- 能够熟悉动态代理代码执行流程
内容讲解
1）概述
在实际开发过程中往往我们自己不会去创建代理类而是通过JDK提供的Proxy类在程序运行时，运用反射机制动态创建而成
这就是我们所谓的动态代理。
与静态代理之间的区别，在于不用自己写代理类
虽然我们不需要自己定义代理类创建代理对象
但是我们要定义对被代理对象直接访问方法的拦截，原因就是对拦截的方法做增强。
动态代理技术在框架中使用居多，例如：很快要学到的数据库框架MyBatis框架等后期学的一些主流框架技术（Spring，SpringMVC）中都使用了动态代理技术。
2）API学习
Proxy类
java.lang.reflect.Proxy类提供了用于创建动态代理类和对象的静态方法
它还是由这些方法创建的所有动态代理类的超类（代理类的父类是Proxy）。
public static Object newProxyInstance (
ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h ) 获取代理对象的方法
- 返回值：该方法返回就是动态生成的代理对象
- 参数列表说明：
1. ClassLoader loader - 定义代理类的类加载器
2. Class<?>[] interfaces - 代理类要实现的接口列表，要求与被代理类的接口一样。
3. InvocationHandler h - 就是具体实现代理逻辑的接口
InvocationHandler接口
源码 ：
interface InvocationHandler{
public Object invoke(Object proxy, Method method, Object[] args); //代理逻辑
}
java.lang.reflect.InvocationHandler是代理对象的实际处理代理逻辑的接口，具体代理实现逻辑在其 invoke 方法中。所有代理对象调用的方法，执行是都会经过invoke。因此如果要对某个方法进行代理增强，就可以在这个invoke方法中进行定义。
方法说明如下：
public Object invoke(Object proxy, Method method, Object[] args);
1. 返回值：方法被代理后执行的结果。
2. 参数列表：
1. proxy - 就是代理对象
2. method - 代理对象调用的方法
3. args - 代理对象调用方法传入参数值的对象数组.
3）代码实践
将经纪人代理明星的案例使用动态代理实现
- 把父接口定义
- 定义被代理类：宝强
- 动态生成代理类
- 定义代理逻辑
package com.itheima.dynamicproxy_demo;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
// 测试类
/*
1 Proxy类 :
public static Object newProxyInstance (
ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h ) 获取代理对象的方法
- 返回值：该方法返回就是动态生成的代理对象
- 参数列表说明：
1. ClassLoader loader - 定义代理类的类加载器
2. Class<?>[] interfaces - 代理类要实现的接口列表，要求与被代理类的接口一样。
3. InvocationHandler h - 就是具体实现代理逻辑的接口
2 InvocationHandler接口
public Object invoke(Object proxy, Method method, Object[] args);
1. 返回值：方法被代理后执行的结果。
2. 参数列表：
1. proxy - 就是代理对象
2. method - 代理对象调用的方法
3. args - 代理对象调用方法传入参数值的对象数组.
*/
public class DynamicProxyDemo {
public static void main(String[] args) {
// Proxy.newProxyInstance(被代理角色的类加载器 , 被代理角色实现的所有接口 , 处理器);
// 被代理角色的类加载器
ClassLoader classLoader = BaoQiang.class.getClassLoader();
// 被代理角色实现的所有接口
Class<?>[] interfaces = BaoQiang.class.getInterfaces();
// 创建被代理角色对象
BaoQiang baoQiang = new BaoQiang();
// 代理角色 , 动态生成
Star songZhe = (Star) Proxy.newProxyInstance(classLoader, interfaces, new MyInvocationHandler(baoQiang));
// 代理角色调用liveShow方法
songZhe.liveShow(1000);
songZhe.sleep();
}
}
// 定义InvocationHandler接口的实现类
class MyInvocationHandler implements InvocationHandler {
private BaoQiang baoQiang;
public MyInvocationHandler(BaoQiang baoQiang) {
this.baoQiang = baoQiang;
}
// invoke什么时候会执行????
// 代理对象调用功能 , 就会触发invoke方法
// 此方法对被代理角色的功能做增强
// method : 代理对象调用功能就会触发invoke方法 , invoke方法中的method代表的就是调用的方法对象
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (method.getName().equals("liveShow")) {
// 代理角色对象调用liveShow方法 , 此位置会拦截
// 前增强
System.out.println("宋喆帮宝强拉了一个真人秀的活动,获取佣金" + (double) args[0] * 0.8 + "元");
Object result = method.invoke(baoQiang, (double) args[0] * 0.2);
// 后增强
System.out.println("宋喆帮宝强把赚的钱存了起来...");
return result;
} else if (method.getName().equals("sleep")) {
// 代理角色对象调用sleep方法 , 此位置会拦截
method.invoke(baoQiang);
} else {
// 除了liveShow和sleep方法 , 会执行else代码块中的内容
}
return null;
}
}
// 1 抽象角色
interface Star {
double liveShow(double money);
void sleep();
}
// 2 定义被代理角色(宝强)
class BaoQiang implements Star {
@Override
public double liveShow(double money) {
System.out.println("宝强参加了一个真人秀活动赚了" + money + "钱");
return money;
}
@Override
public void sleep() {
System.out.println("宝强累了 , 睡觉...");
}
}
动态代理调用流程：
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nfkpKqqO-1678111473047)(imgs/image-20210306173851168.png)]](https://i-blog.csdnimg.cn/blog_migrate/52a2a0d1ae1f61ed0cf0ffa880b80e82.png)
知识小结
-
什么是动态代理？
在代码执行前，没有代理类，代理类是在程序运行的时候动态生成
Proxy.newProxyInstance -
动态代理有什么好处？
动态代理可以为 “被代理对象” 的所有接口的所有方法做代理，动态代理可以在不改变方法源码的情况下，实现对方法功能的增强。
-
动态代理相关的API有哪些？
Proxy public static Object newProxyInstance(类加载器，接口列表，调用处理器) 类加载器 = 被代理对象.getClass().getClassLoader(); 接口列表 = 被代理对象.getClass().getInterfaces(); 调用处理器 = new InvocationHandler(){ 实现 invoke 方法 }; InvocationHandler public Object invoke(代理对象,方法对象,方法的实参类别) 该方法执行时机是，代理对象调用方法时触发执行 -
动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。
-
缺点 ：只能针对接口的实现类做代理对象，普通类是不能做代理对象的。
后面框架学习的时候会接触到CGLib（Code Genneration Library ）： 可以实现对类的代理
三、类加载器，反射
1.类加载器
1.1类加载器【理解】
-
作用
负责将.class文件（存储的物理文件）加载在到内存中
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s38bMEpp-1678111996737)(.\img\01_类加载器.png)]](https://i-blog.csdnimg.cn/blog_migrate/a1f2392400cda94192e95fb3bcad10ae.png)
1.2类加载的过程【理解】
-
类加载时机
- 创建类的实例（对象）
- 调用类的类方法
- 访问类或者接口的类变量，或者为该类变量赋值
- 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
- 初始化某个类的子类
- 直接使用java.exe命令来运行某个主类
-
类加载过程
-
加载
- 通过包名 + 类名，获取这个类，准备用流进行传输
- 在这个类加载到内存中
- 加载完毕创建一个class对象
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UMkte29v-1678111996738)(.\img\02_类加载过程加载.png)]](https://i-blog.csdnimg.cn/blog_migrate/98af2df00a6317ececdddf1bde011319.png)
-
链接
-
验证
确保Class文件字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身安全
(文件中的信息是否符合虚拟机规范有没有安全隐患)
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IK9kib5N-1678111996739)(.\img\03_类加载过程验证.png)]](https://i-blog.csdnimg.cn/blog_migrate/eee8cf929e64f115122dab67e81eda01.png)
-
准备
负责为类的类变量（被static修饰的变量）分配内存，并设置默认初始化值
(初始化静态变量)
-
解析
将类的二进制数据流中的符号引用替换为直接引用
(本类中如果用到了其他类，此时就需要找到对应的类)
-
-
-
初始化
根据程序员通过程序制定的主观计划去初始化类变量和其他资源
(静态变量赋值以及初始化其他资源)
-
小结
- 当一个类被使用的时候，才会加载到内存
- 类加载的过程: 加载、验证、准备、解析、初始化
1.3类加载的分类【理解】
-
分类
- Bootstrap class loader：虚拟机的内置类加载器，通常表示为null ，并且没有父null
- Platform class loader：平台类加载器,负责加载JDK中一些特殊的模块
- System class loader：系统类加载器,负责加载用户类路径上所指定的类库
-
类加载器的继承关系
- System的父加载器为Platform
- Platform的父加载器为Bootstrap
-
代码演示
public class ClassLoaderDemo1 { public static void main(String[] args) { //获取系统类加载器 ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader(); //获取系统类加载器的父加载器 --- 平台类加载器 ClassLoader classLoader1 = systemClassLoader.getParent(); //获取平台类加载器的父加载器 --- 启动类加载器 ClassLoader classLoader2 = classLoader1.getParent(); System.out.println("系统类加载器" + systemClassLoader); System.out.println("平台类加载器" + classLoader1); System.out.println("启动类加载器" + classLoader2); } }
1.4双亲委派模型【理解】
-
介绍
如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式
1.5ClassLoader 中的两个方法【应用】
-
方法介绍
方法名 说明 public static ClassLoader getSystemClassLoader() 获取系统类加载器 public InputStream getResourceAsStream(String name) 加载某一个资源文件 -
示例代码
public class ClassLoaderDemo2 { public static void main(String[] args) throws IOException { //static ClassLoader getSystemClassLoader() 获取系统类加载器 //InputStream getResourceAsStream(String name) 加载某一个资源文件 //获取系统类加载器 ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader(); //利用加载器去加载一个指定的文件 //参数：文件的路径（放在src的根目录下，默认去那里加载） //返回值：字节流。 InputStream is = systemClassLoader.getResourceAsStream("prop.properties"); Properties prop = new Properties(); prop.load(is); System.out.println(prop); is.close(); } }
2.反射
2.1反射的概述【理解】
-
反射机制
是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；
对于任意一个对象，都能够调用它的任意属性和方法；
这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。
2.2获取Class类对象的三种方式【应用】
-
三种方式分类
-
类名.class属性
-
对象名.getClass()方法
-
Class.forName(全类名)方法
-
-
示例代码
public class Student { private String name; private int age; public Student() { } public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public void study(){ System.out.println("学生在学习"); } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } } public class ReflectDemo1 { public static void main(String[] args) throws ClassNotFoundException { //1.Class类中的静态方法forName("全类名") //全类名:包名 + 类名 Class clazz = Class.forName("com.itheima.myreflect2.Student"); System.out.println(clazz); //2.通过class属性来获取 Class clazz2 = Student.class; System.out.println(clazz2); //3.利用对象的getClass方法来获取class对象 //getClass方法是定义在Object类中. Student s = new Student(); Class clazz3 = s.getClass(); System.out.println(clazz3); System.out.println(clazz == clazz2); System.out.println(clazz2 == clazz3); } }
2.3反射获取构造方法并使用【应用】
2.3.1Class类获取构造方法对象的方法
-
方法介绍
方法名 说明 Constructor<?>[] getConstructors() 返回所有公共构造方法对象的数组 Constructor<?>[] getDeclaredConstructors() 返回所有构造方法对象的数组 Constructor getConstructor(Class<?>… parameterTypes) 返回单个公共构造方法对象 Constructor getDeclaredConstructor(Class<?>… parameterTypes) 返回单个构造方法对象 -
示例代码
public class Student { private String name; private int age; //私有的有参构造方法 private Student(String name) { System.out.println("name的值为:" + name); System.out.println("private...Student...有参构造方法"); } //公共的无参构造方法 public Student() { System.out.println("public...Student...无参构造方法"); } //公共的有参构造方法 public Student(String name, int age) { System.out.println("name的值为:" + name + "age的值为:" + age); System.out.println("public...Student...有参构造方法"); } } public class ReflectDemo1 { public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException { //method1(); //method2(); //method3(); //method4(); } private static void method4() throws ClassNotFoundException, NoSuchMethodException { // Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)： // 返回单个构造方法对象 //1.获取Class对象 Class clazz = Class.forName("com.itheima.myreflect3.Student"); Constructor constructor = clazz.getDeclaredConstructor(String.class); System.out.println(constructor); } private static void method3() throws ClassNotFoundException, NoSuchMethodException { // Constructor<T> getConstructor(Class<?>... parameterTypes)： // 返回单个公共构造方法对象 //1.获取Class对象 Class clazz = Class.forName("com.itheima.myreflect3.Student"); //小括号中,一定要跟构造方法的形参保持一致. Constructor constructor1 = clazz.getConstructor(); System.out.println(constructor1); Constructor constructor2 = clazz.getConstructor(String.class, int.class); System.out.println(constructor2); //因为Student类中,没有只有一个int的构造,所以这里会报错. Constructor constructor3 = clazz.getConstructor(int.class); System.out.println(constructor3); } private static void method2() throws ClassNotFoundException { // Constructor<?>[] getDeclaredConstructors()： // 返回所有构造方法对象的数组 //1.获取Class对象 Class clazz = Class.forName("com.itheima.myreflect3.Student"); Constructor[] constructors = clazz.getDeclaredConstructors(); for (Constructor constructor : constructors) { System.out.println(constructor); } } private static void method1() throws ClassNotFoundException { // Constructor<?>[] getConstructors()： // 返回所有公共构造方法对象的数组 //1.获取Class对象 Class clazz = Class.forName("com.itheima.myreflect3.Student"); Constructor[] constructors = clazz.getConstructors(); for (Constructor constructor : constructors) { System.out.println(constructor); } } }
2.3.2Constructor类用于创建对象的方法
-
方法介绍
方法名 说明 T newInstance(Object…initargs) 根据指定的构造方法创建对象 setAccessible(boolean flag) 设置为true,表示取消访问检查 -
示例代码
// Student类同上一个示例,这里就不在重复提供了 public class ReflectDemo2 { public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { //T newInstance(Object... initargs)：根据指定的构造方法创建对象 //method1(); //method2(); //method3(); //method4(); } private static void method4() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException { //获取一个私有的构造方法并创建对象 //1.获取class对象 Class clazz = Class.forName("com.itheima.myreflect3.Student"); //2.获取一个私有化的构造方法. Constructor constructor = clazz.getDeclaredConstructor(String.class); //被private修饰的成员,不能直接使用的 //如果用反射强行获取并使用,需要临时取消访问检查 constructor.setAccessible(true); //3.直接创建对象 Student student = (Student) constructor.newInstance("zhangsan"); System.out.println(student); } private static void method3() throws ClassNotFoundException, InstantiationException, IllegalAccessException { //简写格式 //1.获取class对象 Class clazz = Class.forName("com.itheima.myreflect3.Student"); //2.在Class类中,有一个newInstance方法,可以利用空参直接创建一个对象 Student student = (Student) clazz.newInstance();//这个方法现在已经过时了,了解一下 System.out.println(student); } private static void method2() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException { //1.获取class对象 Class clazz = Class.forName("com.itheima.myreflect3.Student"); //2.获取构造方法对象 Constructor constructor = clazz.getConstructor(); //3.利用空参来创建Student的对象 Student student = (Student) constructor.newInstance(); System.out.println(student); } private static void method1() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException { //1.获取class对象 Class clazz = Class.forName("com.itheima.myreflect3.Student"); //2.获取构造方法对象 Constructor constructor = clazz.getConstructor(String.class, int.class); //3.利用newInstance创建Student的对象 Student student = (Student) constructor.newInstance("zhangsan", 23); System.out.println(student); } }
2.3.3小结
-
获取class对象
三种方式: Class.forName(“全类名”), 类名.class, 对象名.getClass()
-
获取里面的构造方法对象
getConstructor (Class<?>... parameterTypes) getDeclaredConstructor (Class<?>… parameterTypes)
-
如果是public的，直接创建对象
newInstance(Object… initargs)
-
如果是非public的，需要临时取消检查，然后再创建对象
setAccessible(boolean) 暴力反射
2.4反射获取成员变量并使用【应用】
2.4.1Class类获取成员变量对象的方法
-
方法分类
方法名 说明 Field[] getFields() 返回所有公共成员变量对象的数组 Field[] getDeclaredFields() 返回所有成员变量对象的数组 Field getField(String name) 返回单个公共成员变量对象 Field getDeclaredField(String name) 返回单个成员变量对象 -
示例代码
public class Student { public String name; public int age; public String gender; private int money = 300; @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + ", gender='" + gender + '\'' + ", money=" + money + '}'; } } public class ReflectDemo1 { public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException { // method1(); //method2(); //method3(); //method4(); } private static void method4() throws ClassNotFoundException, NoSuchFieldException { // Field getDeclaredField(String name)：返回单个成员变量对象 //1.获取class对象 Class clazz = Class.forName("com.itheima.myreflect4.Student"); //2.获取money成员变量 Field field = clazz.getDeclaredField("money"); //3.打印一下 System.out.println(field); } private static void method3() throws ClassNotFoundException, NoSuchFieldException { // Field getField(String name)：返回单个公共成员变量对象 //想要获取的成员变量必须是真实存在的 //且必须是public修饰的. //1.获取class对象 Class clazz = Class.forName("com.itheima.myreflect4.Student"); //2.获取name这个成员变量 //Field field = clazz.getField("name"); //Field field = clazz.getField("name1"); Field field = clazz.getField("money"); //3.打印一下 System.out.println(field); } private static void method2() throws ClassNotFoundException { // Field[] getDeclaredFields()：返回所有成员变量对象的数组 //1.获取class对象 Class clazz = Class.forName("com.itheima.myreflect4.Student"); //2.获取所有的Field对象 Field[] fields = clazz.getDeclaredFields(); //3.遍历 for (Field field : fields) { System.out.println(field); } } private static void method1() throws ClassNotFoundException { // Field[] getFields()：返回所有公共成员变量对象的数组 //1.获取class对象 Class clazz = Class.forName("com.itheima.myreflect4.Student"); //2.获取Field对象. Field[] fields = clazz.getFields(); //3.遍历 for (Field field : fields) { System.out.println(field); } } }
2.4.2Field类用于给成员变量赋值的方法
-
方法介绍
方法名 说明 void set(Object obj, Object value) 赋值 Object get(Object obj) 获取值 -
示例代码
// Student类同上一个示例,这里就不在重复提供了 public class ReflectDemo2 { public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException, InstantiationException { // Object get(Object obj) 返回由该 Field表示的字段在指定对象上的值。 //method1(); //method2(); } private static void method2() throws ClassNotFoundException, NoSuchFieldException, InstantiationException, IllegalAccessException { //1.获取class对象 Class clazz = Class.forName("com.itheima.myreflect4.Student"); //2.获取成员变量Field的对象 Field field = clazz.getDeclaredField("money"); //3.取消一下访问检查 field.setAccessible(true); //4.调用get方法来获取值 //4.1创建一个对象 Student student = (Student) clazz.newInstance(); //4.2获取指定对象的money的值 Object o = field.get(student); //5.打印一下 System.out.println(o); } private static void method1() throws ClassNotFoundException, NoSuchFieldException, InstantiationException, IllegalAccessException { // void set(Object obj, Object value)：给obj对象的成员变量赋值为value //1.获取class对象 Class clazz = Class.forName("com.itheima.myreflect4.Student"); //2.获取name这个Field对象 Field field = clazz.getField("name"); //3.利用set方法进行赋值. //3.1先创建一个Student对象 Student student = (Student) clazz.newInstance(); //3.2有了对象才可以给指定对象进行赋值 field.set(student,"zhangsan"); System.out.println(student); } }
2.5反射获取成员方法并使用【应用】
2.5.1Class类获取成员方法对象的方法
-
方法分类
方法名 说明 Method[] getMethods() 返回所有公共成员方法对象的数组，包括继承的 Method[] getDeclaredMethods() 返回所有成员方法对象的数组，不包括继承的 Method getMethod(String name, Class<?>… parameterTypes) 返回单个公共成员方法对象 Method getDeclaredMethod(String name, Class<?>… parameterTypes) 返回单个成员方法对象 -
示例代码
public class Student { //私有的，无参无返回值 private void show() { System.out.println("私有的show方法，无参无返回值"); } //公共的，无参无返回值 public void function1() { System.out.println("function1方法，无参无返回值"); } //公共的，有参无返回值 public void function2(String name) { System.out.println("function2方法，有参无返回值,参数为" + name); } //公共的，无参有返回值 public String function3() { System.out.println("function3方法，无参有返回值"); return "aaa"; } //公共的，有参有返回值 public String function4(String name) { System.out.println("function4方法，有参有返回值,参数为" + name); return "aaa"; } } public class ReflectDemo1 { public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException { //method1(); //method2(); //method3(); //method4(); //method5(); } private static void method5() throws ClassNotFoundException, NoSuchMethodException { // Method getDeclaredMethod(String name, Class<?>... parameterTypes)： // 返回单个成员方法对象 //1.获取class对象 Class clazz = Class.forName("com.itheima.myreflect5.Student"); //2.获取一个成员方法show Method method = clazz.getDeclaredMethod("show"); //3.打印一下 System.out.println(method); } private static void method4() throws ClassNotFoundException, NoSuchMethodException { //1.获取class对象 Class clazz = Class.forName("com.itheima.myreflect5.Student"); //2.获取一个有形参的方法function2 Method method = clazz.getMethod("function2", String.class); //3.打印一下 System.out.println(method); } private static void method3() throws ClassNotFoundException, NoSuchMethodException { // Method getMethod(String name, Class<?>... parameterTypes) ： // 返回单个公共成员方法对象 //1.获取class对象 Class clazz = Class.forName("com.itheima.myreflect5.Student"); //2.获取成员方法function1 Method method1 = clazz.getMethod("function1"); //3.打印一下 System.out.println(method1); } private static void method2() throws ClassNotFoundException { // Method[] getDeclaredMethods()： // 返回所有成员方法对象的数组，不包括继承的 //1.获取class对象 Class clazz = Class.forName("com.itheima.myreflect5.Student"); //2.获取Method对象 Method[] methods = clazz.getDeclaredMethods(); //3.遍历一下数组 for (Method method : methods) { System.out.println(method); } } private static void method1() throws ClassNotFoundException { // Method[] getMethods()：返回所有公共成员方法对象的数组，包括继承的 //1.获取class对象 Class clazz = Class.forName("com.itheima.myreflect5.Student"); //2.获取成员方法对象 Method[] methods = clazz.getMethods(); //3.遍历 for (Method method : methods) { System.out.println(method); } } }
2.5.2Method类用于执行方法的方法
-
方法介绍
方法名 说明 Object invoke(Object obj, Object… args) 运行方法 参数一: 用obj对象调用该方法
参数二: 调用方法的传递的参数(如果没有就不写)
返回值: 方法的返回值(如果没有就不写)
-
示例代码
public class ReflectDemo2 { public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException { // Object invoke(Object obj, Object... args)：运行方法 // 参数一：用obj对象调用该方法 // 参数二：调用方法的传递的参数（如果没有就不写） // 返回值：方法的返回值（如果没有就不写） //1.获取class对象 Class clazz = Class.forName("com.itheima.myreflect5.Student"); //2.获取里面的Method对象 function4 Method method = clazz.getMethod("function4", String.class); //3.运行function4方法就可以了 //3.1创建一个Student对象,当做方法的调用者 Student student = (Student) clazz.newInstance(); //3.2运行方法 Object result = method.invoke(student, "zhangsan"); //4.打印一下返回值 System.out.println(result); } }
四、xml,注解，单元测试
1.xml
1.1概述【理解】
-
万维网联盟(W3C)
万维网联盟(W3C)创建于1994年，又称W3C理事会。1994年10月在麻省理工学院计算机科学实验室成立。
建立者： Tim Berners-Lee (蒂姆·伯纳斯·李)。
是Web技术领域最具权威和影响力的国际中立性技术标准机构。
到目前为止，W3C已发布了200多项影响深远的Web技术标准及实施指南，-
如广为业界采用的超文本标记语言HTML（标准通用标记语言下的一个应用）、
-
可扩展标记语言XML（标准通用标记语言下的一个子集）
-
以及帮助残障人士有效获得Web信息的无障碍指南（WCAG）等
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VCoZYFvS-1678112385345)(.\img\01_w3c概述.png)]](https://i-blog.csdnimg.cn/blog_migrate/db2198cc74960cdf6903030227cd0762.png)
-
-
xml概述
XML的全称为(EXtensible Markup Language)，是一种可扩展的标记语言
标记语言: 通过标签来描述数据的一门语言(标签有时我们也将其称之为元素)
可扩展：标签的名字是可以自定义的,XML文件是由很多标签组成的,而标签名是可以自定义的 -
作用
- 用于进行存储数据和传输数据
- 作为软件的配置文件
-
作为配置文件的优势
- 可读性好
- 可维护性高
1.2标签的规则【应用】
-
标签由一对尖括号和合法标识符组成
<student> -
标签必须成对出现
<student> </student> 前边的是开始标签，后边的是结束标签 -
特殊的标签可以不成对,但是必须有结束标记
<address/> -
标签中可以定义属性,属性和标签名空格隔开,属性值必须用引号引起来
<student id="1"> </student> -
标签需要正确的嵌套
这是正确的: <student id="1"> <name>张三</name> </student> 这是错误的: <student id="1"><name>张三</student></name>
1.3语法规则【应用】
-
语法规则
-
XML文件的后缀名为：xml
-
文档声明必须是第一行第一列
<?xml version="1.0" encoding="UTF-8" standalone="yes”?>version：该属性是必须存在的
encoding：该属性不是必须的 打开当前xml文件的时候应该是使用什么字符编码表(一般取值都是UTF-8)
standalone: 该属性不是必须的，描述XML文件是否依赖其他的xml文件，取值为yes/no
-
必须存在一个根标签，有且只能有一个
-
XML文件中可以定义注释信息
-
XML文件中可以存在以下特殊字符
< < 小于 > > 大于 & & 和号 ' ' 单引号 " " 引号 -
XML文件中可以存在CDATA区
<![CDATA[ …内容… ]]>
-
-
示例代码
<?xml version="1.0" encoding="UTF-8" ?> <!--注释的内容--> <!--本xml文件用来描述多个学生信息--> <students> <!--第一个学生信息--> <student id="1"> <name>张三</name> <age>23</age> <info>学生< >>>>>>>>>>>的信息</info> <message> <![CDATA[内容 <<<<<< >>>>>> ]]]></message> </student> <!--第二个学生信息--> <student id="2"> <name>李四</name> <age>24</age> </student> </students>
1.4xml解析【应用】
-
概述
xml解析就是从xml中获取到数据
-
常见的解析思想
DOM(Document Object Model)文档对象模型:就是把文档的各个组成部分看做成对应的对象。
会把xml文件全部加载到内存,在内存中形成一个树形结构,再获取对应的值![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OAABnE6K-1678112385347)(.\img\02_dom解析概述.png)]](https://i-blog.csdnimg.cn/blog_migrate/38ed71269142055c27049d08c02d6dd2.png)
-
常见的解析工具
- JAXP: SUN公司提供的一套XML的解析的API
- JDOM: 开源组织提供了一套XML的解析的API-jdom
- DOM4J: 开源组织提供了一套XML的解析的API-dom4j,全称：Dom For Java
- pull: 主要应用在Android手机端解析XML
-
解析的准备工作
-
我们可以通过网站：https://dom4j.github.io/ 去下载dom4j
今天的资料中已经提供,我们不用再单独下载了,直接使用即可
-
将提供好的dom4j-1.6.1.zip解压,找到里面的dom4j-1.6.1.jar
-
在idea中当前模块下新建一个libs文件夹,将jar包复制到文件夹中
-
选中jar包 -> 右键 -> 选择add as library即可
-
-
需求
- 解析提供好的xml文件
- 将解析到的数据封装到学生对象中
- 并将学生对象存储到ArrayList集合中
- 遍历集合
-
代码实现
<?xml version="1.0" encoding="UTF-8" ?> <!--注释的内容--> <!--本xml文件用来描述多个学生信息--> <students> <!--第一个学生信息--> <student id="1"> <name>张三</name> <age>23</age> </student> <!--第二个学生信息--> <student id="2"> <name>李四</name> <age>24</age> </student> </students> // 上边是已经准备好的student.xml文件 public class Student { private String id; private String name; private int age; public Student() { } public Student(String id, String name, int age) { this.id = id; this.name = name; this.age = age; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Student{" + "id='" + id + '\'' + ", name='" + name + '\'' + ", age=" + age + '}'; } } /** * 利用dom4j解析xml文件 */ public class XmlParse { public static void main(String[] args) throws DocumentException { //1.获取一个解析器对象 SAXReader saxReader = new SAXReader(); //2.利用解析器把xml文件加载到内存中,并返回一个文档对象 Document document = saxReader.read(new File("myxml\\xml\\student.xml")); //3.获取到根标签 Element rootElement = document.getRootElement(); //4.通过根标签来获取student标签 //elements():可以获取调用者所有的子标签.会把这些子标签放到一个集合中返回. //elements("标签名"):可以获取调用者所有的指定的子标签,会把这些子标签放到一个集合中并返回 //List list = rootElement.elements(); List<Element> studentElements = rootElement.elements("student"); //System.out.println(list.size()); //用来装学生对象 ArrayList<Student> list = new ArrayList<>(); //5.遍历集合,得到每一个student标签 for (Element element : studentElements) { //element依次表示每一个student标签 //获取id这个属性 Attribute attribute = element.attribute("id"); //获取id的属性值 String id = attribute.getValue(); //获取name标签 //element("标签名"):获取调用者指定的子标签 Element nameElement = element.element("name"); //获取这个标签的标签体内容 String name = nameElement.getText(); //获取age标签 Element ageElement = element.element("age"); //获取age标签的标签体内容 String age = ageElement.getText(); // System.out.println(id); // System.out.println(name); // System.out.println(age); Student s = new Student(id,name,Integer.parseInt(age)); list.add(s); } //遍历操作 for (Student student : list) { System.out.println(student); } } }
1.5DTD约束【理解】
-
什么是约束
用来限定xml文件中可使用的标签以及属性
-
约束的分类
- DTD
- schema
-
编写DTD约束
-
步骤
-
创建一个文件，这个文件的后缀名为.dtd
-
看xml文件中使用了哪些元素
<!ELEMENT> 可以定义元素 -
判断元素是简单元素还是复杂元素
简单元素：没有子元素。
复杂元素：有子元素的元素；
-
-
代码实现
<!ELEMENT persons (person)> <!ELEMENT person (name,age)> <!ELEMENT name (#PCDATA)> <!ELEMENT age (#PCDATA)>
-
-
引入DTD约束
-
引入DTD约束的三种方法
-
引入本地dtd
-
在xml文件内部引入
-
引入网络dtd
-
-
代码实现
-
引入本地DTD约束
// 这是persondtd.dtd文件中的内容,已经提前写好 <!ELEMENT persons (person)> <!ELEMENT person (name,age)> <!ELEMENT name (#PCDATA)> <!ELEMENT age (#PCDATA)> // 在person1.xml文件中引入persondtd.dtd约束 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE persons SYSTEM 'persondtd.dtd'> <persons> <person> <name>张三</name> <age>23</age> </person> </persons> -
在xml文件内部引入
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE persons [ <!ELEMENT persons (person)> <!ELEMENT person (name,age)> <!ELEMENT name (#PCDATA)> <!ELEMENT age (#PCDATA)> ]> <persons> <person> <name>张三</name> <age>23</age> </person> </persons> -
引入网络dtd
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE persons PUBLIC "dtd文件的名称" "dtd文档的URL"> <persons> <person> <name>张三</name> <age>23</age> </person> </persons>
-
-
-
DTD语法
-
定义元素
定义一个元素的格式为：<!ELEMENT 元素名 元素类型>
简单元素： EMPTY: 表示标签体为空
ANY: 表示标签体可以为空也可以不为空
PCDATA: 表示该元素的内容部分为字符串
复杂元素：
直接写子元素名称. 多个子元素可以使用",“或者”|"隔开；
","表示定义子元素的顺序 ; “|”: 表示子元素只能出现任意一个
"?"零次或一次, "+"一次或多次, "*"零次或多次;如果不写则表示出现一次![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nkqBvqbp-1678112385348)(.\img\03_DTD语法定义元素.png)]](https://i-blog.csdnimg.cn/blog_migrate/7734b57779b0ec70c315d55221699234.png)
-
定义属性
格式
定义一个属性的格式为：<!ATTLIST 元素名称 属性名称 属性的类型 属性的约束>
属性的类型：
CDATA类型：普通的字符串属性的约束:
// #REQUIRED： 必须的
// #IMPLIED： 属性不是必需的
// #FIXED value：属性值是固定的 -
代码实现
<!ELEMENT persons (person+)> <!ELEMENT person (name,age)> <!ELEMENT name (#PCDATA)> <!ELEMENT age (#PCDATA)> <!ATTLIST person id CDATA #REQUIRED> <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE persons SYSTEM 'persondtd.dtd'> <persons> <person id="001"> <name>张三</name> <age>23</age> </person> <person id = "002"> <name>张三</name> <age>23</age> </person> </persons> ```
-
1.6schema约束【理解】
-
schema和dtd的区别
- schema约束文件也是一个xml文件，符合xml的语法，这个文件的后缀名.xsd
- 一个xml中可以引用多个schema约束文件，多个schema使用名称空间区分（名称空间类似于java包名）
- dtd里面元素类型的取值比较单一常见的是PCDATA类型，但是在schema里面可以支持很多个数据类型
- schema 语法更加的复杂
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7LLwOCDA-1678112385350)(.\img\04_schema约束介绍.png)]](https://i-blog.csdnimg.cn/blog_migrate/8a8b6dc8b32a230dbdbb6748f546c11d.png)
-
编写schema约束
-
步骤
1，创建一个文件，这个文件的后缀名为.xsd。
2，定义文档声明
3，schema文件的根标签为：
4，在中定义属性：
xmlns=http://www.w3.org/2001/XMLSchema
5，在中定义属性 ：
targetNamespace =唯一的url地址，指定当前这个schema文件的名称空间。
6，在中定义属性 ：
elementFormDefault="qualified“，表示当前schema文件是一个质量良好的文件。
7，通过element定义元素
8，判断当前元素是简单元素还是复杂元素![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Rr8axScd-1678112385355)(.\img\05_schema约束编写.png)]](https://i-blog.csdnimg.cn/blog_migrate/12f74d61cb2e6a8451d6e533970200b4.png)
-
代码实现
<?xml version="1.0" encoding="UTF-8" ?> <schema xmlns="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.itheima.cn/javase" elementFormDefault="qualified" > <!--定义persons复杂元素--> <element name="persons"> <complexType> <sequence> <!--定义person复杂元素--> <element name = "person"> <complexType> <sequence> <!--定义name和age简单元素--> <element name = "name" type = "string"></element> <element name = "age" type = "string"></element> </sequence> </complexType> </element> </sequence> </complexType> </element> </schema>
-
-
引入schema约束
-
步骤
1，在根标签上定义属性xmlns=“http://www.w3.org/2001/XMLSchema-instance”
2，通过xmlns引入约束文件的名称空间
3，给某一个xmlns属性添加一个标识，用于区分不同的名称空间
格式为: xmlns:标识=“名称空间地址” ,标识可以是任意的，但是一般取值都是xsi
4，通过xsi:schemaLocation指定名称空间所对应的约束文件路径
格式为：xsi:schemaLocation = "名称空间url 文件路径“ -
代码实现
<?xml version="1.0" encoding="UTF-8" ?> <persons xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.itheima.cn/javase" xsi:schemaLocation="http://www.itheima.cn/javase person.xsd" > <person> <name>张三</name> <age>23</age> </person> </persons> ```
-
-
schema约束定义属性
-
代码示例
<?xml version="1.0" encoding="UTF-8" ?> <schema xmlns="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.itheima.cn/javase" elementFormDefault="qualified" > <!--定义persons复杂元素--> <element name="persons"> <complexType> <sequence> <!--定义person复杂元素--> <element name = "person"> <complexType> <sequence> <!--定义name和age简单元素--> <element name = "name" type = "string"></element> <element name = "age" type = "string"></element> </sequence> <!--定义属性，required( 必须的)/optional( 可选的)--> <attribute name="id" type="string" use="required"></attribute> </complexType> </element> </sequence> </complexType> </element> </schema> <?xml version="1.0" encoding="UTF-8" ?> <persons xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.itheima.cn/javase" xsi:schemaLocation="http://www.itheima.cn/javase person.xsd" > <person id="001"> <name>张三</name> <age>23</age> </person> </persons> ```
-
2.注解
2.1概述【理解】
-
概述
对我们的程序进行标注和解释
-
注解和注释的区别
- 注释: 给程序员看的
- 注解: 给编译器看的
-
使用注解进行配置配置的优势
代码更加简洁,方便
2.2自定义注解【理解】
-
格式
public @interface 注解名称 {
public 属性类型 属性名() default 默认值 ;
}
-
属性类型
- 基本数据类型
- String
- Class
- 注解
- 枚举
- 以上类型的一维数组
-
代码演示
public @interface Anno2 { } public enum Season { SPRING,SUMMER,AUTUMN,WINTER; } public @interface Anno1 { //定义一个基本类型的属性 int a () default 23; //定义一个String类型的属性 public String name() default "itheima"; //定义一个Class类型的属性 public Class clazz() default Anno2.class; //定义一个注解类型的属性 public Anno2 anno() default @Anno2; //定义一个枚举类型的属性 public Season season() default Season.SPRING; //以上类型的一维数组 //int数组 public int[] arr() default {1,2,3,4,5}; //枚举数组 public Season[] seasons() default {Season.SPRING,Season.SUMMER}; //value。后期我们在使用注解的时候，如果我们只需要给注解的value属性赋值。 //那么value就可以省略 public String value(); } //在使用注解的时候如果注解里面的属性没有指定默认值。 //那么我们就需要手动给出注解属性的设置值。 //@Anno1(name = "itheima") @Anno1("abc") public class AnnoDemo { } -
注意
如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可
-
自定义注解案例
-
需求
自定义一个注解@Test,用于指定类的方法上,如果某一个类的方法上使用了该注解,就执行该方法
-
实现步骤
- 自定义一个注解Test,并在类中的某几个方法上加上注解
- 在测试类中,获取注解所在的类的Class对象
- 获取类中所有的方法对象
- 遍历每一个方法对象,判断是否有对应的注解
-
代码实现
//表示Test这个注解的存活时间 @Retention(value = RetentionPolicy.RUNTIME) public @interface Test { } public class UseTest { //没有使用Test注解 public void show(){ System.out.println("UseTest....show...."); } //使用Test注解 @Test public void method(){ System.out.println("UseTest....method...."); } //没有使用Test注解 @Test public void function(){ System.out.println("UseTest....function...."); } } public class AnnoDemo { public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, InvocationTargetException { //1.通过反射获取UseTest类的字节码文件对象 Class clazz = Class.forName("com.itheima.myanno3.UseTest"); //创建对象 UseTest useTest = (UseTest) clazz.newInstance(); //2.通过反射获取这个类里面所有的方法对象 Method[] methods = clazz.getDeclaredMethods(); //3.遍历数组，得到每一个方法对象 for (Method method : methods) { //method依次表示每一个方法对象。 //isAnnotationPresent(Class<? extends Annotation> annotationClass) //判断当前方法上是否有指定的注解。 //参数：注解的字节码文件对象 //返回值：布尔结果。 true 存在 false 不存在 if(method.isAnnotationPresent(Test.class)){ method.invoke(useTest); } } } }
-
2.3元注解【理解】
-
概述
元注解就是描述注解的注解
-
元注解介绍
元注解名 说明 @Target 指定了注解能在哪里使用 @Retention 可以理解为保留时间(生命周期) @Inherited 表示修饰的自定义注解可以被子类继承 @Documented 表示该自定义注解，会出现在API文档里面。 -
示例代码
@Target({ElementType.FIELD,ElementType.TYPE,ElementType.METHOD}) //指定注解使用的位置（成员变量，类，方法） @Retention(RetentionPolicy.RUNTIME) //指定该注解的存活时间 //@Inherited //指定该注解可以被继承 public @interface Anno { } @Anno public class Person { } public class Student extends Person { public void show(){ System.out.println("student.......show.........."); } } public class StudentDemo { public static void main(String[] args) throws ClassNotFoundException { //获取到Student类的字节码文件对象 Class clazz = Class.forName("com.itheima.myanno4.Student"); //获取注解。 boolean result = clazz.isAnnotationPresent(Anno.class); System.out.println(result); } }
3.单元测试
3.1概述【理解】
JUnit是一个 Java 编程语言的单元测试工具。JUnit 是一个非常重要的测试工具
3.2特点【理解】
- JUnit是一个开放源代码的测试工具。
- 提供注解来识别测试方法。
- JUnit测试可以让你编写代码更快，并能提高质量。
- JUnit优雅简洁。没那么复杂，花费时间较少。
- JUnit在一个条中显示进度。如果运行良好则是绿色；如果运行失败，则变成红色。
3.3使用步骤【应用】
-
使用步骤
- 将junit的jar包导入到工程中 junit-4.9.jar
- 编写测试方法该测试方法必须是公共的无参数无返回值的非静态方法
- 在测试方法上使用@Test注解标注该方法是一个测试方法
- 选中测试方法右键通过junit运行该方法
-
代码示例
public class JunitDemo1 { @Test public void add() { System.out.println(2 / 0); int a = 10; int b = 20; int sum = a + b; System.out.println(sum); } }
3.4相关注解【应用】
-
注解说明
注解 含义 @Test 表示测试该方法 @Before 在测试的方法前运行 @After 在测试的方法后运行 -
代码示例
public class JunitDemo2 { @Before public void before() { // 在执行测试代码之前执行，一般用于初始化操作 System.out.println("before"); } @Test public void test() { // 要执行的测试代码 System.out.println("test"); } @After public void after() { // 在执行测试代码之后执行，一般用于释放资源 System.out.println("after"); } }
597
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
