20天深度复习JavaSE的详细笔记(十九)——单元测试、反射、注解

原创 已于 2022-09-17 10:20:13 修改 · 579 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#java #后端 #开发语言
于 2022-09-17 10:19:40 首次发布
本文深入探讨了Java单元测试、反射、注解等高级技术，包括Junit单元测试的使用方法与优势、反射机制的基本原理及其应用案例、注解的设计与解析等内容。

文章目录

Demo19-Java高级技术：单元测试、反射、注解

1.Junit单元测试

1.1单元测试概述

1.单元测试:

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

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

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

3.Junit单元测试框架

  • JUnit是使用Java语言实现的单元测试框架，它是开源的，Java开发者都应当学习并使用JUnit编写单元测试
  • 此外，几乎所有的IDE工具都集成了JUnit，这样我们就可以直接在IDE中编写并运行JUnit测试，JUnit目前最新版本是5

4.Junit优点

  • JUnit可以灵活的选择执行哪些测试方法，可以一键执行全部测试方法。

  • Junit可以生成全部方法的测试报告。如果测试良好是绿色;如果测试失败是红色

  • 单元测试中的某个方法测试失败了，不会影响其他测试方法的测试。

1.2单元测试快速入门及常用注解

1.Junit单元测试步骤:

  • 将Unit的jar包导入到项目中

    • IDEA通常整合好了Junit框架,一般不需要导入,只要我们在第一次使用的时候联网,IDEA就会自动将Junit的jar包下载,从此以后再使用时也不需要自己导入jar包了

    • 如果IDEA没有整合好,需要自己手动导入如下两个Junit的jar包到模块

在这里插入图片描述

  • 编写测试方法:该测试方法必须是公共的无参数无返回值的非静态方法

  • 在测试方法上使用@Test注解：标注该方法是一个测试方法

  • 在测试方法中完成被测试方法的预期正确性测试。

  • 选中测试方法，选择“JUnit运行” ，如果测试良好则是绿色；如果测试失败，则是红色

2.Junit常用注解(Junit 4.xxxx版本)

注解(括号中是Junit5.xxxx版本的注解,作用不变,名字变了)说明
@Test测试方法
@Before(@BeforeEach)用来修饰实例方法，该方法会在每一个测试方法执行之前执行一次
@After(@AfterEach)用来修饰实例方法，该方法会在每一个测试方法执行之前执行一次
@BeforeClass(@BeforeAll)用来静态修饰方法，该方法会在所有测试方法之前只执行一次(由类来调,所以需要是静态方法)
@AfterClass(@AfterAll)用来静态修饰方法，该方法会在所有测试方法之后只执行一次(由类来调,所以需要是静态方法)
  • 开始执行的方法:初始化资源
  • 执行完之后的方法:释放资源
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方法执行一次===");
    }
	
    //测试方法
    @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();
    }
}

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

2.反射

2.1认识反射

1.反射概述:

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

2.反射的关键:

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

    HelloWorld.java -> javac -> HelloWorld.class

    Class c = HelloWorld.class;

3.总结:反射的基本作用,关键:

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

2.2反射获取类对象

将java文件编译成字节码文件,有人会将字节码文件提取到内存中去,这样就得到了Class对象

在这里插入图片描述

  • 类名.class：JVM将使用类装载器，将类装入内存(前提是:该类还未装入内存)，不做类的初始化工作，返回Class的对象
  • Class.forName(“类全限名字符串”)：装入类，并做类的静态初始化，返回Class的对象
  • 实例对象.getClass()：对类进行静态初始化、非静态初始化；返回引用运行时真正所指的对象(因为:子对象的引用会赋给父对象的引用变量中,如Animal a = new Dog();)所属的类的Class的对象

生成Class对象的过程：

  • 当我们编写一个新的java类时,JVM就会帮我们编译成class对象,存放在同名的.class文件中。在运行时，当需要生成这个类的class对象，JVM就会检查此类是否已经装载内存中。
    • 若是装载，看是否还需要做类的初始化(1.静态初始化或2.静态初始化,非静态初始化或3.非静态初始化),如果需要,就初始化完成后由返回class对象,如果不需要,直接返回class对象
    • 若是没有装载，则把.class文件以特定方式(1.不做类的初始化或2.做类的静态初始化或3.做类的静态初始化,非静态初始化)然后装入到内存中并返回class对象
public class GetClassTest {
    @Test
    public void test() throws ClassNotFoundException {
        Class<?> clz = Person.class;
        System.out.println("//////////////");
        clz = Class.forName("com.itheima.d2_reflect_class.Person");
        System.out.println("//////////////");
        clz = new Person().getClass();
    }
}

public class Person {
    static {
        System.out.println("Person：静态代码块");
    }
    {
        System.out.println("Person：动态代码块");
    }
    public Person(){
        System.out.println("Person：构造方法");
    }
}

执行结果:

//////////////
Person：静态代码块
//////////////
Person：动态代码块
Person：构造方法

2.3反射获取构造器对象并用该构造器对象创建实例对象

Class类中用于获取构造器的方法:

方法说明
Constructor<?>[] getConstructors()返回所有构造器对象的数组(只能拿public的)
Constructor<?>[] getDeclaredConstructors()返回所有构造器对象的数组，存在就能拿到
Constructor getConstructor(Class<?>… parameterTypes)返回单个构造器对象(1.只能拿public的2.参数是可变参数,且是构造器形参类型对应的class对象)
Constructor getDeclaredConstructor(Class<?>… parameterTypes)返回单个构造器对象，存在就能拿到(参数是可变参数,且是构造器形参类型对应的class对象)

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

方法说明
T newInstance(Object… initargs) >根据指定的构造器创建实例对象
public void setAccessible(boolean flag)设置为true,表示取消访问检查，进行暴力反射
public class TestStudent01 {
    @Test
    public void getConstructors(){
        Class c = Student.class;
        // 提取类中的全部的构造器对象(这里只能拿public修饰的构造器)
        Constructor[] constructors = c.getConstructors();
        System.out.println("=====test1======");
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());
        }
    }

    @Test
    public void getDeclaredConstructors(){
        Class c = Student.class;
        Constructor[] constructors = c.getDeclaredConstructors();//任何权限的构造器都可以拿到
        System.out.println("=====test2======");
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());
        }
    }

    @Test
    public void getConstructor() throws Exception {
        Class c = Student.class;
        System.out.println("=====test3======");
        // 定位单个构造器对象 (按照参数定位无参数构造器 只能拿public修饰的某个构造器)
        Constructor cons = c.getConstructor();
        System.out.println(cons.getName() + "===>" + cons.getParameterCount());
    }

    @Test
    public void getDeclaredConstructor() throws Exception {
        Class c = Student.class;
        System.out.println("=====test4======");
        // 定位单个构造器对象 (按照参数定位无参数构造器)
        Constructor cons = c.getDeclaredConstructor();
        System.out.println(cons.getName() + "===>" + cons.getParameterCount());

        // 定位某个有参构造器
        Constructor cons1 = c.getDeclaredConstructor(String.class);
        System.out.println(cons1.getName() + "===>" + cons1.getParameterCount());
        cons1.setAccessible(true);//权限被打开
        Student s1 = (Student) cons1.newInstance("孙悟空");//参数类型是Objec类型
        System.out.println(s1);
    }
}

public class Student {
    private String name;
    public Student(){
        System.out.println("无参数构造器执行！");
    }
    private Student(String name) {
        System.out.println("有参数构造器执行！");
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}

注意:

  • 第43行cons.setAccessible(true);是为了取消访问检查
    • 这样的话私有的也可以执行了,所以说反射可以破坏封装性
    • 如果是非public的构造器,需要用这行代码暴力反射打开权限,且只能变量cons1使用,下次再执行c.getDeclaredConstructor().newInstance(“孙悟空”);获得新的私有构造器对象并创建实例对象时仍需这行代码打开权限,否则就报错
  • 第44行cons1.newInstance(“孙悟空”)参数类型是Object类型
    • 我认为这个构造器参数是String类型,但我这里传的是Object类型,所以我认为底层会做类型强转

2.4反射获取成员变量对象

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

方法说明
Field[] getFields()返回所有成员变量对象的数组(只能拿public的)
Field[] getDeclaredFields()返回所有成员变量对象的数组，存在就能拿到
Field getField(String name)根据名称返回单个成员变量对象(只能拿public的)
Field getDeclaredField(String name)根据名称返回单个成员变量对象，存在就能拿到
方法说明
void set(Object obj, Object value)赋值
Object get(Object obj)取值
public class FieldDemo01 {
    @Test
    public void getDeclaredFields(){
        Class c = Student.class;
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field.getName() + "==>" + field.getType());
        }
    }

    @Test
    public void getDeclaredField() throws Exception {
        Class c = Student.class;
        Field f = c.getDeclaredField("age");
        System.out.println(f.getName() +"===>" + f.getType());

        // 和构造器对象的setAccessible方法作用一样,都是暴力打开权限,且只对f有用
        f.setAccessible(true);

        // 赋值
        Student s = new Student();
        f.set(s , 18);
        System.out.println(s);

        // 取值
        int age = (int) f.get(s);
        System.out.println(age);
    }
}

public class Student {
    private String name;
    private int age;
    public static String schoolName;
    public static final String  COUNTTRY = "中国";
    public Student(){
        System.out.println("无参数构造器执行！");
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
  • 第22行f.set(s , 18);
    • 以前是对象给变量赋值:s.setAge(18);,现在是:变量对对象说:对象,来把我改成18.关系反转了,故称为反射
    • 两个形参都是Object类型,我认为和构造器的cons1.newInstance(“孙悟空”)一样,内部会进行强转

2.5反射获取方法对象

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

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

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

方法说明
Object invoke(Object obj, Object… args)称为:运行方法
参数一:用obj对象调用该方法
参数二:调用方法的传递的参数(如果没有就不写)
返回值:调用的方法的返回值(如果没有就不写)
public class MethodDemo01 {
    @Test
    public void getDeclaredMethods(){
        Class c = Dog.class;
        Method[] methods = c.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method.getName() +" 返回值类型：" + method.getReturnType() + " 参数个数：" + method.getParameterCount());
        }
    }
    
    @Test
    public void getDeclardMethod() throws Exception {
        Class c = Dog.class;
        Method m = c.getDeclaredMethod("eat");
        Method m2 = c.getDeclaredMethod("eat", String.class);

        // 暴力打开权限了
        m.setAccessible(true);
        m2.setAccessible(true);
        
        Dog d = new Dog();
        // 注意：方法如果是没有结果回来的，那么返回的是null.
        Object result = m.invoke(d);
        System.out.println(result);

        Object result2 = m2.invoke(d, "骨头");
        System.out.println(result2);
    }
}

public class Dog {
    public Dog(){
    }
    private void eat(){
        System.out.println("狗吃骨头");
    }
    private String eat(String name){
        System.out.println("狗吃" + name);
        return "吃的很开心！";
    }
    public static void inAddr(){
        System.out.println("在非洲学习Java!");
    }
}

2.6反射的作用

2.6.1绕过编译阶段为集合添加数据
  • 反射是作用在运行时的技术，此时集合的泛型将不能产生约束了，此时是可以为集合存入其他任意类型的元素的
    • 因为:泛型只是在编译阶段可以约束集合只能操作某种数据类型，在编译成Class文件进入运行阶段的时候，其真实类型都是ArrayList了，泛型相当于被擦除了。
      • 为什么编译后ArrayList,ArrayList等等的真实类型都是ArrayList呢,因为官方想实现运行时只需要一个ArrayList集合变量即可存储各种类型的数据,这样就避免了内存浪费(否则:假如源码代码中有ArrayList和ArrayList两种类型的变量,那运行时就要创建ArrayList和ArrayList两个类,并创建两个对应的集合对象存储对应的数据占用空间)
public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        // 需求：反射实现泛型擦除后，加入其他类型的元素
        ArrayList<String> lists1 = new ArrayList<>();
        ArrayList<Integer> lists2 = new ArrayList<>();

        System.out.println(lists1.getClass());
        System.out.println(lists2.getClass());

        System.out.println(lists1.getClass() ==  lists2.getClass());//true,证明了:运行时真实类型都是ArrayList

        System.out.println("---------------------------");
        ArrayList<Integer> lists3 = new ArrayList<>();
        lists3.add(23);
        lists3.add(22);
        // lists3.add("中国");//报错,因为有泛型约束

        Class c = ArrayList.class; // ArrayList.class  ===> public boolean add(E e)
        // 定位c类中的add方法
        Method add = c.getDeclaredMethod("add", Object.class);
        boolean rs = (boolean) add.invoke(lists3, "中国");
        System.out.println(rs);
        System.out.println(lists3);

        //下面这种方式也可以突破泛型,并且不需要用反射
        ArrayList list4 = lists3;
        list4.add("外国");
        list4.add(false);
        System.out.println(lists3);
    }
}
  • 反射为何可以给约定了泛型的集合存入其他类型的元素？
    • 编译成Class文件进入运行阶段的时候，泛型会自动擦除。
    • 反射是作用在运行时的技术，此时已经不存在泛型了。
2.6.2通用框架的底层原理

利用反射做通用框架:

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

分析:

  • 定义一个方法,可以接收任意类的对象
  • 每次收到一个对象后,需要解析这个对象的全部成员变量名称
    • 这个对象可能是任意的,那么怎么样才可以知道这个对象的全部成员变量名称呢:
      • 使用反射获取对象的Class类对象,然后获取全部成员变量信息
      • 遍历成员变量信息,然后提取本成员变量在对象中的具体值
public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        Student s = new Student("猪八戒",'男',1000,"西天跑路1班","吃，睡");
        MybatisUtil.save(s);
        Teacher t = new Teacher("波仔",'男',6000);
        MybatisUtil.save(t);
    }
}

public class MybatisUtil {
    public static void save(Object obj){
        try (
                PrintStream ps = new PrintStream(new FileOutputStream("Demo23-junit-reflect-annotation-proxy/src/data.txt", true));
        ){
            // 1、获得Class对象
            Class c = obj.getClass();
            // c.getSimpleName()获取当前类名   c.getName获取全限名：包名+类名
            ps.println("================" + c.getSimpleName() + "================");

            // 2、提取它的全部成员变量的值并打印
            Field[] fields = c.getDeclaredFields();
            // 3、获取成员变量的信息
            for (Field field : fields) {
                String name = field.getName();
                // 提取本成员变量在obj对象中的值（取值）
                field.setAccessible(true);
                //如果强转为字符串会报错,因为获得的值可能真实数据类型是int,double,强转报错
                String value = field.get(obj) + "";
                ps.println(name  + "=" + value);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class Student {
    private String name;
    private char sex;
    private int age;
    private String className;
    private String hobby;
    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 class Teacher {
    private String name;
    private char sex;
    private double salary;
    public Teacher(String name, char sex, double salary) {
        this.name = name;
        this.sex = sex;
        this.salary = salary;
    }
}

反射的作用:

  • 可以在运行时得到一个类的全部成分然后操作
  • 可以破坏封装性(很突出)
  • 可以破坏泛型的约束性(很突出)
  • 更重要的用途是适合:做java高级框架

3.注解

3.1认识注解

  • 注解概述:
    • java注解又称为java标注,是JDK5引入的一种注释机制
    • java语言中的类,构造器,方法,成员变量,参数等都可以被注解进行注释
  • 注解的作用:
    • 对Java中类、方法、成员变量做标记，然后进行特殊处理，至于到底做何种处理由业务需求来决定
      • 例如：JUnit框架中，标记了注解@Test的方法就可以被当成测试方法执行，而没有标记的就不能当成测试方法执行

3.2自定义注解

格式:

public @interface 注解名称 {

​ public 属性类型 属性名() default 默认值;

}

  • public是默认的,可以不写
  • 属性类型支持任意的数据类型
  • 特殊属性:
    • value属性,如果只有一个value属性的情况下,使用value属性的时候可以省略value名称不写
    • 如果有多个属性,且只有value没有默认值,此时使用value属性的时候可以省略value名称不写
    • 但是如果有多个属性,且多个属性没有默认值,那么value名称是不能省略的
@Book("/delete")
public class AnnotationDemo1 {
    @Book(value = "/delete")
    private AnnotationDemo1(){
    }
    @Book(value = "/delete", price = 25.5)
    public static void main(String[] args) {
        @Book("/delete")
        int age = 21;
    }
}

public @interface Book {
    String value(); // 特殊属性
    double price() default 9.9;
}

3.3元注解

元注解就是放在注解上面的注解(是用来注解注解的注解)

常用元注解有两个:

  • @Target:约束自定义注解只能在哪些地方使用
  • @Retention:申明注解的声明周期
    • 很多注解默认在运行阶段就消失了,可以用这个注解申明它永远活着

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

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

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

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

3.4注解解析

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

与注解解析相关的接口:

  • Annotation: 注解的顶级接口，注解都是Annotation类型的对象
  • AnnotatedElement:该接口定义了与注解解析相关的解析方法
方法说明
Annotation[] getDeclaredAnnotations()获得当前对象上使用的所有注解，返回注解数组
T getDeclaredAnnotation(Class annotationClass)根据注解类型获得对应注解对象
boolean isAnnotationPresent(Class annotationClass)判断当前对象是否使用了指定的注解，如果使用了则返回true，否则false

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

解析注解的技巧:

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

注解解析的案例:

需求:

  • 定义注解Bookk，要求如下：
    • 包含属性：String value() 书名
    • 包含属性：double price() 价格，默认值为 100
    • 包含属性：String[] authors() 多位作者
    • 限制注解使用的位置：类和成员方法上
    • 指定注解的有效范围：RUNTIME
  • 定义BookStore类，在类和成员方法上使用Bookk注解
  • 定义AnnotationDemo01测试类获取Bookk注解上的数据
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Bookk {
    String value();
    double price() default 100;
    String[] author();
}

public class AnnotationDemo3 {
    @Test
    public void parseClass(){
        // a.先得到类对象
        Class c = BookStore.class;
        // b.判断这个类上面是否存在这个注解
        if(c.isAnnotationPresent(Bookk.class)){
            //c.直接获取该注解对象
            Bookk book = (Bookk) c.getDeclaredAnnotation(Bookk.class);
            System.out.println(book.value());
            System.out.println(book.price());
            System.out.println(Arrays.toString(book.author()));
        }
    }

    @Test
    public void parseMethod() throws NoSuchMethodException {
        // a.先得到类对象
        Class c = BookStore.class;

        Method m = c.getDeclaredMethod("test");

        // b.判断这个类上面是否存在这个注解
        if(m.isAnnotationPresent(Bookk.class)){
            //c.直接获取该注解对象
            Bookk book = (Bookk) m.getDeclaredAnnotation(Bookk.class);
            System.out.println(book.value());
            System.out.println(book.price());
            System.out.println(Arrays.toString(book.author()));
        }
    }
}

@Bookk(value = "《情深深雨濛濛》", price = 99.9, author = {"琼瑶", "dlei"})
class BookStore{
    @Bookk(value = "《三少爷的剑》", price = 399.9, author = {"古龙", "熊耀华"})
    public void test(){
    }
}

3.5注解的应用场景-模拟Junit框架

需求:定义若干个方法,只要加了MyTest注解,就可以在启动时被触发执行

分析:

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

public class AnnotationDemo4 {
    public void test1(){
        System.out.println("===test1===");
    }
    @MyTest
    public void test2(){
        System.out.println("===test2===");
    }
    @MyTest
    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.遍历方法，看是否有MyTest注解，有就跑它
        for (Method method : methods) {
            if(method.isAnnotationPresent(MyTest.class)){
                // 跑它
                method.invoke(t);
            }
        }
    }
}
  • 上述案例中一旦有测试方法不满足公开,无参,无返回值,那么编写就会很麻烦,这也是为什么Junit单元测试规定测试方法必须公开,无参,无返回值,和我们一样,是为了简化编写框架的流程

4.动态代理

4.1动态代理概述,快速入门

1.什么是代理:

  • 一个对象,用来对被代理对象的行为额外做一些辅助工作

2.代理主要干什么,他是如何工作的:

在这里插入图片描述

3.如何创建动态代理:

  • java中代理的代表类是:java.lang.reflect.Proxy
    • Proxy提供了一个静态方法,用于为对象产生一个代理对象返回

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h):为对象(生成)返回一个代理对象

  • 参数一:定义代理类的类加载器
    • newProxyInstance方法内部会先为我们生成一个代理类,再通过代理类产生一个代理对象,所以要给方法一个类加载器,好让他底层通过类加载器生成一个代理类,进而得到代理对象
  • 参数二:代理类要实现的接口列表
    • 这可能也就是为什么java规定动态代理中我们必须要设计接口:因为方法明确规定是要接口列表
  • 参数三:将方法调用分派到的处理程序(代理对象的核心处理程序)

在这里插入图片描述

public class Test {
    public static void main(String[] args) {
        //1.创建一个对象(杨超越),java规定动态代理中我们必须要设计接口
        Star s = new Star("杨超越");

        //为杨超越对象生成一个代理对象(经纪人)
        Skill s2 = StarAgentProxy.getProxy(s);
        s2.jump();
        System.out.println(s2.sing());
    }
}

public interface Skill {
    void jump();
    int sing();
}

public class Star implements Skill{
    private String name;
    public Star(String name) {
        this.name = name;
    }
    @Override
    public void jump() {
        System.out.println(name + "开始跳舞");
    }
    @Override
    public int sing() {
        System.out.println(name + "开始唱歌");
        return 23333;
    }
}

public class StarAgentProxy {
    public static Skill getProxy(Skill obj) {
        /*
        public static Object newProxyInstance(
              ClassLoader loader,
              Class<?>[] interfaces,
              InvocationHandler h)
         */
        //为杨超越这个对象生成一个代理对象
        return (Skill)Proxy.newProxyInstance(
                obj.getClass().getClassLoader(),
                obj.getClass().getInterfaces(),
            new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("收首付款");

                //真正的让杨超越去唱歌和跳舞
                //method:正在被调用的方法对象 args:代表这个方法的参数
                Object rs = method.invoke(obj, args);//如果方法无返回值那么rs就是null

                System.out.println("收尾款,把杨超越接回来");
                return rs;
            }
        });
    }
}
  • 第43行return (Skill)Proxy.newProxyInstance(…
    • 因为以后用户是调用代理对象唱歌跳舞,代理对象再调用真正的杨超越对象唱歌跳舞,所以稍微想一下就能知道:newProxyInstance方法内部肯定是会让代理对象实现Skill接口的,而newProxyInstance方法返回的代理对象是Object类型,所以需要强制类型转换

总结:

  • 在java中实现动态代理的步骤是什么:
    • 必须存在接口
    • 被代理对象需要实现接口
    • 使用Proxy类提供的方法,得到对象的代理对象
  • 通过代理对象调用方法,执行流程是什么样的:
    • 先走向代理
    • 代理可以为方法额外做一些辅助工作
    • 开发真正触发对象的方法的执行
    • 回到代理中,由代理负责返回结果给方法的调用者

4.2动态代理的应用案例:做性能分析

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

分析:

  • 定义一个UserService表示用户业务接口,规定必须完成用户登录,用户删除,用户查询功能
  • 定义一个实现类UserServiceImpl实现UserService,并完成相关功能
  • 创建一个实现类的对象,该对象为业务对象,紧接着为业务对象做一个代理对象

在这里插入图片描述

public interface UserService {
    String login(String loginName , String passWord) ;
    void selectUsers();
    boolean deleteUsers();
}

public class UserServiceImpl implements UserService{
    @Override
    public String login(String loginName, String passWord) {
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if("admin".equals(loginName) && "1234".equals(passWord)) {
            return "success";
        }
        return "登录名和密码可能有毛病";

    }
    @Override
    public void selectUsers() {
        System.out.println("查询了100个用户数据！");
        try {
            Thread.sleep(2000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    @Override
    public boolean deleteUsers() {
        try {
            System.out.println("删除100个用户数据！");
            Thread.sleep(500);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
}

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 startTimer = System .currentTimeMillis();
                        // 马上触发方法的真正执行。(触发真正的业务功能)
                        Object result = method.invoke(obj, args);

                        long endTimer = System.currentTimeMillis();
                        System.out.println(method.getName() + "方法耗时：" + (endTimer - startTimer) / 1000.0 + "s");

                        // 把业务功能方法执行的结果返回给调用者
                        return result;
                    }
                });
    }
}

动态代理的优点:

  • 可以在不改变方法源码的情况下，实现对方法功能的增强

  • 简化了编程工作、提高了软件系统的可扩展性，同时也提高了开发效率

  • 可以为被代理对象的所有方法做代理

  • 非常的灵活:

    • 支持任意接口类型的实现类对象做代理
      • 因为可以将创建并返回代理对象的方法(本案例就是getProxy方法)设计为泛型方法,此时就可以创建任意接口类型的实现类对象的代理对象
    • 也可以直接为接口本身做代理(以后学)
DJL快速入门（纯Java跑深度学习模型）
iioSnail的博客
06-29 2万+
DJL快速入门（纯Java跑深度学习模型） 1. DJL核心内容讲解 2. DJL加载Pytorch模型 3. DJL的Tensor操作 4. DJL简单案例（DJL使用Pytorch模型完成图片分类） 5. OpenPose项目实战
Java 人工智能应用：使用 DL4J 实现深度学习算法
shrgegrb的博客
05-30 1573
本文介绍了如何使用Java深度学习库DL4J实现深度学习算法。DL4J是为Java开发者设计的开源分布式深度学习库，可与Hadoop和Spark集成处理大规模数据。文章详细讲解了DL4J开发环境的搭建步骤，包括Maven依赖配置和Java环境准备。重点演示了如何使用DL4J构建多层感知机（MLP）模型，涵盖数据准备、模型构建、训练和评估的完整流程。通过示例代码展示了如何实现数据预处理、神经网络配置、模型训练和性能评估，为Java开发者提供了深度学习应用的实践指南。文中采用的MLP模型适用于二分类问题，可作为
Java与机器学习：深入理解深度学习与神经网络
阿里渣渣java研发组-群主
06-10 1397
深度学习是一种基于人工神经网络的机器学习方法，通过多层神经网络的训练，能够自动提取数据的高层次特征。深度学习在图像识别、语音识别、自然语言处理等领域取得了显著的成果。
Java也能搞定机器学习？
qq_38196449的博客
12-11 4632
深度学习是机器学习的一个分支，主要侧重于对于人工神经网络的开发。MLP 由多个层组成，每层包含多个神经元（也称为节点），并且每一层的神经元与下一层的所有神经元相连。这种归纳学习的方法可以让计算机学习一些特征并进行一系列复杂的任务，比如识别照片中的物体。您可以使用现有的Java专业知识作为学习和使用机器学习和深度学习的入口。您可以使用您最喜欢的IDE来构建、训练和部署您的模型。Deep Java Library（DJL）是一个开源的、高级的、与引擎无关的深度学习Java框架。您可以在任何时候交换机引擎。
java深度学习人脸检测、特征提取、人脸对比
So straw?
09-15 7956
网上几乎没有关于java使用深度学习的人脸识别完整的源码，这个是我进半年来自己摸索出来的，现在开源出来，希望对喜欢人脸识别的java社区有帮助。 人脸识别分为以下3步骤完成： 1.人脸定位，也叫人脸检测，就是在一张图片中去定位人脸区域，并截图人脸照片。 2.根据步骤1得到的人脸截图输入模型，提取特征，得出一个512维度的特征向量数组。 3.根据2得出的向量数组输入分类网络，输出分类最相似的结果：lab和相似度。 本人已经完全封装好了，可直接运行测试代码调用海康等摄像头或者本地usb摄像头进行人
怎样正确的度过JavaSE阶段真的很重要！（详细知识内容+资料）
热门推荐
奈何的人生
03-22 2万+
不要小看JavaSE的这些基础章节，打好基础很重要！巧了，我这里涵盖了所有Java基础！
从零到一-在Java中实现深度学习模型的实战指南
一键难忘的博客
12-21 4734
Deep Java Library（DJL）是一个高性能的开源深度学习框架，专门为Java开发者提供深度学习功能。简洁的API：提供简单易用的API接口，让Java开发者能够快速构建和训练深度学习模型。多种后端支持：支持多种深度学习引擎，包括TensorFlow、PyTorch、MXNet等。硬件加速：支持GPU加速，可以在NVIDIA GPU上进行高效的深度学习训练。跨平台支持：可以在不同操作系统上运行，如Linux、Windows和macOS。
Java 深度学习项目（一）
最新发布
龙哥盟
07-13 2048
数据的持续增长以及对基于这些数据做出越来越复杂决策的需求，正在带来巨大的障碍，阻碍组织通过传统的分析方法及时获取见解。为了寻找有意义的价值和见解，深度学习得以发展，深度学习是基于学习多个抽象层次的机器学习算法分支。神经网络作为深度学习的核心，被广泛应用于预测分析、计算机视觉、自然语言处理、时间序列预测以及执行大量其他复杂任务。至今，大多数深度学习书籍都是以 Python 编写的。然而，本书是为开发者、数据科学家、机器学习从业者和深度学习爱好者设计的，旨在帮助他们利用 Deeplearning4j（一个基于
【Java反射-56.5.1】深入理解 Java 中的 getDeclaredField()：使用与原理详解
weixin_39033358的博客
01-24 2237
是类中的一个方法，用于获取指定名称的字段（Field对象）。与getField()方法不同，可以访问类的所有字段，包括privateprotected和默认访问权限的字段，而getField()只能访问public字段。参数name是字段的名称。返回值：返回一个Field对象，表示指定名称的字段。异常：如果指定的字段不存在。：如果存在安全管理器且不允许访问该字段。是 Java 反射机制中的一个重要方法，它允许开发者动态地访问类的字段（包括私有字段）。
25.Java与深度学习实战指南：基于Deeplearning4j
weixin_40593051的博客
05-10 771
Java在AI领域以其高性能和企业级应用优势，成为生产环境部署和分布式系统的首选语言。主流Java深度学习框架如Deeplearning4j、TensorFlow Java API、Weka和Smile，为开发者提供了丰富的工具和库。Deeplearning4j作为专为Java设计的框架，支持CPU/GPU，并集成Hadoop/Spark，适用于复杂网络结构和数据处理。通过掌握神经网络基础、数据处理、模型训练与评估等核心知识点，开发者可以在计算机视觉和自然语言处理领域实现图像分类、文本分类和情感分析等应用。
java深度学习框架Deeplearning4j实战（一）BP网络分类器
uniqueleion的博客
11-01 2万+
1、Deeplearning4j 深度学习，人工智能今天已经成了IT界最流行的词，而tensorflow,phython又是研究深度学习神经网络的热门工具。tensorflow是google的出品，而phython又以简练的语法，独特的代码结构和语言特性为众多数据科学家和AI工程师们所喜爱。但今天介绍的不是这两个炙手可热的东东，而是相对冷门，但对于国内大多数的工程师而言更友好，基于java的另一...
【JAVA深度学习】实战示例-犬类图片识别
oJuHao12345的专栏
08-05 795
Springboot maven集成djl 图片识别 深度学习开发环境安装
自己打造一个深度学习框架 for java
08-03 2133
自己打造一个深度学习框架 for java 前言 从16年开始利用空余时间研究深度学习的方面，由于工作的原因，最熟悉的编程语言就是java，所以框架的编程语言自然而然就使用了java。自己打造框架的初衷就是为了更加深入了解各个算法、模型、实现的原理和思路。 框架介绍 Omega-AI：基于java打造的深度学习框架，帮助你快速搭建神经网络，实现训练或测试模型，支持多线程运算，框架目前支持BP神经网络和卷积神经网络的构建。 源码地址： https://gitee.com/iangellove/omega-ai
如何用70行Java代码实现深度神经网络算法
happytofly的博客
02-18 6241
对于现在流行的深度学习，保持学习精神是必要的——程序员尤其是架构师永远都要对核心技术和关键算法保持关注和敏感，必要时要动手写一写掌握下来，先不用关心什么时候用到——用不用是政治问题，会不会写是技术问题，就像军人不关心打不打的问题，而要关心如何打赢的问题。程序员如何学习机器学习对程序员来说，机器学习是有一定门槛的（这个门槛也是其核心竞争力），相信很多人在学习机器学习时都会为满是数学公式的英文论文而头...
深度学习 java_深度学习Java语言实现 PDF 下载
weixin_35895753的博客
02-12 577
相关截图：资料简介：本书是一本实战型的深度学习和机器学习宝典，十分适合Java的深度学习入门者。本书涵盖了深度学习的主要成熟算法，一步步地剖析算法背后的数学原理，并提供大量通俗易懂的代码加以说明。同时，为了能更好地指导实践，作者生动地阐述了很多宝贵的工程经验和技术直觉。最后，本书介绍了该领域*的研究和应用成果，还包括一些实用的网络资源及研究方法。总之，本书值得深度学习爱好者细细品味。 人工智能以及...
动手用 Java 训练深度学习模型
亚马逊云科技专栏
06-13 751
很长时间以来，Java 一直是一个很受企业欢迎的编程语言。得益于丰富的生态以及完善维护的包和框架，Java 拥有着庞大的开发者社区。尽管深度学习应用的不断演进和落地，提供给 Java 开发...
深度学习——你需要了解的八大开源框架
凌风探梅的专栏
08-22 3255
深度学习——你需要了解的八大开源框架 2016-08-05 19:18 Blake 0条评论 深度学习八大开源框架 导读：深度学习（Deep Learning）是机器学习中一种基于对数据进行表征学习的方法，深度学习的好处是用非监督式或半监督式的特征学习、分层特征提取高效算法来替代手工获取特征（feature）。作为当下最热门的话题，Google、Facebook、Mic
Junit单元测试、反射
平安
08-22 1366
目录 Junit单元测试 测试分类 Junit使用：白盒测试 反射 反射概念 获取class对象的三种方式  Class对象功能 获取成员变量 获取构造方法 获取成员方法  Junit单元测试 测试分类          1. 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。          2. 白盒测试：需要写代码。关注程序具体的执行流程。 Juni...
深度学习一：自己写java代码，训练一个神经元
阳光玻璃杯
06-27 1万+
神经网络与深度学习这本书是我学习深度学习的启蒙教材，感兴趣可以到链接出下载。通过一段时间的学习，感觉基本理解了梯度下降算法和反向传播算法，于是尝试着自己写代码来实现神经网络。一开始总是很难的，所以我设计了个非常简单的目标，训练一个神经元。比如我给他输入1，我期望它输出0，这就是一个反相器。我希望它能做到这一点，所以我对他进行训练。 训练一个神经元能简化梯度下降算法和反向传播算法的实现，也能帮助我...
Deep learning深度学习的十大开源框架
奥特曼超人的博客专栏
10-08 7916
Google开源了TensorFlow（GitHub），此举在深度学习领域影响巨大，因为Google在人工智能领域的研发成绩斐然，有着雄厚的人才储备，而且Google自己的Gmail和搜索引擎都在使用自行研发的深度学习工具。对于希望在应用中整合深度学习功能的开发者来说，GitHub上其实还有很多不错的开源项目值得关注，首先我们推荐目前规模人气最高的TOP3：一、Caffe。源自加州伯克利分校的Ca
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

认真生活的灰太狼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值