文章目录
-
- 单元测试
-
- 什么是单元测试
- [咱们之前是如何进行单元测试的？ 有啥问题 ？](#咱们之前是如何进行单元测试的？ 有啥问题 ？)
- 现在使用方法进行测试
- 优点
- Junit单元测试的使用步骤
- 删除不需要的jar包
- 总结
- 反射
- 注解
- 动态代理(设计模式)
这些是源码、框架、架构师层面的技术
单元测试
什么是单元测试
就是针对最小的功能单元:方法，编写测试代码对其进行正确性测试。也就是测试 类中方法的正确性的。
咱们之前是如何进行单元测试的？ 有啥问题 ？
- 只能在main方法编写测试代码，去调用其他方法进行测试。
- 无法实现自动化测试，一个方法测试失败，可能影响其他方法的测试。(报错就无法继续进行了)
- 无法得到测试的报告，需要程序员自己去观察测试是否成功。(一个一个写main方法进行测试很麻烦)
现在使用方法进行测试
可以用来对方法进行测试，它是第三方公司开源出来的（很多开发工具已经集成了Junit框架，比如IDEA）
优点
- 可以灵活的编写测试代码，可以针对某个方法执行测试，也支持一键完成对全部方法的自动化测试，且各自独立。
- 不需要程序员去分析测试的结果，会自动生成测试报告出来。如果测试良好则是绿色；如果测试失败，则是红色。
- 单元测试中的某个方法测试失败了，不会影响其他测试方法的测试。
Junit单元测试的使用步骤
需求
- 某个系统，有多个业务方法，请使用Junit单元测试框架，编写测试代码，完成对这些方法的正确性测试。
具体步骤
- 将Junit框架的jar包导入到项目中（注意：IDEA集成了Junit框架，不需要我们自己手工导入了）
- 为需要测试的业务类，定义对应的测试类，并为每个业务方法，编写对应的测试方法（必须：公共、无参、无返回值）
- 测试方法上必须声明@Test注解，然后在测试方法中，编写代码调用被测试的业务方法进行测试；
- 开始测试：选中测试方法，右键选择"JUnit运行" ，如果测试通过则是绿色；如果测试失败，则是红色
业务
java
// StringUtil.java
/**
* 字符串工具类
*/
public class StringUtil {
public static void printNumber(String name){
if(name == null){
System.out.println("参数为null！请注意");
return;
}
System.out.println("名字长度是：" + name.length());
}
/**
* 求字符串的最大索引
*/
public static int getMaxIndex(String data){
if(data == null || "".equals(data)) {
return -1;
}
return data.length() - 1;
}
}测试
java
// StringUtilTest.java
import org.junit.Assert;
import org.junit.Test;
// 测试类：junit单元测试框架，对业务类中的业务方法进行正确性测试。
public class StringUtilTest {
// 测试方法：必须是公开public，无参，无返回值。
// 测试方法必须加上@Test注解（Junit框架的核心步骤）
@Test
public void testPrinNumber() {
// 测试步骤：
StringUtil.printNumber("张三abc"); // 5
// 测试用例
StringUtil.printNumber("");
StringUtil.printNumber(null);
}
@Test
public void testGetMaxIndex() {
// 测试步骤：
int index = StringUtil.getMaxIndex("abcdefg"); // 6
// 测试用例
int index2 = StringUtil.getMaxIndex("");
int index3 = StringUtil.getMaxIndex(null);
System.out.println(index);
System.out.println(index2);
System.out.println(index3);
// 做断言：断言结果是否与预期结果一致
// assertEquals("手写错误提示",预期结果，实际结果);
Assert.assertEquals("本轮测试失败，业务获取的最大索引有问题！请检查",6, index);
Assert.assertEquals("本轮测试失败，业务获取的最大索引有问题！请检查",-1, index2);
Assert.assertEquals("本轮测试失败，业务获取的最大索引有问题！请检查",-1, index3);
}
}
删除不需要的jar包
总结
1 Junit单元测试是做什么的？
- 测试类中方法的正确性的。
2 Junit单元测试的优点是什么？
- JUnit可以选择执行哪些测试方法，可以一键执行全部测试方法的测试。
- JUnit可以生测试报告，如果测试良好则是绿色；如果测试失败，则是红色。
- 单元测试中的某个方法测试失败了，不会影响其他测试方法的测试。
3 JUnit单元测试的实现过程是什么样的？
- 必须导入Junit框架的jar包。
- 定义的测试方法必须是无参数无返回值，且公开的方法。
- 测试方法使用@Test注解标记。
4 JUnit测试某个方法，测试全部方法怎么处理？成功的标志是什么
- 测试某个方法直接右键该方法启动测试。
- 测试全部方法，可以选择类或者模块启动。
- 红色失败，绿色通过。
反射
认识反射、获取类
什么是反射
反射就是：加载类，并允许以编程的方式解剖类中的各种成分（成员变量、方法、构造器等）。
比如idea中当你.一个对象为什么会有提示，这就是用了反射。反射可以解剖类的所有成员变量和方法。
反射具体学什么？
学习获取类的信息、操作它们
1、反射第一步：加载类，获取类的字节码：Class对象
2、获取类的构造器：Constructor对象
3、获取类的成员变量：Field对象
4、获取类的成员方法：Method对象
全部认识完后，再看反射的应用场景
反射第一步：或者Class对象
1、反射第一步：加载类，获取类的Class对象
获取Class对象的三种方式
- Class c1 = 类名.class
- 调用Class提供方法：public static Class forName(String package)；
- Object提供的方法： public Class getClass()； Class c3 = 对象.getClass();
java
public class ReflectDemo1 {
public static void main(String[] args) throws Exception {
// 目标：掌握反射第一步操作：或者类的Class对象。（获取类本身）。
// 1、获取类本身：类.class
Class c1 = Student.class;
System.out.println(c1);// class com.itheima.demo2reflect.Student
// 2、获取类本身：Class.forName("类的全类名")
Class c2 = Class.forName("com.itheima.demo2reflect.Student");
System.out.println(c2);// class com.itheima.demo2reflect.Student
// 3、获取类本身：对象.getClass()
Student s = new Student();
Class c3 = s.getClass();
System.out.println(c3);// class com.itheima.demo2reflect.Student
System.out.println(c1 == c2); // true
System.out.println(c2 == c3); // true
}
}
// student类
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
private String name;
private int age;
private String hobby;
}获取类中的成分、并对其进行操作
获取类中构造器
Class提供了从类中获取构造器的方法。
| 方法 | 说明 |
|---|---|
| Constructor<?>[] getConstructors() | 获取全部构造器（只能获取public修饰的） |
| Constructor<?>[] getDeclaredConstructors() | 获取全部构造器（只要存在就能拿到） |
| Constructor<T> getConstructor(Class<?>... parameterTypes) | 获取某个构造器（只能获取public修饰的） |
| Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) | 获取某个构造器（只要存在就能拿到） |
获取类构造器的作用：依然是初始化对象返回
| Constructor提供的方法 | 说明 |
|---|---|
| T newInstance(Object... initargs) | 调用此构造器对象表示的构造器，并传入参数，完成对象的初始化并返回 |
| public void setAccessible(boolean flag) | 设置为true，表示禁止检查访问控制（暴力反射） |
获取类的成员变量
Class提供了从类中获取成员变量的方法。
| 方法 | 说明 |
|---|---|
| public Field[] getFields() | 获取类的全部成员变量（只能获取public修饰的） |
| public Field[] getDeclaredFields() | 获取类的全部成员变量（只要存在就能拿到） |
| public Field getField(String name) | 获取类的某个成员变量（只能获取public修饰的） |
| public Field getDeclaredField(String name) | 获取类的某个成员变量（只要存在就能拿到） |
获取到成员变量的作用：依然是赋值、取值。
| 方法 | 说明 |
|---|---|
| void set(Object obj, Object value)： | 赋值 |
| Object get(Object obj) | 取值 |
| public void setAccessible(boolean flag) | 设置为true，表示禁止检查访问控制（暴力反射） |
获取类的成员方法
Class提供了从类中获取成员方法的API。
| 方法 | 说明 |
|---|---|
| Method[] getMethods() | 获取类的全部成员方法（只能获取public修饰的） |
| Method[] getDeclaredMethods() | 获取类的全部成员方法（只要存在就能拿到） |
| Method getMethod(String name, Class<?>... parameterTypes) | 获取类的某个成员方法（只能获取public修饰的） |
| Method getDeclaredMethod(String name, Class<?>... parameterTypes) | 获取类的某个成员方法（只要存在就能拿到） |
成员方法的作用：依然是执行
| Method****提供的方法 | 说明 |
|---|---|
| public Object invoke(Object obj, Object... args) | 触发某个对象的该方法执行。 |
| public void setAccessible(boolean flag) | 设置为true，表示禁止检查访问控制（暴力反射） |
java
public class Dog {
private String name;
private int age;
private String hobby;
private Dog() {
System.out.println("无参数构造器执行了~~");
}
private Dog(String name) {
System.out.println("1个参数有参数构造器执行了~~");
this.name = name;
}
public Dog(String name, int age) {
System.out.println("2个参数有参数构造器执行了~~");
this.name = name;
this.age = age;
}
private void eat(){
System.out.println("狗吃骨头！");
}
public String eat(String name){
System.out.println("狗吃" + name);
return "狗说：谢谢！谢谢！汪汪汪！";
}
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 String getHobby() {
return hobby;
}
public void setHobby(String hobby) {
this.hobby = hobby;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", age=" + age +
", hobby='" + hobby + '\'' +
'}';
}
}
java
import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectDemo2 {
@Test
public void getClassInfo(){
// 目标：获取类的信息。
// 1、反射第一步：或者Class对象，代表拿到类。
Class c1 = Student.class;
System.out.println(c1.getName()); // 类名的全类名 com.itheima.demo2reflect.Student
System.out.println(c1.getSimpleName()); // 类名 Student
}
// 2、获取类的构造器对象并对其进行操作。
@Test
public void getConstructorInfo() throws Exception {
// 目标：获取类的构造器对象并对其进行操作。
// 1、反射第一步：或者Class对象，代表拿到类。
Class c1 = Dog.class;
// 2、获取构造器对象。
Constructor[] cons = c1.getDeclaredConstructors();
for (Constructor con : cons) {
System.out.println(con.getName() + "(" + con.getParameterCount() + ")");
}
// com.itheima.demo2reflect.Dog(0)
// com.itheima.demo2reflect.Dog(1)
// com.itheima.demo2reflect.Dog(2)
System.out.println("----------------------------------------------------------------");
// 3、获取单个构造器
Constructor con = c1.getDeclaredConstructor(); // 无参数构造器
System.out.println(con.getName() + "(" + con.getParameterCount() + ")");
//com.itheima.demo2reflect.Dog(0)
Constructor con2 = c1.getDeclaredConstructor(String.class, int.class); // 2个参数的有参数构造器
System.out.println(con2.getName() + "(" + con2.getParameterCount() + ")");
// com.itheima.demo2reflect.Dog(2)
// 4、获取构造器的作用依然是创建对象：创建对象。
// 我们完全可以new Dog() 这里之所以不用new Dog()，是为了之后的学习打下基础。
// 暴力反射：暴力反射可以访问私有的构造器、方法、属性。
con.setAccessible(true); // 绕过访问权限，直接访问！
Dog d1 = (Dog) con.newInstance();
System.out.println(d1);
// 无参数构造器执行了~~
// Dog{name='null', age=0, hobby='null'}
Dog d2 = (Dog)con2.newInstance("小黑", 3);
System.out.println(d2);
// 2个参数有参数构造器执行了~~
// Dog{name='小黑', age=3, hobby='null'}
}
// 3、获取类的成员变量对象并对其进行操作。
@Test
public void getFieldInfo() throws Exception {
// 目标：获取类的成员变量对象并对其进行操作。
// 1、反射第一步：或者Class对象，代表拿到类。
Class c1 = Dog.class;
// 2、获取成员变量对象。
Field[] fields = c1.getDeclaredFields();
for (Field field : fields) {
System.out.println(field.getName() + "(" + field.getType().getName() + ")");
}
// name(java.lang.String)
// age(int)
// hobby(java.lang.String)
// 3、获取单个成员变量对象。
Field field = c1.getDeclaredField("hobby");
System.out.println(field.getName() + "(" + field.getType().getName() + ")");
// hobby(java.lang.String)
Field field2 = c1.getDeclaredField("age");
System.out.println(field2.getName() + "(" + field2.getType().getName() + ")");
// age(int)
// 4、获取成员变量的目的依然是取值和赋值。
Dog d = new Dog("泰迪", 3);// 2个参数有参数构造器执行了~~
field.setAccessible(true); // 绕过访问权限，直接访问！
field.set(d, "社交"); // 相当于 d.setHobby("社交");
System.out.println(d);// Dog{name='泰迪', age=3, hobby='社交'}
String hobby = (String) field.get(d); // 相当于 d.getHobby();
System.out.println(hobby);// 社交
}
// 4、获取类的成员方法对象并对其进行操作。
@Test
public void getMethodInfo() throws Exception {
// 目标：获取类的成员方法对象并对其进行操作。
// 1、反射第一步：或者Class对象，代表拿到类。
Class c1 = Dog.class;
// 2、获取成员方法对象。
Method[] methods = c1.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method.getName() + "(" + method.getParameterCount() + ")");
}
// eat(0)
// eat(1)
// setHobby(1)
// getHobby(0)
// getAge(0)
// setAge(1)
// 3、获取单个成员方法对象。
Method m1 = c1.getDeclaredMethod("eat");// 获取是无参数的eat方法
Method m2 = c1.getDeclaredMethod("eat", String.class);// 获取是有参数的eat方法
System.out.println(m1.getName() + "(" + m1.getParameterCount() + ")");// getName(0)
System.out.println(m2.getName() + "(" + m2.getParameterCount() + ")");// toString(0)
System.out.println("--------------------------------------");
// 4、获取成员方法的目的依然是调用方法。
Dog d = new Dog("泰迪", 3);// 2个参数有参数构造器执行了~~
m1.setAccessible(true); // 绕过访问权限，直接访问！
Object rs1 = m1.invoke(d); // 唤醒对象d的eat方法执行，相当于 d.eat(); //狗吃骨头！
System.out.println(rs1); // null
Object rs2 = m2.invoke(d, "牛肉"); // 唤醒对象d的eat带String参数的方法执行，相当于 d.eat("牛肉");
// 狗吃牛肉
System.out.println(rs2);// 狗说：谢谢！谢谢！汪汪汪！
}
}作用、应用场景
反射的作用？
- 基本作用：可以得到一个类的全部成分然后操作。
- 可以破坏封装性。
- 可以绕过泛型的约束
- 最重要的用途是：适合做Java的框架，基本上，主流的框架都会基于反射设计出一些通用的功能。
java
import java.lang.reflect.Method;
import java.util.ArrayList;
public class ReflectDemo3 {
public static void main(String[] args) throws Exception {
// 3、可以绕过泛型的约束。
ArrayList<String> list = new ArrayList<>();
list.add("张无忌");
list.add("令狐冲");
list.add("东方不败");
// list.add(9.9);// 报错
// list.add(true);
Class c1 = list.getClass(); // c1 == ArrayList.class
// 这是编译后，类名.class
// 获取 ArrayList 类的add方法
Method add = c1.getDeclaredMethod("add", Object.class);
// 编译好后的文件已经把泛型擦除了， 所以这里可以添加任意类型的数据。
// 触发list集合对象的add方法执行。
add.invoke(list, 9.9); // 翻墙
add.invoke(list, true); // 翻墙
System.out.println(list);
// [张无忌, 令狐冲, 东方不败, 9.9, true]
}
}使用反射做一个简易版的框架
需求：
对于任意一个对象，该框架都可以把对象的字段名和对应的值，保存到文件中去。
实现步骤
- 定义一个方法，可以接收任意对象。
- 每收到一个对象后，使用反射获取该对象的Class对象，然后获取全部的成员变量。
- 遍历成员变量，然后提取成员变量在该对象中的具体值。
- 把成员变量名、和其值，写出到文件中去即可。
反射有啥作用？
可以在运行时得到一个类的全部成分然后操作。
可以破坏封装性。（很突出）
也可以破坏泛型的约束性。（很突出）
更重要的用途是适合：做Java高级框架
基本上主流框架都会基于反射设计一些通用技术功能。
java
// 框架
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.lang.reflect.Field;
public class SaveObjectFrameWork {
// 保存任意对象的静态方法
public static void saveObject(Object obj) throws Exception {
PrintStream ps = new PrintStream(new FileOutputStream("day-15\\src\\com\\itheima\\demo2reflect\\obj.txt", true));
// obj 可能是学生 老师 狗
// 只有反射可以直到对象有多少个字段：
// 1. 获取Class对象
Class c = obj.getClass();
String simpleName = c.getSimpleName();
ps.println("==============" + simpleName + "====================");
// 2. 获取Class对象的所有字段。
Field[] fields = c.getDeclaredFields();
// 3. 遍历字段
for (Field field : fields) {
// 4. 获取字段的值
// 4.1 获取字段名称
String fieldName = field.getName();
// 4.2 获取字段的值
field.setAccessible(true); // 暴力反射
Object fieldValue = field.get(obj) + "";
// 5. 打印到文件中去
ps.println(fieldName + "=" + fieldValue);
}
ps.close();
}
}
java
// 编写入口方法
public class ReflectDemo4 {
public static void main(String[] args) throws Exception {
// 目标：搞清楚反射的应用：做框架的通用技术。
Dog d = new Dog("小黑", 3);
SaveObjectFrameWork.saveObject(d);
// 创建学生对象
Student s = new Student("小明", 18, "爱问问题");
SaveObjectFrameWork.saveObject(s);
// 创建老师对象
Teacher t = new Teacher("小红", 19, "java、前端、动漫", 3000, "422期", '女', "12345678901");
SaveObjectFrameWork.saveObject(t);
}
}
java
==============Dog====================
name=小黑
age=3
hobby=null
==============Student====================
name=小明
age=18
hobby=爱问问题
==============Teacher====================
name=小红
age=19
hobby=java、前端、动漫
salary=3000.0
className=422期
sex=女
phone=12345678901注解
注解概述
就是Java代码里的特殊标记，比如：@Override、@Test等，作用是：让其他程序根据注解信息来决定怎么执行该程序。
注意：注解可以用在类上、构造器上、方法上、成员变量上、参数上、等位置处。
注解概述-自定义注解
自定义注解
就是自己定义注解。
java
public @interface 注解名称 {
public 属性类型 属性名() default 默认值 ;
}
java
@MyBook(name = "赵丽颖", age = 18, address = {"北京", "上海"})
public class AnnotationDemo1 {
@MyBook(name = "王菲", age = 52, address = {"北京", "香港"})
public static void main( String[] args ) {
// 目标：自定义注解。
int a;
}
}
// 自定义注解
public @interface MyBook {
String name();
int age() default 18;
String[] address();
}特殊属性名： value
如果注解中只有一个value属性，使用注解时，value名称可以不写!!
java
public @interface A {
String value(); // 特殊属性value，在使用时如果只有一个value属性，value名称可以不写
String hobby() default "打篮球"; // 当这个有默认值，value名称也可以不写
}
// @A(value = "delete")
//@A("delete") // 特殊属性value，在使用时如果只有一个value属性，value名称可以不写
//@A(value = "delete", hobby = "打篮球")
@A("delete")
public class AnnotationDemo1 {
public static void main( @A("delete") String[] args ) {
// 目标：自定义注解。
@A("delete")
int a;
}
}注解概述-注解的原理
注解本质是一个接口，Java中所有注解都是继承了Annotation接口的。
@注解(...)：其实就是一个实现类对象，实现了该注解以及Annotation接口。
注解的作用
- 对Java中类、方法、成员变量做标记，然后进行特殊处理。
- 例如：JUnit框架中，标记了注解@Test的方法就可以被当成测试方法执行，而没有标记的就不能当成测试方法执行
元注解
元注解是什么
指的是：注解(动词)注解(名词)的注解(名词)。
元注解是什么？
注解注解的注解
各自的作用是什么？
@Target约束自定义注解可以标记的范围。
@Retention用来约束自定义注解的存活范围。
java
//@MyTest1
public class AnnotationDemo2 {
@MyTest1
private int age;
// @MyTest1
public AnnotationDemo2(){
}
@MyTest1
public static void main(String[] args) {
// 目标：搞清楚元注解的作用。
}
@MyTest1
public void getAgeTest(){
}
}
// 元注解
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.METHOD, ElementType.FIELD}) // 表示注解的作用目标为方法,成员变量
@Retention(RetentionPolicy.RUNTIME) // 表示注解的保留策略: 编译器运行时(一直活着)
public @interface MyTest1 { }注解的解析
注解的解析是什么
就是判断类上、方法上、成员变量上是否存在注解，并把注解里的内容给解析出来。
如何解析注解？
- 指导思想：要解析谁上面的注解，就应该先拿到谁。
- 比如要解析类上面的注解，则应该先获取该类的Class对象，再通过Class对象解析其上面的注解。
- 比如要解析成员方法上的注解，则应该获取到该成员方法的Method对象，再通过Method对象解析其上面的注解。
- Class 、 Method 、 Field , Constructor、都实现了AnnotatedElement接口，它们都拥有解析注解的能力。
| AnnotatedElement 接口提供了解析注解的方法 | 说明 |
|---|---|
| public Annotation[] getDeclaredAnnotations() | 获取当前对象上面的注解。 |
| public T getDeclaredAnnotation(Class annotationClass) | 获取指定的注解对象 |
| public boolean isAnnotationPresent(Class annotationClass) | 判断当前对象上是否存在某个注解 |
解析注解的案例
- 定义注解MyTest4，要求如
- 包含属性：String value()
- 包含属性：double aaa()，默认值为 100
- 包含属性：String[] bbb()
- 限制注解使用的位置：类和成员方法上
- 指定注解的有效范围：一直到运行时
- 定义一个类叫：Demo，在类中定义一个test1方法，并在该类和其方法上使用MyTest4注解
- 定义AnnotationTest3测试类，解析Demo类中的全部注解。
java
// 第一步
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.METHOD, ElementType.TYPE}) // 表示注解的作用目标为方法,成员变量
@Retention(RetentionPolicy.RUNTIME) // 表示注解的保留策略: 编译器运行时(一直活着)
public @interface MyTest2 {
String value();
double height() default 169.5;
String[] address();
}
// 第二步
@MyTest2(value = "刘亦菲", address = {"北京", "上海", "深圳"})
public class Demo {
@MyTest2(value = "欧阳娜娜", address = {"湖南", "湖北"})
public void go(){
}
}
// 第三步
import org.junit.Test;
import java.lang.reflect.Method;
import java.util.Arrays;
public class AnnotationDemo3 {
// 目标：解析注解
@Test
public void parseClass() throws Exception {
// 1.获取类对象
Class c1 = Demo.class;
// 2、使用isAnnotationPresent判断这个类上是否陈列了注解MyTest2
if (c1.isAnnotationPresent(MyTest2.class)) {
// 3、获取注解对象
MyTest2 myTest2 = (MyTest2) c1.getDeclaredAnnotation(MyTest2.class);
// 4、获取注解属性值
String[] address = myTest2.address();
double height = myTest2.height();
String value = myTest2.value();
// 5、打印注解属性值
System.out.println(Arrays.toString(address));
System.out.println(height);
System.out.println(value);
// [北京, 上海, 深圳]
// 169.5
// 刘亦菲
}
}
@Test
public void parseMethod() throws Exception {
// 1.获取类对象
Class c1 = Demo.class;
// 2、获取方法对象
Method method = c1.getMethod("go");
// 3、使用isAnnotationPresent判断这个方法上是否陈列了注解MyTest2
if (method.isAnnotationPresent(MyTest2.class)) {
// 4、获取注解对象
MyTest2 myTest2 = method.getDeclaredAnnotation(MyTest2.class);
// 5、获取注解属性值
String[] address = myTest2.address();
double height = myTest2.height();
String value = myTest2.value();
// 6、打印注解属性值
System.out.println(Arrays.toString(address));
System.out.println(height);
System.out.println(value);
// [湖南, 湖北]
// 169.5
// 欧阳娜娜
}
}
}总结
什么是注解的解析？注解解析的步骤是啥？
| 方法 |
|---|
| Annotation[] getDeclaredAnnotations() |
| T getDeclaredAnnotation(Class<T> annotationClass) |
| boolean isAnnotationPresent(Class<Annotation> annotationClass) |
作用、应用场景
使用注解开发出一个简易版的Junit框架
需求
- 定义若干个方法，只要加了MyTest注解，就会触发该方法执行。
分析
- 定义一个自定义注解MyTest，只能注解方法，存活范围是一直都在。
- 定义若干个方法，部分方法加上@MyTest注解修饰，部分方法不加。
- 模拟一个junit程序，可以触发加了@MyTest注解的方法执行。
java
import java.lang.reflect.Method;
public class AnnotationDemo4 {
// 目标：搞清楚注解的应用场景：模拟junit框架。有MyTest注解的方法就执行，没有的就不执行。
public static void main(String[] args) throws Exception {
AnnotationDemo4 ad = new AnnotationDemo4();
// 1、获取类对象
Class c = AnnotationDemo4.class;
// 2、获取所有方法
Method[] methods = c.getMethods();
// 3、遍历所有方法，判断方法上是否有MyTest注解，有就执行，没有就不执行。
for (Method method : methods) {
// 4、判断方法上是否有MyTest注解
if (method.isAnnotationPresent(MyTest.class)) {
// 获取到这个方法的注解
MyTest myTest = method.getDeclaredAnnotation(MyTest.class);
int count = myTest.count();
// 5、有就执行这个method方法
for (int i = 0; i < count; i++) {
method.invoke(ad);
}
// test3方法执行了
// test3方法执行了
// test1方法执行了
// test4方法执行了
}
}
}
// 测试方法：public 无参 无返回值
@MyTest
public void test1(){
System.out.println("test1方法执行了");
}
public void test2(){
System.out.println("test2方法执行了");
}
@MyTest(count = 2)
public void test3(){
System.out.println("test3方法执行了");
}
@MyTest
public void test4(){
System.out.println("test4方法执行了");
}
}
// 注解。
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.METHOD}) // 表示注解的作用目标为方法
@Retention(RetentionPolicy.RUNTIME) // 表示注解的保留策略: 编译器运行时(一直活着)
public @interface MyTest {
int count() default 1; // 表示注解的属性
}动态代理(设计模式)
程序为什么需要代理？代理长什么样？
什么是代理
歌手自己准备场地话筒收钱
当歌手忙不过来时。
歌手自己找个代理，让代理帮自己准备场地，准备话筒，并为歌手安排行程等等。
如何为Java对象创建一个代理对象？
java.lang.reflect.Proxy类：提供了为对象产生代理对象的方法：
java
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
参数一：用于指定用哪个类加载器，去加载生成的代理类
参数二：指定接口，这些接口用于指定生成的代理长什么，也就是有哪些方法
参数三：用来指定生成的代理对象要干什么事情代码
java
// 接口：StarService
package com.itheima.demo4proxy;
// 明星行为接口
public interface StarService {
void sing(String name);
String dance();
}
// Star.java
package com.itheima.demo4proxy;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Star implements StarService{
private String name;
@Override
public void sing(String name) {
System.out.println(this.name + "表演唱歌：" + name);
}
@Override
public String dance() {
System.out.println(this.name + "表演跳舞：魅力四射！" );
return "谢谢！谢谢！";
}
}
java
// ProxyUtil.java
package com.itheima.demo4proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 代理工具类：中介公司，专门负责创建代理对象并返回给别人使用
*/
public class ProxyUtil {
// 创建一个明星对象的代理对象返回。
public static StarService createProxy(Star s){
/**
* 参数一：用于执行用哪个类加载器去加载生成的代理类。
* 参数二：用于指定代理类需要实现的接口: 明星类实现了哪些接口，代理类就实现哪些接口
* 参数三：用于指定代理类需要如何去代理（代理要做的事情）。
*/
StarService proxy = (StarService) Proxy.newProxyInstance(ProxyUtil.class.getClassLoader(),
s.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 用来声明代理对象要干的事情。
// 参数一： proxy接收到代理对象本身（暂时用处不大）
// 参数二： method代表正在被代理的方法
// 参数三： args代表正在被代理的方法的参数
String methodName = method.getName();
if("sing".equals(methodName)){
System.out.println("准备话筒，收钱20万！");
}else if("dance".equals(methodName)){
System.out.println("准备场地，收钱100万！");
}
// 真正干活（把真正的明星对象叫过来正式干活）
// 找真正的明星对象来执行被代理的行为：method方法
Object result = method.invoke(s, args);
return result;
}
});
return proxy;
}
}
java
package com.itheima.demo4proxy;
import java.lang.reflect.Proxy;
public class Test {
public static void main(String[] args) {
// 目标：创建代理对象。
// 1、准备一个明星对象：设计明星类。
Star star = new Star("章若楠");
// 2、为章若楠创建一个专属与她的代理对象。
StarService proxy = ProxyUtil.createProxy(star);
proxy.sing("《红昭愿》");
System.out.println(proxy.dance());
}
}代码运行流程
Java提供了什么API帮我们创建代理？
Proxy的newProxyInstance方法。
newIProxyInstance方法在创建代理时，需要接几个参数，每个参数的含义是什么？
- 参数一：用于执行用哪个类加载器去加载生成的代理类。
- 参数二：用于指定代理类需要实现的接口: 明星类实现了哪些接口，代理类就实现哪些接口
- 参数三：用于指定代理类需要如何去代理（代理要做的事情）。
通过invokehandler的invoke方法指定代理干的事时，这个invoke会被谁调用？要接哪几个参数？
谁去调用触发谁的方法。
参数一： proxy接收到代理对象本身（暂时用处不大）
参数二： method代表正在被代理的方法
参数三： args代表正在被代理的方法的参数
解决实际问题、掌握使用代理的好处
使用代理优化用户管理类
场景
某系统有一个用户管理类，包含用户登录，删除用户，查询用户等功能，系统要求统计每个功能的执行耗时情况，以便后期观察程序性能。
需求
现在，某个初级程序员已经开发好了该模块，请观察该模块的代码，找出目前存在的问题，并对其进行改造。
java
package com.itheima.demo05proxy2;
/**
* 用户业务接口
*/
public interface UserService {
// 登录功能
void login(String loginName,String passWord) throws Exception;
// 删除用户
void deleteUsers() throws Exception;
// 查询用户，返回数组的形式。
String[] selectUsers() throws Exception;
String[] selectUsers2() throws Exception;
}
package com.itheima.demo05proxy2;
/**
* 用户业务实现类（面向接口编程）
*/
public class UserServiceImpl implements UserService{
@Override
public void login(String loginName, String passWord) throws Exception {
// ----------------------
if("admin".equals(loginName) && "123456".equals(passWord)){
System.out.println("您登录成功，欢迎光临本系统~");
}else {
System.out.println("您登录失败，用户名或密码错误~");
}
Thread.sleep(1000);
// --------------------------
}
@Override
public void deleteUsers() throws Exception{
System.out.println("成功删除了1万个用户~");
Thread.sleep(1500);
}
@Override
public String[] selectUsers() throws Exception{
System.out.println("查询出了3个用户");
String[] names = {"张全蛋", "李二狗", "牛爱花"};
Thread.sleep(500);
return names;
}
@Override
public String[] selectUsers2() throws Exception {
System.out.println("查询出了3000个用户");
String[] names = {"张全蛋2", "李二狗2", "牛爱花2"};
Thread.sleep(2500);
return names;
}
}
java
package com.itheima.demo05proxy2;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyUtil {
public static <T> T createProxy(T obj) {
T proxy = (T) Proxy.newProxyInstance(ProxyUtil.class.getClassLoader(),
obj.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long start = System.currentTimeMillis(); // 记录开始时间 1970年1月1日0时0分0秒 走到此刻的总毫秒值
// 真正调用业务对象被代理的方法
Object result = method.invoke(obj, args);
long end = System.currentTimeMillis();
System.out.println(method.getName() + "方法耗时："+(end-start)/1000.0+"秒");
return result;
}
});
return proxy;
}
}
java
package com.itheima.demo05proxy2;
import java.util.Arrays;
/**
* 目标：使用动态代理解决实际问题，并掌握使用代理的好处。
*/
public class Test {
public static void main(String[] args) throws Exception{
// 1、创建用户业务对象。
UserService userService = ProxyUtil.createProxy(new UserServiceImpl());
// 2、调用用户业务的功能。
userService.login("admin", "123456");
userService.deleteUsers();
String[] names = userService.selectUsers();
System.out.println("查询到的用户是：" + Arrays.toString(names));
String[] names2 = userService.selectUsers2();
System.out.println("查询到的用户是：" + Arrays.toString(names2));
}
}
java
您登录成功，欢迎光临本系统~
login方法耗时：1.007秒
成功删除了1万个用户~
deleteUsers方法耗时：1.506秒
查询出了3个用户
selectUsers方法耗时：0.515秒
查询到的用户是：[张全蛋, 李二狗, 牛爱花]
查询出了3000个用户
selectUsers2方法耗时：2.514秒
查询到的用户是：[张全蛋2, 李二狗2, 牛爱花2]