单元测试、反射、注解、动态代理
目录
单元测试
单元测试概述
单元测试
- 单元测试就是针对最小的功能单元编写测试代码，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注解标记
*/
@Test
public void testLoginName(){
UserService userService = new UserService();
String rs = userService.loginName("admin","123456");
//进行预期结果的正确性测试：断言
Assert.assertEquals("您的业务功能可能出现问题","登录成功",rs);
}
@Test
public void testSelectNames(){
UserService userService = new UserService();
userService.selectNames();
}
}
output:
output:
单元测试常用注解
Junit常用注解（Junit 4.xxxx版本)
| 注解 | 说明 |
|---|---|
| @Test | 测试方法 |
| @Before | 用来修饰实例方法，该方法会在每一个测试方法执行之前执行一次 |
| @After | 用来修饰实例方法，该方法会在每一个测试方法执行之后执行一次 |
| @BeforeClass | 用来修饰静态方法，该方法会在所有测试方法执行之前执行一次 |
| @AfterClass | 用来修饰静态方法，该方法会在所有测试方法之后执行一次 |
- 开始执行的方法：初始化资源。
- 执行完之后的方法：释放资源。
/**
测试类
*/
public class TestUserService {
//修饰实例方法的
@Before
public void before(){
System.out.println("======before方法执行一次=======");
}
@After
public void after(){
System.out.println("========after方法执行一次=========");
}
//修饰静态方法的
@BeforeClass
public static void beforeClass(){
System.out.println("========beforeClass方法执行一次=========");
}
@AfterClass
public static void afterClass(){
System.out.println("========afterClass方法执行一次=========");
}
/**
测试方法
注意点：
1.必须是公开的，无参数，无返回值的方法
2.测试方法必须使用@Test注解标记
*/
@Test
public void testLoginName(){
UserService userService = new UserService();
String rs = userService.loginName("admin","123456");
//进行预期结果的正确性测试：断言
Assert.assertEquals("您的业务功能可能出现问题","登录成功",rs);
}
@Test
public 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.类名.class
Class 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 |
返回单个构造器对象（只能拿public的） |
| Constructor |
返回单个构造器对象，存在就能拿到 |
public class TestStudent01 {
//1.getConstructors:
//获取全部的构造器：只能获取public修饰的构造器
//Constructor[] getConstuctors()
@Test
public 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();
//获取全部的构造器，无所谓权限是否可及
@Test
public 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修饰的某个构造器
@Test
public void getConstructor() throws Exception {
//a.获取类对象
Class c = Student.class;
//b.定位单个构造器对象(按照参数定位无参数的构造器）
Constructor cons = c.getConstructor();
System.out.println(cons.getName() + "===>" + cons.getParameterCount());
}
//4.getDeclaredConstructor
//获取某个构造器：只要存在的都可以拿到不考虑修饰符
@Test
public 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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class TestStudent02 {
//1.调用一个构造器得到一个类的对象返回
@Test
public 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对象，只要申明了就能拿到
*/
@Test
public 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)
*/
@Test
public 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 {
@Test
public 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,获取某个方法对象
*/
@Test
public 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.class
System.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;
}
@Override
public 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;
}
@Override
public 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 {
@MyTest
public AnnotationDemo2(){
}
@MyTest
public 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 |
根据注解类型获得对应注解对象 |
| boolean isAnnotationPresent(Class |
判断当前对象是否使用了指定的注解，如果使用返回true，否则返回false |
- 所有类成分Class，Method，Field，Constructor，都实现了AnnotatedElement接口他们都拥有解析注解的能力：
解析注解的技巧
- 注解在哪个成分上，我们就先拿哪个成分对象。
- 比如注解作用成员方法，则要获得该成员方法对于的Method对象，再来拿上面的注解
- 类和成员变量如上
案例：注解解析的案例
需求：注解解析的案例
分析：
- 定义注解Book ，要求如下：
- 包含属性：String value( ) 书名
- 包含属性：double price( ) 价格
- 包含属性： String[ ] authors( ) 多位作者
- 限制注解使用的位置：类和成员方法上
- 指定注解的有效范围：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 {
@Test
public 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()));
}
}
@Test
public 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 {
@MyTest1
public void test1(){
System.out.println("========test1========");
}
public void test2(){
System.out.println("========test2========");
}
@MyTest1
public 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 {
@Override
public 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");
}
}
@Override
public 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");
}
@Override
public 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 {
@Override
public 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";
}
}
@Override
public void selectUsers() {
System.out.println("查询了一百个用户！");
try {
Thread.sleep(2000);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public 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() {
@Override
public 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;
}
});
}
}
动态代理的优点
- 非常的灵活，支持任意接口类型的实现类对象做代理，也可以直接为接口本身做代理。
- 可以为被代理对象的所有方法做代理
- 可以在不改变方法源码的情况下，实现对方法功能的增强。
- 不仅简化了编程工作、提高了软件系统的可拓展性，同时也提高了开发效率。
