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

news/2024/5/19 3:02:10 标签: 单元测试, 反射, 动态代理, java

文章目录

单元测试

单元测试概述

单元测试

  • 单元测试就是针对最小的功能单元编写测试代码，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运行” ， 如果测试良好则是绿色；如果测试失败，则是红色
java">/**
 * 业务方法
 */
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("查询全部用户名称成功！");
    }
}

java">/**
    测试类
 */
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用来修饰静态方法，该方法会在所有测试方法之后执行一次
  • 开始执行的方法：初始化资源。
  • 执行完之后的方法：释放资源。
java">/**
    测试类
 */
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的全部成分。
java">HelloWorld.java -> javac -> HelloWorld.class
Class c = HelloWorld.class;
  1. 反射的基本作用、关键？
    • 反射是在运行时获取类的字节码文件对象：然后可以解析类中的全部成分
    • 反射的核心思想和关键就是：得到编译以后的class文件对象。

反射获取类对象

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

java">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
  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)返回单个构造器对象，存在就能拿到
java">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，表示取消访问检查，进行暴力反射
java">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 +
                '}';
    }
}

java">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}
  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)返回单个成员变量对象，存在就能拿到
java">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)获取值
java">/**
 * 反射获取成员变量：取值和赋值
 */
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

小结

  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 )返回单个成员方法对象，存在就能拿到
java">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;
    }
}

java">/**
 * 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对象调用该方法
参数二：调用方法传递的参数(如果没有就不写)
返回值：方法的返回值（如果没有就不写）
java">    /**
        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
狗吃骨头
吃的很开心！

小结：

  1. 利用反射技术获取成员方法对象的方式
  • 获取类中成员方法对象
    • getDeclaredMethods( )
    • getDeclaredMethod(String name,Class<?>… parameterTypes)
  1. 反射得到成员方法可以做什么？
  • 依然是在某个对象中触发该方法执行
    • Object invoke(Object obj, Object… args)
  • 如果某成员方法是非public的，需要打开权限（暴力反射），然后再触发执行
    • setAccessible(boolean)

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

  • 反射的作用是在运行时的技术，此时集合的泛型将不能产生约束了，此时是可以为集合存入其他任意类型的元素的。
java">ArrayList<Integer> list = new ArrayList<>();
list.add(100);
list.add("csl");//报错
list.add(99);
  • 泛型只是在编译阶段可以约束集合只能操作某种数据类型，在编译成Class文件进入运行阶段的时候，其真是类型都是ArrayList了，泛型相当于被擦除了。。
java">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文件进入编译阶段的时候，泛型会自动擦除。
  • 反射是作用在运行时的技术，此时已经不存在泛型了。

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

案例：反射做通用框架

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

分析：

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

java">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 +
                '}';
    }
}
  • 编写一个工具类
java">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();
        }

    }
}
  • 来测试
java">/**
    提供一个通用框架，支持保存所有对象的信息
 */
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的方法就可以被当成测试方法执行，而没有标记的就不能当成测试方法执行。

自定义注解

自定义注解——格式

  • 就是自己做一个注解来使用
java">public @interface 注解名称{
    public 属性名称	属性名( )	default	默认值	;
}
  • 自定义一个注解
java">public @interface MyBook {
    String name();
    String[] authors();
    double price();
}

java">/**
    自定义注解
 */
@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：申明注解的声明周期
java">/**
    元注解
 */
@Target({ElementType.METHOD,ElementType.CONSTRUCTOR})//元注解
@Retention(RetentionPolicy.RUNTIME)//一直活着，在运行阶段这个注解也不消失
public @interface MyTest {
}

java">//@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 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注解上的数据
java">@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD,ElementType.TYPE})
public @interface Book {
    String value();//书名
    double price();//价格
    String[] authors();//多位作者
}

java">/**
 * 完成注解的解析
 */
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注解，就可以在启动时被触发执行

分析：

  1. 定义一个自定义注解MyTest1，只能注解方法，存活范围一直都在。
  2. 定义若干个方法，只要有@MyTest1注解的方法就能在启动时被触发执行，没有这个注解的方法不能执行
java">@Target({ElementType.METHOD})//元注解
@Retention(RetentionPolicy.RUNTIME)//一直活着，在运行阶段这个注解也不消失
public @interface MyTest1 {
}

java">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，并完成相关功能，且统计每个功能的耗时。
  • 定义测试类，创建实现类现象，调用方法。
java">/**
    模拟用户业务功能
 */
public interface UserSerivce {
    String login(String loginName,String passWord);
    void selectUsers();
    boolean delUsers();
}

java">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");
        }
    }
}

java">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. 创建一个实现类对象，该对象为业务对象，紧接着为业务对象做一个代理对象

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

java">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;
        }
    }
}

java">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

java">/**
 * 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;
                    }
                });

    }
}

动态代理的优点

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

http://www.niftyadmin.cn/n/1367845.html

相关文章

JavaSE——XML、解析、设计模式

JavaSE——XML、解析、设计模式

文章目录XMLXML概述XML的创建、语法规则XML文档约束方式一、DTD约束文档的约束方式二-schema约束XML解析技术XML解析技术概述Dom4J解析XML文件Dom4J解析XML文件中的各种节点Dom4J解析XML文件-案例实战XML检索技术&#xff1a;Xpath设计模式&#xff1a;工厂模式设计模式&#x…
阅读更多...
JDBC详

JDBC详

文章目录JDBC1&#xff0c;JDBC概述1.1 JDBC概念1.2 JDBC本质1.3 JDBC好处2&#xff0c;JDBC快速入门2.1 编写代码步骤2.2 具体操作3&#xff0c;JDBC API详解3.1 DriverManager3.2 Connection3.2.1 获取执行对象3.2.2 事务管理3.3 Statement3.3.1 概述3.3.2 代码实现3.4 Resul…
阅读更多...
MavenMybatis

MavenMybatis

文章目录Maven&MyBatis1&#xff0c;Maven1.1 Maven简介1.1.1 Maven模型1.1.2 仓库1.2 Maven安装配置1.3 Maven基本使用1.3.1 Maven 常用命令1.3.2 Maven 生命周期1.4 IDEA使用Maven1.4.1 IDEA配置Maven环境1.4.2 Maven 坐标详解1.4.3 IDEA 创建 Maven项目1.4.4 IDEA 导入 …
阅读更多...
Mybatis练习CRUD

Mybatis练习CRUD

文章目录Mybatis练习1&#xff0c;配置文件实现CRUD1.1 环境准备1.2 查询所有数据1.2.1 编写接口方法1.2.2 编写SQL语句1.2.3 编写测试方法1.2.4 起别名解决上述问题1.2.5 使用resultMap解决上述问题1.2.6 小结1.3 查询详情1.3.1 编写接口方法1.3.2 编写SQL语句1.3.3 编写测试方…
阅读更多...
JSPEL表达式MVC三层结构综合案例

JSPEL表达式MVC三层结构综合案例

文章目录JSP1&#xff0c;JSP 概述2&#xff0c;JSP 快速入门2.1 搭建环境2.2 导入 JSP 依赖2.3 创建 jsp 页面2.4 编写代码2.5 测试3&#xff0c;JSP 原理4&#xff0c;JSP 脚本4.1 JSP 脚本分类4.2 案例4.2.1 需求4.2.2 实现4.2.3 成品代码4.2.4 测试4.3 JSP 缺点5&#xff0…
阅读更多...
CookieSession(会话技术)

CookieSession(会话技术)

文章目录会话技术1&#xff0c;会话跟踪技术的概述2&#xff0c;Cookie2.1 Cookie的基本使用2.2 Cookie的原理分析2.3 Cookie的使用细节2.3.1 Cookie的存活时间2.3.2 Cookie存储中文3&#xff0c;Session3.1 Session的基本使用3.2 Session的原理分析3.3 Session的使用细节3.3.1…
阅读更多...
FilterListenerAjax

FilterListenerAjax

文章目录Filter&Listener&Ajax1&#xff0c;Filter1.1 Filter概述1.2 Filter快速入门1.2.1 开发步骤1.2.2 代码演示1.3 Filter执行流程1.4 Filter拦截路径配置1.5 过滤器链1.5.1 概述1.5.2 代码演示1.5.3 问题1.6 案例1.6.1 需求1.6.2 分析1.6.3 代码实现1.6.3.1 创建F…
阅读更多...
JavaWeb阶段综合案例

JavaWeb阶段综合案例

文章目录综合案例1&#xff0c;功能介绍2&#xff0c;环境准备2.1 工程准备2.2 创建表3&#xff0c;查询所有功能3.1 后端实现3.1.1 dao方法实现3.1.2 service方法实现3.1.3 servlet实现3.1.4 测试后端程序3.2 前端实现4&#xff0c;添加功能4.1 后端实现4.1.1 dao方法实现4.1.…
阅读更多...
最新文章

Copyright @ 2022~2023