文章目录

单元测试
- 单元测试概述
- 单元测试快速入门
- 单元测试常用注解
反射
- 反射概述
- 反射获取类对象
- 反射获取构造器对象
- 反射获取成员变量对象
- 反射获取方法对象
- 反射的作用-绕过编译阶段为集合添加数据
- 反射的作用-通用框架的底层原理
注解
- 注解概述
- 自定义注解
- 元注解
- 注解解析
- - 案例：注解解析的案例
- 注解的应用场景一：Junit框架
动态代理

单元测试

单元测试概述

单元测试

单元测试就是针对最小的功能单元编写测试代码，Java程序最小的功能单元是方法，因此，单元测试就是针对Java方法的测试，进而检查方法的正确性。

目前测试方法是怎么进行的，存在什么问题。

只有一个main方法，如果一个方法的测试失败了，其他方法测试都会受到影响。
无法得到测试的结果报告，需要程序员自己去观察测试是否成功。
无法实现自动化测试。

Junit单元测试框架

Junit是使用Java语言实现的单元测试框架，它是开源的。
几乎所有的IDE工具都集成了Junit，Junit目前最新版本是5

Junit优点

Junit可以灵活的选择执行哪些测试方法，可以一键执行全部测试方法。
Junit可以生成全部方法的测试报告。
单元测试中的某个方法测试失效了，不会影响其他测试方法的测试。

小结

Junit单元测试是做什么的？
- 测试类中方法的正确性
Junit单元测试的优点是什么？
- Junit可以选择执行哪些测试方法，可以一键执行全部测试方法的测试。
- Junit可以生成测试报告，如果测试良好则是绿色；如果测试失败则是红色。
- 单元测试中的某个测试方法失败了，不会影响其他测试方法的测试。

单元测试快速入门

步骤：单元测试快速入门

需求：使用单元测试进行业务方法预期结果、正确性测试

分析：

将Junit的jar包导入到项目中
- IDEA通常整合好了Junit框架，一般不需要导入。
- 如果IDEA没有整合好，需要自己手动导入Junit的2个jar包到模块
编写测试方法：该测试方法必须是公共的无参数无返回值的非静态方法
在测试方法上使用@Test注解：标注该方法是一个测试方法
在测试方法中完成被测试方法的预期正确性测试
选择测试方法，选择“Junit运行” ，如果测试良好则是绿色；如果测试失败，则是红色

/*** 业务方法*/
public class UserService {public String loginName(String loginName, String passWord) {if ("admin".equals(loginName) && "12345".equals(passWord)) {return "登录成功";} else {return "用户名或者密码有问题！";}}public void selectNames(){System.out.println(10/0);System.out.println("查询全部用户名称成功！");}
}

/**测试类*/
public class TestUserService {/**测试方法注意点：1.必须是公开的，无参数，无返回值的方法2.测试方法必须使用@Test注解标记*/@Testpublic void testLoginName(){UserService userService = new UserService();String rs = userService.loginName("admin","123456");//进行预期结果的正确性测试：断言Assert.assertEquals("您的业务功能可能出现问题","登录成功",rs);}@Testpublic void testSelectNames(){UserService userService = new UserService();userService.selectNames();}
}
output:

output:

单元测试常用注解

Junit常用注解（Junit 4.xxxx版本)

注解	说明
@Test	测试方法
@Before	用来修饰实例方法，该方法会在每一个测试方法执行之前执行一次
@After	用来修饰实例方法，该方法会在每一个测试方法执行之后执行一次
@BeforeClass	用来修饰静态方法，该方法会在所有测试方法执行之前执行一次
@AfterClass	用来修饰静态方法，该方法会在所有测试方法之后执行一次

开始执行的方法：初始化资源。
执行完之后的方法：释放资源。

/**测试类*/
public class TestUserService {//修饰实例方法的@Beforepublic void before(){System.out.println("======before方法执行一次=======");}@Afterpublic void after(){System.out.println("========after方法执行一次=========");}//修饰静态方法的@BeforeClasspublic static void beforeClass(){System.out.println("========beforeClass方法执行一次=========");}@AfterClasspublic static void afterClass(){System.out.println("========afterClass方法执行一次=========");}/**测试方法注意点：1.必须是公开的，无参数，无返回值的方法2.测试方法必须使用@Test注解标记*/@Testpublic void testLoginName(){UserService userService = new UserService();String rs = userService.loginName("admin","123456");//进行预期结果的正确性测试：断言Assert.assertEquals("您的业务功能可能出现问题","登录成功",rs);}@Testpublic void testSelectNames(){UserService userService = new UserService();userService.selectNames();}
}
output:
========beforeClass方法执行一次=========
======before方法执行一次=======
查询全部用户名称成功！
========after方法执行一次=========
========afterClass方法执行一次=========

Junit常用注解（Junit 5.xxxx版本)

注解	说明
@Test	测试方法
@BeforeEach	用来修饰实例方法，该方法会在每一个测试方法执行之前执行一次
@AfterEach	用来修饰实例方法，该方法会在每一个测试方法执行之后执行一次
@BeforeAll	用来修饰静态方法，该方法会在所有测试方法之前执行一次
@AfterAll	用来修饰静态方法，该方法会在所有测试方法之后执行一次

开始执行的方法：初始化资源
执行完之后的方法：释放资源

反射

反射概述

反射是指对于任何一个Class类，在“运行的时候”都可以直接得到这个类的全部成分
在运行时，可以直接得到这个类的构造器对象：Constructor
在运行时，可以直接得到这个类的成员变量对象：Filed
在运行时，可以直接得到这个类的成员方法对象：Method
这种运行时动态获取类信息以及动态调用类中成分的能力称为Java语言的反射机制。

反射的关键：

反射的第一步都是先得到编译后的Class类对象，然后就可以得到Class的全部成分。

HelloWorld.java -> javac -> HelloWorld.class
Class c = HelloWorld.class;

反射的基本作用、关键？
- 反射是在运行时获取类的字节码文件对象：然后可以解析类中的全部成分
- 反射的核心思想和关键就是：得到编译以后的class文件对象。

反射获取类对象

反射的第一步：获取Class类的对象

public class Test {public static void main(String[] args) throws Exception {//1.Class类中的一个静态方法：forName(全限名：类名+包名）Class c = Class.forName("com.csl.d2_reflect_class.Student");System.out.println(c);//Student.class//2.类名.classClass c2 = Student.class;System.out.println(c2);//3.对象.getClass()   获取对象对应类的Class对象Student s = new Student();Class c3 = s.getClass();System.out.println(c3);}
}
public class Student {}
output:
class com.csl.d2_reflect_class.Student
class com.csl.d2_reflect_class.Student
class com.csl.d2_reflect_class.Student

反射的第一步是什么？
- 获取Class类对象，如此才可以解析类的全部成分。
获取Class类的对象的三种方式。
- 方式一：Class c1 = Class.forName(“全类名”);
- 方式二：Class c2 = 类名.class
- 方式三：Class c3 = 对象.getClass();

反射获取构造器对象

使用反射技术获取构造器对象并使用

反射的第一步是先得到类对象，然后从类对象中获取类的成分对象。
Class类中用于获取构造器的方法

方法	说明
Contructor<?> [ ] getConstructors( )	返回所有构造器对象的数组(只能拿public的)
Constructor<?>[ ] getDeclaredConsturctors( )	返回所有构造器对象的数组，存在就能拿到
Constructor getConstructor(Class<?>… parmeterTypes)	返回单个构造器对象（只能拿public的）
Constructor getDeclaredConstructor(Class<?>… parameterTypes)	返回单个构造器对象，存在就能拿到

public class TestStudent01 {//1.getConstructors://获取全部的构造器：只能获取public修饰的构造器//Constructor[] getConstuctors()@Testpublic void getConstructors() {//a.第一步，获取类对象Class c = Student.class;//b.提取类中的全部构造器对象(这里只能拿public修饰的）Constructor[] constructors = c.getConstructors();//c.遍历构造器、for (Constructor constructor : constructors) {System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());}}//2.getDeclaredConstructors();//获取全部的构造器，无所谓权限是否可及@Testpublic void getDeclraredConstructors() {//a.第一步获取类对象Class c = Student.class;//b.提取类中的全部构造器对象Constructor[] constructors = c.getDeclaredConstructors();//c.遍历构造器for (Constructor constructor : constructors) {System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());}}//3.getConstructors(Class... parameterTypes)//获取某个构造器：只能拿public修饰的某个构造器@Testpublic void getConstructor() throws Exception {//a.获取类对象Class c = Student.class;//b.定位单个构造器对象(按照参数定位无参数的构造器）Constructor cons = c.getConstructor();System.out.println(cons.getName() + "===>" + cons.getParameterCount());}//4.getDeclaredConstructor//获取某个构造器：只要存在的都可以拿到不考虑修饰符@Testpublic void getDeclaredConstructor() throws Exception {//a.获取类对象Class c = Student.class;//b.定位某个有参构造器Constructor cons2 = c.getDeclaredConstructor(String.class, int.class);System.out.println(cons2.getName() + "===>" + cons2.getParameterCount());}
}

使用反射技术获取构造器对象并使用

获取构造器的作用依然是初始化一个对象返回。

Constructor类中用于创建对象的方法

符号	说明
T newInstance(Object… initargs)	根据指定的构造器创建对象
public void setAccessible(boolean flag)	设置为true，表示取消访问检查，进行暴力反射

public class Student {private String name;private int age;private Student() {System.out.println("无参构造器执行！");}public Student(String name, int age) {System.out.println("有参构造器执行！");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;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}
}

public class TestStudent02 {//1.调用一个构造器得到一个类的对象返回@Testpublic void getDeclaredConstructor() throws Exception {//a.获取类对象Class c = Student.class;//b,定位单个构造器对象（按照参数定位无参构造器）Constructor cons1 = c.getDeclaredConstructor();System.out.println(cons1.getName() + "===>" + cons1.getParameterCount());//如果遇到了私有的构造器，可以暴力反射cons1.setAccessible(true);//权限打开Student s = (Student) cons1.newInstance();System.out.println(s);//c.定位某个有参构造器Constructor cons2 = c.getDeclaredConstructor(String.class, int.class);System.out.println(cons2.getName() + "===>" + cons2.getParameterCount());Student s1 = (Student) cons2.newInstance("至尊宝", 777);System.out.println(s1);}
}
output:
com.csl.d3_reflect_constructor.Student===>0
无参构造器执行！
Student{name='null', age=0}
com.csl.d3_reflect_constructor.Student===>2
有参构造器执行！
Student{name='至尊宝', age=777}

利用反射技术获取构造器对象的方式
- getDeclaredConstructors( )
- getDeclaredConstructor(Class<?>… parameterTypes)
反射得到的构造器可以做什么？
- 依然是创建对象的
  - public newInstance(Object… initargs)
- 如果是非public的构造器，需要打开权限(暴力反射)，然后再创建对象
  - setAccessible(boolean)
  - 反射可以破坏封装性，私有的也可以执行了。

反射获取成员变量对象

使用反射技术获取成员变量对象并使用

反射的第一步是先得到类对象，然后从类对象中获取类的成分对象。
Class类中用于获取成员变量的方法

方法	说明
Filed[ ] getFileds( )	返回所有成员变量对象的数组，(只能拿public的)
Filed[ ] getDeclaredFileds( )	返回所有成员变量对象的数组，存在就能拿到
Filed getFiled(String name)	返回单个成员变量对象（只能拿public的）
Filed getDeclaredFiled( String name)	返回单个成员变量对象，存在就能拿到

public class FiledDemo01 {/*** 1.获取全部的成员变量* Filed[] getDeclaredFileds()* 获得所有成员变量对应的Filed对象，只要申明了就能拿到*/@Testpublic void getDeclaredFileds() {//a.定位Class对象Class c = Student.class;//b.定位全部成员变量Field[] fields = c.getDeclaredFields();//c.遍历一下for (Field field : fields) {System.out.println(field.getName() + "===>" + field.getType());}}/**2.获取某个成员变量对象Filed getDeclaredFiled(String name)*/@Testpublic void getDeclaredFeild()throws Exception{//a.定位Class对象Class c = Student.class;//b,根据名称定位某个成员变量Field filed = c.getDeclaredField("age");System.out.println(filed.getName()+"===>"+filed.getType());//age===>int}
}
output:
age===>int
name===>class java.lang.String
age===>int
schoolName===>class java.lang.String
COUNTTRY===>class java.lang.String

获取成员变量的作用依然是在某个对象中取值、赋值

Filed类中用于取值、赋值的方法

符号	说明
void set(Object obj, Object value)	赋值
Object get(Object obj)	获取值

/*** 反射获取成员变量：取值和赋值*/
public class FiledDemo02 {@Testpublic void setFiled() throws Exception {//a.反射第一步，获取类对象Class c = Student.class;//b.提取某个成员变量Field ageF = c.getDeclaredField("age");ageF.setAccessible(true);//暴力打开权限//c.赋值Student s = new Student();ageF.set(s,18);//s.setAge(18)System.out.println(s);//d.取值int age = (int) ageF.get(s);System.out.println(age);}
}
output:
无参构造器执行！
Student{name='null', age=18}
18

小结

利用反射技术获取成员变量的方式
- getDeclaredFileds( )
- getDeclaredFiled(String name)
反射得到成员变量可以做什么？
- 依然是在某个对象中取值和赋值
  - void set(Object obj,Object value):
  - Object get(Object obj)
- 如果成员变量是非public的，需要打开权限(暴力反射)，然后再取值、赋值
  - setAccessiable(boolean)

反射获取方法对象

使用反射技术获取方法对象并使用

Class类中用于获取成员方法的方法

方法	说明
Method[ ] getMethods( )	返回所有成员方法对象的数组（只能拿public的）
Method[ ] getDeclaredMethods( )	返回所有成员方法对象的数组，存在就能拿到
Method getMethod(String name, Class<?> … parametreTypes)	返回单个成员方法对象（只能拿public的）
Method getDeclaredMethod(String name,Class<?>… parameterTypes )	返回单个成员方法对象，存在就能拿到

public class Dog {private String name;public Dog() {}public void run() {System.out.println("狗跑的贼快~~~");}public void eat() {System.out.println("狗吃骨头");}private String eat(String name) {System.out.println("狗吃" + name);return "吃的很开心！";}public static void inAddr(){System.out.println("我正在自学黑马的课程");}public Dog(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

/*** 1, 获得类中的所有成员方法对象*/
@Test
public void getDeclaredMethods() {//a.获取类对象Class c = Dog.class;//b.提取全部方法Method[] m = c.getDeclaredMethods();//c.遍历全部方法for (Method method : m) {System.out.println(method.getName() + "返回值类型 " +method.getReturnType()+"参数个数 " + method.getParameterCount());}
}
output:
getName返回值类型class java.lang.String参数个数0
run返回值类型void参数个数0
setName返回值类型void参数个数1
eat返回值类型class java.lang.String参数个数1
eat返回值类型void参数个数0
inAddr返回值类型void参数个数0

获取成员方法的作用依然是在某个对象中进行执行此方法

Method类中用于触发执行的方法

符号	说明
Object invoke(Object obj , Object… args)	运行方法参数一：用Object对象调用该方法参数二：调用方法传递的参数(如果没有就不写) 返回值：方法的返回值（如果没有就不写）

    /**2,获取某个方法对象*/@Testpublic void getDeclaredMethod()throws Exception{//a.获取类对象Class c = Dog.class;//b.提取单个方法Method m1 = c.getDeclaredMethod("eat");Method m2 = c.getDeclaredMethod("eat", String.class);m1.setAccessible(true);//c.触发方法的执行Dog d = new Dog();Object result = m1.invoke(d);System.out.println(result);m2.setAccessible(true);Object result2 = m2.invoke(d,"骨头");System.out.println(result2);}
}
output:
狗吃骨头
null
狗吃骨头
吃的很开心！

小结：

利用反射技术获取成员方法对象的方式

获取类中成员方法对象
- getDeclaredMethods( )
- getDeclaredMethod(String name,Class<?>… parameterTypes)

反射得到成员方法可以做什么？

依然是在某个对象中触发该方法执行
- Object invoke(Object obj, Object… args)
如果某成员方法是非public的，需要打开权限（暴力反射），然后再触发执行
- setAccessible(boolean)

反射的作用-绕过编译阶段为集合添加数据

反射的作用是在运行时的技术，此时集合的泛型将不能产生约束了，此时是可以为集合存入其他任意类型的元素的。

ArrayList<Integer> list = new ArrayList<>();
list.add(100);
list.add("csl");//报错
list.add(99);

泛型只是在编译阶段可以约束集合只能操作某种数据类型，在编译成Class文件进入运行阶段的时候，其真是类型都是ArrayList了，泛型相当于被擦除了。。

public class ReflectDemo {public static void main(String[] args) throws Exception {//反射实现泛型擦除后，加入其它的类型ArrayList<String> list1 = new ArrayList<>();ArrayList<Integer> list2 = new ArrayList<>();System.out.println(list1.getClass());System.out.println(list2.getClass());System.out.println(list1.getClass() == list2.getClass());//ArrayList.classSystem.out.println("=================");ArrayList<Integer> list3 = new ArrayList<>();list3.add(22);list3.add(23);
//        list2.add("csl");Class c = list3.getClass();//ArrayList.class ==> public boolean add(E e)//定义c类中的add方法Method add = c.getDeclaredMethod("add",Object.class);boolean rs = (boolean) add.invoke(list3, "csl");System.out.println(rs);System.out.println(list3);ArrayList list4 = list3;list4.add("csl");list4.add(false);System.out.println(list3);}
}
output:
class java.util.ArrayList
class java.util.ArrayList
true
=================
true
[22, 23, csl]
[22, 23, csl, csl, false]

1.反射为何可以给约定了泛型的集合存入其他类型的元素？

编译成class文件进入编译阶段的时候，泛型会自动擦除。
反射是作用在运行时的技术，此时已经不存在泛型了。

反射的作用-通用框架的底层原理

案例：反射做通用框架

需求：给你任意一个对象，在不清楚对象字段的情况下，可以把对象的字段名称和对应值存储到文件中去。

分析：

定义一个方法，可以接受任意类型的对象。
每次接收到一个对象后，需要解析这个对象的全部成员变量名称。
这个对象可能是任意的，那么怎样才可以知道这个对象的全部成员变量名称呢？
使用反射获取对象的Class类对象，然后获取全部的成员变量信息
遍历成员变量信息，然后提取本成员变量在对象中的具体值。
存入成员变量名称和值到文件中去即可

任意定义一个学生类，老师类

public class Student {private String name;private char sex;private int age;private String className;private String hobby;public Student() {}public Student(String name, char sex, int age, String className, String hobby) {this.name = name;this.sex = sex;this.age = age;this.className = className;this.hobby = hobby;}public String getName() {return name;}public void setName(String name) {this.name = name;}public char getSex() {return sex;}public void setSex(char sex) {this.sex = sex;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getClassName() {return className;}public void setClassName(String className) {this.className = className;}public String getHobby() {return hobby;}public void setHobby(String hobby) {this.hobby = hobby;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", sex=" + sex +", age=" + age +", className='" + className + '\'' +", hobby='" + hobby + '\'' +'}';}
}

public class Teacher {private String name;private double saraly;private char sex;public Teacher() {}public Teacher(String name, double saraly, char sex) {this.name = name;this.saraly = saraly;this.sex = sex;}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getSaraly() {return saraly;}public void setSaraly(double saraly) {this.saraly = saraly;}public char getSex() {return sex;}public void setSex(char sex) {this.sex = sex;}@Overridepublic String toString() {return "Teacher{" +"name='" + name + '\'' +", saraly=" + saraly +", sex=" + sex +'}';}
}

编写一个工具类

public class MybatisUtil {/*** 保存任意类型的对象** @param obj*/public static void save(Object obj) {try (PrintStream ps = new PrintStream(new FileOutputStream("junit-reflect-annotation-proxy-app/src/data.txt", true));) {//1.提取这个对象的全部成员变量，只有反射可以解决Class c = obj.getClass();ps.println("===========" + c.getSimpleName() + "==========");//(c.getSimpleName()获取当前类， c.getName获取全限名：包名+类名）//2.提取全部类的成员变量Field[] fields = c.getDeclaredFields();//3.遍历，获取成员变量的信息for (Field field : fields) {String name = field.getName();//提取本成员变量在obj对象中的值（取值）field.setAccessible(true);String value = field.get(obj) + "";ps.println(name + "=" + value);}} catch (Exception e) {e.printStackTrace();}}
}

来测试

/**提供一个通用框架，支持保存所有对象的信息*/
public class ReflectDemo {public static void main(String[] args) {Student s = new Student("csl",'男',25,"十三班","钓鱼");MybatisUtil.save(s);Teacher t = new Teacher("王老师",6666,'女');MybatisUtil.save(t);}
}
output:
===========Student==========
===========Teacher==========
===========Student==========
name=csl
sex=男
age=25
className=十三班
hobby=钓鱼
===========Teacher==========
name=王老师
saraly=6666.0
sex=女

小结

——反射的作用

可以在运行时得到一个类的全部成分然后操作。
也可以破坏封装性
也可以破坏泛型的约束性
更适合的用途适合：做Java高级框架

注解

注解概述

Java注解（Annotation）又称Java标注，是JDK5.0引入的一种注释机制。
Java语言中的类、构造器、方法、成员变量、参数等都可以被注解进行标注。

注解的作用是什么呢？

对Java中类、方法、成员变量做标记，然后进行特殊处理，至于到底作何种处理由业务需求来决定。
例如：Junit框架中，标记了注解@Test的方法就可以被当成测试方法执行，而没有标记的就不能当成测试方法执行。

自定义注解

自定义注解——格式

就是自己做一个注解来使用

public @interface 注解名称{public 属性名称  属性名( )  default 默认值 ;
}

自定义一个注解

public @interface MyBook {String name();String[] authors();double price();
}

/**自定义注解*/
@MyBook(name = "《四大名著》",authors = {"罗贯中","吴承恩","曹雪芹","施耐庵"},price = 222)
public class AnnotationDemo1 {@MyBook(name = "《四大名著》",authors = {"罗贯中","吴承恩","曹雪芹","施耐庵"},price = 222)private AnnotationDemo1(){}@MyBook(name = "《四大名著》",authors = {"罗贯中","吴承恩","曹雪芹","施耐庵"},price = 222)public static void main(String[] args) {@MyBook(name = "《四大名著》",authors = {"罗贯中","吴承恩","曹雪芹","施耐庵"},price = 222)int age = 23;}
}

特殊属性

value属性，如果只有一个value属性的情况下，使用value属性的时候可以省略value名称不写！！
但是如果有多个属性，且多个属性没有默认值，那么value名称是不能省略的。

元注解

元注解：就是注解注解的注解。

元注解有两个：

@Target：约束自定义注解只能在哪些地方使用
@Retention：申明注解的声明周期

/**元注解*/
@Target({ElementType.METHOD,ElementType.CONSTRUCTOR})//元注解
@Retention(RetentionPolicy.RUNTIME)//一直活着，在运行阶段这个注解也不消失
public @interface MyTest {}

//@MyTest//报错
public class AnnotationDemo2 {@MyTestpublic AnnotationDemo2(){}@MyTestpublic static void main(String[] args) {}
}

@Target中可以使用的值定义在ElementType枚举类中，常用值如下

TYPE，类，接口
FIELD，成员变量
METHOD，成员方法
PARAMETER，方法参数
CONSTRUCTOR，构造器
LOCAL_VARIBLE，局部变量

@Retention中可以使用的值定义在RetentionPolicy枚举类中，常用值如下

SOURCE：注解只作用在源码阶段，生成的字节码文件中不存在
ClASS：注解作用在源码阶段，字节码文件阶段，运行阶段不存在，默认值。
RUNTIME：注解作用在源码阶段，字节码文件阶段，运行阶段（开发常用）

注解解析

注解的解析

注解的操作中经常需要进行解析，注解的解析就是判断是否存在注解，存在注解就解析出内容。

与注解解析相关的接口

Annotation：注解的顶级接口，注解都是Annotation类型的对象
AnnotatedElement：该接口定义了与注解解析相关的解析方法

方法	说明
Annotation[ ] getDeclaredAnnotations( )	获的当前对象上使用的所有注解，返回注解数组
T getDeclaredAnnotation(Class annotationClass)	根据注解类型获得对应注解对象
boolean isAnnotationPresent(Class annotationClass)	判断当前对象是否使用了指定的注解，如果使用返回true，否则返回false

所有类成分Class，Method，Field，Constructor，都实现了AnnotatedElement接口他们都拥有解析注解的能力：

解析注解的技巧

注解在哪个成分上，我们就先拿哪个成分对象。
比如注解作用成员方法，则要获得该成员方法对于的Method对象，再来拿上面的注解
类和成员变量如上

案例：注解解析的案例

**需求：**注解解析的案例

分析：

定义注解Book ，要求如下：
1. 包含属性：String value( ) 书名
2. 包含属性：double price( ) 价格
3. 包含属性： String[ ] authors( ) 多位作者
4. 限制注解使用的位置：类和成员方法上
5. 指定注解的有效范围：RUNTIME
定义BookStores类，在类和成员方法上使用Book注解
定义AnnotationDemo01测试类获取Book注解上的数据

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD,ElementType.TYPE})
public @interface Book {String value();//书名double price();//价格String[] authors();//多位作者
}

/*** 完成注解的解析*/
public class AnnotationDemo03 {@Testpublic void parseClass() {//a.先得到类对象Class c = BookStore.class;//b.判断这个类上是否有Book.class这个注解if (c.isAnnotationPresent(Book.class)) {Book book = (Book) c.getDeclaredAnnotation(Book.class);System.out.println(book.value());System.out.println(book.price());System.out.println(Arrays.toString(book.authors()));}}@Testpublic void parseMethod() throws Exception {//a.先得到类对象Class c = BookStore.class;Method m = c.getDeclaredMethod("test");//b，判断这个类上是否有这个注解if (m.isAnnotationPresent(Book.class)){//c.直接获取注解对象Book book = (Book) m.getDeclaredAnnotation(Book.class);System.out.println(book.value());System.out.println(book.price());System.out.println(Arrays.toString(book.authors()));}}
}@Book(value = "《开端》", price = 100.9, authors = {"赵今麦", "白敬亭"})
class BookStore {@Book(value = "《葫芦娃》", price = 99.0, authors = {"水娃", "小金刚", "铁头娃"})public void test() {}
}output:
《开端》
100.9
[赵今麦, 白敬亭]
《葫芦娃》
99.0
[水娃, 小金刚, 铁头娃]

注解的应用场景一：Junit框架

模拟Junit框架

需求：

定义若干个方法，只要加了MyTes1t注解，就可以在启动时被触发执行

分析：

定义一个自定义注解MyTest1，只能注解方法，存活范围一直都在。
定义若干个方法，只要有@MyTest1注解的方法就能在启动时被触发执行，没有这个注解的方法不能执行

@Target({ElementType.METHOD})//元注解
@Retention(RetentionPolicy.RUNTIME)//一直活着，在运行阶段这个注解也不消失
public @interface MyTest1 {}

public class AnnotationDemo4 {@MyTest1public void test1(){System.out.println("========test1========");}public void test2(){System.out.println("========test2========");}@MyTest1public void test3(){System.out.println("========test3========");}public static void main(String[] args) throws Exception {AnnotationDemo4 t = new AnnotationDemo4();//a.获取类对象Class c = AnnotationDemo4.class;//b.提取全部方法Method[] methods = c.getDeclaredMethods();//c.遍历方法，判断方法中是否有该注解，有就跑它for (Method method : methods) {if (method.isAnnotationPresent(MyTest1.class)){method.invoke(t);}}}
}
output:
========test3========
========test1========

动态代理

案例：模拟企业业务功能开发，并完成每个功能的性能统计

需求：

模拟某企业用户管理业务，需要包含用户登录，用户删除，用户查询功能，并要统计每个功能的耗时。

分析：

定义一个UserService表示用户业务接口，规定必须完成用户登录，用户删除，用户查询功能。
定义一个实现类UserServiceImpl实现UserService，并完成相关功能，且统计每个功能的耗时。
定义测试类，创建实现类现象，调用方法。

/**模拟用户业务功能*/
public interface UserSerivce {String login(String loginName,String passWord);void selectUsers();boolean delUsers();
}

package com.csl.d9_proxy;public class UserSerivceImpl implements UserSerivce {@Overridepublic String login(String loginName, String passWord) {long startTime = System.currentTimeMillis();try {Thread.sleep(1000);if ("admin".equals(loginName) && "12345".equals(passWord)) {return "success";}return "登录名或密码有问题！";} catch (Exception e) {e.printStackTrace();return "error";} finally {long endTime = System.currentTimeMillis();System.out.println("login方法耗时：" + (endTime - startTime) / 1000.0 + "s");}}@Overridepublic void selectUsers() {long startTime = System.currentTimeMillis();System.out.println("查询了一百个用户！");try {Thread.sleep(2000);} catch (Exception e) {e.printStackTrace();}long endTime = System.currentTimeMillis();System.out.println("selectUsers方法耗时：" + (endTime - startTime) / 1000.0 + "s");}@Overridepublic boolean delUsers() {long startTime = System.currentTimeMillis();try {System.out.println("删除了一百个数据！");Thread.sleep(500);return true;} catch (Exception e) {e.printStackTrace();return false;} finally {long endTime = System.currentTimeMillis();System.out.println("delUsers方法耗时：" + (endTime - startTime) / 1000.0 + "s");}}
}

public class Test {public static void main(String[] args) {UserSerivce userSerivce = new UserSerivceImpl();System.out.println(userSerivce.login("admin", "12345"));userSerivce.selectUsers();System.out.println(userSerivce.delUsers());}
}
output:
login方法耗时：1.019s
success
查询了一百个用户！
selectUsers方法耗时：2.011s
删除了一百个数据！
delUsers方法耗时：0.502s
true

动态代理

代理就是被代理者没有能力或者不愿意去完成某件事，需要找个人替自己去完成这件事，动态代理就是用来对业务功能（方法）进行代理的。

关键步骤

必须有接口，实现类要实现接口（代理通常是基于接口实现的）
创建一个实现类对象，该对象为业务对象，紧接着为业务对象做一个代理对象

/**模拟用户业务功能*/
public interface UserSerivce {String login(String loginName,String passWord);void selectUsers();boolean delUsers();
}

package com.csl.d9_proxy;public class UserSerivceImpl implements UserSerivce {@Overridepublic String login(String loginName, String passWord) {try {Thread.sleep(1000);if ("admin".equals(loginName) && "12345".equals(passWord)) {return "success";}return "登录名或密码有问题！";} catch (Exception e) {e.printStackTrace();return "error";}}@Overridepublic void selectUsers() {System.out.println("查询了一百个用户！");try {Thread.sleep(2000);} catch (Exception e) {e.printStackTrace();}}@Overridepublic boolean delUsers() {try {System.out.println("删除了一百个数据！");Thread.sleep(500);return true;} catch (Exception e) {e.printStackTrace();return false;}}
}

package com.csl.d9_proxy;public class Test {public static void main(String[] args) {UserSerivce userSerivce = ProxyUtil.getProxy(new UserSerivceImpl());System.out.println(userSerivce.login("admin", "12345"));userSerivce.selectUsers();System.out.println(userSerivce.delUsers());}
}
output:
login方法耗时：1.012s
success
查询了一百个用户！
selectUsers方法耗时：2.01s
删除了一百个数据！
delUsers方法耗时：0.502s
true

/*** public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)* 参数一：类加载器，负责加载代理类到内存中使用* 参数二：获取被代理对象实现的全部接口。代理要为全部接口的全部方法进行代理* 参数三：代理的核心处理逻辑*/
public class ProxyUtil {/*** 生成业务对象的代理对象** @param obj* @return*/public static <T> T getProxy(T obj) {//  返回了一个代理对象return (T) Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//参数一：代理对象本身//参数二：正在被代理的方法//参数三：被代理方法应该传入的参数long startTime = System.currentTimeMillis();// 马上触发方法的真正执行(触发真正的业务功能）Object result = method.invoke(obj, args);long endTime = System.currentTimeMillis();System.out.println(method.getName() + "方法耗时：" + (endTime - startTime) / 1000.0 + "s");//把业务功能方法执行的结果返回给调用者return result;}});}
}

动态代理的优点

非常的灵活，支持任意接口类型的实现类对象做代理，也可以直接为接口本身做代理。
可以为被代理对象的所有方法做代理
可以在不改变方法源码的情况下，实现对方法功能的增强。
不仅简化了编程工作、提高了软件系统的可拓展性，同时也提高了开发效率。

JavaSE——单元测试、反射、注解、动态代理相关推荐

死磕java底层（三）—反射、动态代理和注解
1.反射介绍 1.1反射反射是指程序可以访问,检测,修改它本身状态或行为的一种能力. 1.2java的反射机制 java的反射机制是指在程序运行状态中,给定任意一个类,都可以获取到这个类的属性和方法 ...
Android APP热更新中的插件化（Hook技术：反射或动态代理），Demo (2)
修改AAPT,资源分区,用于Android插件化- https://github.com/BaoBaoJianqiang/AAPT -- Android下的挂钩(hook)和代码注入(inject) ...
java底层 —反射、动态代理
java底层 -反射.动态代理和注解 1. 反射介绍 1.1 反射反射是指程序可以访问,检测,修改它本身状态或行为的一种能力. 1.2 java的反射机制 java的反射机制是指在程序运行状态中,给 ...
通过反射创建动态代理对象(二)
2019独角兽企业重金招聘Python工程师标准>>> 一.概述将"通过反射创建动态代理对象(一)"合二为一二.代码说明 package staticimpo ...
MyBatis源码解析【4】反射和动态代理
通过之前的介绍,我们了解了几个组件的生命周期. 它也是我们重要装备之一. 今天我们需要搞一件更加强的装备,叫做反射和动态代理. 如果没有这件装备的话,显然后面的源码boss是打不动的. 顺便说一下,下 ...
Java提高班（六）反射和动态代理（JDK Proxy和Cglib）
反射和动态代理放有一定的相关性,但单纯的说动态代理是由反射机制实现的,其实是不够全面不准确的,动态代理是一种功能行为,而它的实现方法有很多.要怎么理解以上这句话,请看下文. 一.反射反射机制是 Ja ...
通过反射创建动态代理对象(三)
2019独角兽企业重金招聘Python工程师标准>>> 一.概述传入目标对象和Advice(要执行的内容)对"通过反射创建动态代理对象(二)"进行改造(AOP框 ...
android hook底层代码_Java-Hook技术-入门实践(反射、动态代理)-Hook拦截通知(当前App/Context)...
老样子,上一篇MonkeyLei:Java-Hook技术-入门实践+反射.动态代理.热修复再看看我们Hook学习了一下,一个是Java本地Main的实践练习. 一个是Android的监听事件的Hoo ...
十七、反射与动态代理
文章目录 1.Java反射机制概述 1.1 使用反射,实现同上的操作 1.2 反射的强大:调用类的私有结构 2.理解Class类并获取Class实例 2.1 Class类的理解 2.2 获取Class ...
支撑Java框架的基础技术：泛型，反射，动态代理，cglib
以Spring为例要想看明白他的源码需要彻底理解Java的一些基础技术泛型,反射同时对于一些高级技术例如动态代理,cglib和字节码技术也需要掌握,下面就按章节来一一说清楚这些技术的核心部分,最后手写 ...

JavaSE——单元测试、反射、注解、动态代理