单元测试

单元测试概述

单元测试

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

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

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

Junit单元测试框架

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

Junit优点

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

小结

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

单元测试快速入门

步骤：单元测试快速入门

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

分析：

1. 将Junit的jar包导入到项目中
   • IDEA通常整合好了Junit框架，一般不需要导入。
   • 如果IDEA没有整合好，需要自己手动导入Junit的2个jar包到模块
2. 编写测试方法：该测试方法必须是公共的无参数无返回值的非静态方法
3. 在测试方法上使用@Test注解：标注该方法是一个测试方法
4. 在测试方法中完成被测试方法的预期正确性测试
5. 选择测试方法，选择“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;

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

1. 反射的第一步是什么？
   • 获取Class类对象，如此才可以解析类的全部成分。
2. 获取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}

1. 利用反射技术获取构造器对象的方式
   • getDeclaredConstructors( )
   • getDeclaredConstructor(Class<?>… parameterTypes)
2. 反射得到的构造器可以做什么？
   • 依然是创建对象的
     • 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

小结

1. 利用反射技术获取成员变量的方式
   • getDeclaredFileds( )
   • getDeclaredFiled(String name)
2. 反射得到成员变量可以做什么？
   • 依然是在某个对象中取值和赋值
     • 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
狗吃骨头
吃的很开心！

小结：

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

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

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

• 依然是在某个对象中触发该方法执行
  • 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文件进入编译阶段的时候，泛型会自动擦除。
• 反射是作用在运行时的技术，此时已经不存在泛型了。

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

案例：反射做通用框架

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

分析：

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

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

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对象，再来拿上面的注解
• 类和成员变量如上

案例：注解解析的案例

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

分析：

1. 定义注解Book ，要求如下：
   1. 包含属性：String value( ) 书名
   2. 包含属性：double price( ) 价格
   3. 包含属性： String[ ] authors( ) 多位作者
   4. 限制注解使用的位置：类和成员方法上
   5. 指定注解的有效范围：RUNTIME
2. 定义BookStores类，在类和成员方法上使用Book注解
3. 定义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注解，就可以在启动时被触发执行

分析：

1. 定义一个自定义注解MyTest1，只能注解方法，存活范围一直都在。
2. 定义若干个方法，只要有@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

动态代理

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

关键步骤

1. 必须有接口，实现类要实现接口（代理通常是基于接口实现的）

2. 创建一个实现类对象，该对象为业务对象，紧接着为业务对象做一个代理对象

/**模拟用户业务功能*/
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;}});}
}

动态代理的优点

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