投稿
  1. 极客之音首页
  2. 后端笔记

注解和反射

飞熊 • • 后端笔记 • 阅读 194

生活中，最使人疲惫的往往不是道路的遥远，而是心中的郁闷;最使人痛苦的往往不是生活的不幸，而是希望的破灭;最使人颓废的往往不是前途的坎坷，而是自信的丧失;最使人绝望的往往不是挫折的打击，而是心灵的死亡。所以我们要有自己的梦想，让梦想的星光指引着我们走出落漠，走出惆怅，带着我们走进自己的理想。

导读：本篇文章讲解 注解和反射，希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com，来源：原文

闲话

今天去打了第三针疫苗，我感觉我又被强化了

一、注解

1、注解的含义
Java 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制

2、注解的三大分类

  • 内置注解
    例如：
    @Override – 检查该方法是否是重写方法
    @Deprecated – 标记过时方法，如果使用该方法，会报编译警告
    @SuppressWarnings – 指示编译器忽略注解中的声明的警告

  • 元注解：负责注解其他注解
    @Target：描述此注解可以被使用在什么地方，比如说是类上还是方法上
    @Retention：描述此注解的有效范围，用来描述注解的生命周期
    （SOURCE<CLASS<RUNTIME，默认RUNTIME级别）
    @DOCUMENT：表示该注解是否将会保存在Javadoc中
    @Inherited：说明子类可以继承父类中的该注解

  • 自定义注解
    使用@interface自定义注解，自动继承了java.lang.annotation.Annotation接口
    注解参数的定义格式：参数类型 + 参数名();
    注解只有一个参数时，参数名默认使用value，这样使用参数时，就可以默认不写参数名，直接写值
    注解可以显示赋值，如果没有默认值的情况下，就必须给注解赋值
    如果注解的默认值为-1，那么代表此注解不存在

自定义注解如下

package com.decade.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// 注解可以显式赋值，如果不赋值，那就使用默认值，没有默认值的必须显式赋值
@MyAnnotation(name = "十年", age = 24)
public class CustomAnnotation {
    @MyValue(name = "db_name", type = "java.lang.String", desc = "名字")
    private String name;

    public CustomAnnotation() {
    }

    public CustomAnnotation(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "CustomAnnotation{" 
            + "name='" + name + '\'' 
            + '}';
    }

    public void test() {

    }
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
    String name() default "";
    // 如果默认值为-1，则代表此注解不存在
    int age() default -1;
    String[] hobbies() default {"音乐", "篮球"};
}

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyValue {
    String name();
    String desc();
    String type();
}

二、反射

1、反射机制

JAVA反射机制是在运行状态中，对于任意一个实体类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制

reflection是Java被视为动态语言的关键，反射机制允许程序在执行期借助于reflection API取得任何类的内部信息，并且能直接操作任意对象的内部属性和方法
Class cla = Class.forName("java.lang.String");

正常方式：引入需要的包名——->通过new实例化对象—–>通过实例化对象，调用对象的方法
反射方式：实例化对象——->getClass()方法—–>得到完整的”包类”名称

2、获取反射对象

反射相关的主要API：java.lang.Class类，可以理解为用来描述类的类
一个类在一个内存中只有一个Class对象
一个类被加载后，整个类都会被封装在Class对象中

package com.decade.reflection;

public class ReflectionDemo01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的Class对象
        Class c1 = Class.forName("com.decade.reflection.testReflection");
        System.out.println(c1);

        Class c2 = Class.forName("com.decade.reflection.testReflection");
        Class c3 = Class.forName("com.decade.reflection.testReflection");
        //一个类在一个内存中只有一个Class对象
        //一个类被加载后，整个类都会被封装在Class对象中
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
    }
}

class testReflection {
    private String name;
    private String email;
    private int age;

    public testReflection() {
    }

    public testReflection(String name, String email, int age) {
        this.name = name;
        this.email = email;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "testReflection{"
            + "name='" + name + '\''
            + ", email='" + email + '\''
            + ", age=" + age
            + '}';
    }
}

3、获得Class类的几种方式

  • 若已知具体的类，可以通过类的class的属性获取，该方法最安全可靠，程序性能最高
    Class cla = Person.class;
  • 若已知某个类的实例，可以使用该实例的getClass()方法获取Class对象
    Class cla = person.getClass();
  • 如果知道一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException
    Class cla = Class.forName("java.lang.String")；
  • 内置基本数据类型可以直接用 类名 .Type
  • 可以用ClassLoader
package com.decade.reflection;

public class ReflectionDemo02 {
   public static void main(String[] args) throws ClassNotFoundException {
       Person person = new Student();
       System.out.println("这个人是：" + person.name);

       //通过对象获得
       Class c1 = person.getClass();
       System.out.println(c1);

       //通过forName获得
       Class<?> c2 = Class.forName("com.decade.reflection.Student");
       System.out.println(c2.hashCode());

       //通过类名.class获得
       Class c3 = Student.class;
       System.out.println(c3.hashCode());

       //基本数据类型的包装类都有一个Type属性
       Class c4 = Integer.TYPE;
       System.out.println(c4);

       //获得父类型
       Class c5 = c1.getSuperclass();
       System.out.println(c5);
   }
}

class Person {
   String name;

   public Person() {
   }

   public Person(String name) {
       this.name = name;
   }

   @Override
   public String toString() {
       return "Person{"
           + "name='" + name + '\''
           + '}';
   }
}

class Student extends Person {
   public Student() {
       this.name = "学生";
   }
}

class Teacher extends Person {
   public Teacher() {
       this.name = "老师";
   }
}

运行结果如下
在这里插入图片描述

4、所有类型的class对象

注意：只要类型和维度一样，通过对象获取到的Class就是同一个

package com.decade.reflection;

import java.lang.annotation.ElementType;

public class ReflectionDemo03 {
    public static void main(String[] args) {
        // 类
        Class c1 = Object.class;
        // 接口
        Class c2 = Comparable.class;
        // 一维数组
        Class c3 = int[].class;
        // 二维数组
        Class c4 = int[][].class;
        // 注解
        Class c5 = Override.class;
        // 枚举类
        Class c6 = ElementType.class;
        // 基本数据类型
        Class c7 = Integer.class;
        // void
        Class c8 = void.class;
        // Class
        Class c9 = Class.class;

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);

        System.out.println("========================");

		// 只要类型和维度一样，通过对象获取到的Class就是同一个
        int[] array1 = new int[10];
        int[] array2 = new int[100];
        System.out.println(array1.getClass().hashCode());
        System.out.println(array2.getClass().hashCode());
    }
}

运行结果如下
在这里插入图片描述

5、类加载内存分析

简单了解一下Java内存
1）堆：
存放new出来的对象和数组
可以被所有线程共享，不会存放别的对象引用

2）栈：
存放基本变量类型（包含这个基本类型的具体数值）
引用对象的变量（会存放这个引用在堆里面的具体地址）

3）方法区（特殊的堆）
可以被所有的线程共享
包含了所有的class和static变量

6、类的加载过程：加载—>链接（验证、准备、解析）—>初始化

  • 加载：查找和导入Class文件
  • 链接：其中解析步骤是可以选择的 （a）检查：检查载入的class文件数据的正确性 （b）准备：给类的静态变量分配存储空间 （c）解析：将符号引用转成直接引用
  • 初始化：对静态变量，静态代码块执行初始化工作

7、分析类的初始化

问：什么时候才会发生类的初始化？
类的主动引用（一定会发生类的初始化）：
1）当虚拟机启动，先初始化main方法所在的类
2）new一个类的对象
3）调用类的静态成员（除final常量）和静态方法
4）使用java.lang.reflection包对的方法对类进行反射调用
5）当初始化一个类，如果其父类没有初始化，那么则会先初始化它的父类

类的被动引用（不会发生类的初始化）：
1）当访问一个静态域时，只有真正声明这个域的类才会被初始化，例如通过子类引用父类的静态变量，子类不会初始化
2）通过数组定义类引用，不会触发此类的初始化
3）引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

8、获取类的完整结构

如何获取类中属性、构造器以及方法呢，我们可以对着下面的例子做一个简单的了解

package com.decade.reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectionDemo04 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("com.decade.reflection.People");

        // 获取类的名字 + 包名
        System.out.println(c1.getName());
        // 获取类名
        System.out.println(c1.getSimpleName());

        System.out.println("=====获取属性========");
        // 获取本类和父类中的属性,只能找到public类型的
        Field[] fields = c1.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("=====获取全部属性========");
        // 能获取本类全部属性
        Field[] fields2 = c1.getDeclaredFields();
        for (Field field : fields2) {
            System.out.println(field);
        }

        System.out.println("=====指定属性========");
        // 获取本类指定属性
        Field sex = c1.getDeclaredField("sex");
        System.out.println("sex=" + sex);
        // 获取本类和父类中指定属性,public修饰
        Field name = c1.getField("name");
        System.out.println("sex=" + name);

        System.out.println("=====获取方法========");
        // 获得类的方法，包括本类和父类的。仅能获得public修饰的
        Method[] methods = c1.getMethods();
        for (Method method : methods) {
            System.out.println(method.getName());
        }
        System.out.println("=====获取所有方法========");
        // 获得类的方法，仅包括本类的。获得public和private修饰的
        Method[] declaredMethods = c1.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod.getName());
        }

        System.out.println("=====获取指定方法========");
        // 获得指定方法，如果方法没有入参，第二个参数填null
        Method setAge = c1.getMethod("setAge", int.class);
        System.out.println(setAge);

        System.out.println("=====获取所有构造器========");
        // 返回本类所有构造函数
        Constructor[] declaredConstructors = c1.getDeclaredConstructors();
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor.getName());
        }
        System.out.println("=====获取构造器========");
        // 返回public修饰的构造函数
        Constructor[] constructors = c1.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName());
        }
        System.out.println("=====获取指定构造器========");
        // 获取指定的构造器
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, String.class);
        System.out.println(declaredConstructor.getName());
    }
}

class Person {
    public String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{"
            + "name='" + name + '\''
            + '}';
    }
}

class People extends Person {
    public int age;

    private String sex;

    private People(int age, String sex) {
        this.age = age;
        this.sex = sex;
    }

    public People(String name, int age, String sex) {
        super(name);
        this.age = age;
        this.sex = sex;
    }

    private void test() {
        System.out.println("私有方法");
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "People{" +
            "name='" + name + '\'' +
            ", age=" + age +
            ", sex='" + sex + '\'' +
            '}';
    }
}

9、如何动态创建对象执行方法（通过反射获取类的方法、字段、构造器）

  • 如何通过反射创建类的对象：调用Class对象的new Instance()方法
    使用此方式，类必须要有无参构造，其次，类的构造器的访问权限需要足够

  • 如果没有无参构造，我们也可以按照下面的步骤创建类的对象：
    1）通过class类的getDeclareConstructor(Class…ParameterTypes)取得本类的指定形参类型的构造器
    2）向构造器传递一个对象数组进去，里面包含了构造器中所需的各个参数
    3）通过constructor实例化对象

  • 调用指定的方法：
    1）通过Class类的getMethod(String name, Class… ParameterTypes)或getDeclaredMethod(String name, Class… ParameterTypes)取得一个method对象，并设置此方法操作时所需的参数类型
    2）之后使用Object.invoke(对象， 参数)进行调用，并向其中传递方法需要的参数

  • 操作指定的属性：需要设置Accessible为true，关闭程序的安全检测
    注意：Method、Filed和Constructor都有setAccessible()方法

package com.decade.reflection;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectionDemo05 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException,
        InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchFieldException {
        Class<?> c1 = Class.forName("com.decade.reflection.User");

        // 通过反射调用普通方法，此处是调用了类的无参构造
        User user = (User) c1.newInstance();
        Method setName = c1.getDeclaredMethod("setName", String.class);
        // 通过invoke进行方法调用
        setName.invoke(user, "十年");
        System.out.println(user.getName());

        System.out.println("=======================");
        // 通过反射操作属性
        User user2 = (User) c1.newInstance();
        Field name = c1.getDeclaredField("name");
        Field sex = c1.getDeclaredField("sex");
        System.out.println(user.getName());
        // 要操作私有属性，需要设置Accessible为true，关闭程序的安全检测
        name.setAccessible(true);
        name.set(user2, "十年Decade");
        sex.set(user2, "男");
        System.out.println(user2.getName());
        System.out.println(user2.getSex());
    }
}

class User {
    private String name;

    public String sex;

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "User{" +
            "name='" + name + '\''
            + ", sex='" + sex + '\''
            + '}';
    }
}

运行结果如下
在这里插入图片描述

10、通过反射操作注解

首先我们新建两个自定义注解，将它们添加到类和属性上

package com.decade.reflection;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// 注解可以显式赋值，如果不赋值，那就使用默认值，没有默认值的必须显式赋值
@MyAnnotation(name = "十年", age = 24)
public class CustomAnnotation2 {
    @MyValue(name = "db_name", type = "java.lang.String", desc = "名字")
    private String name;

    public CustomAnnotation2() {
    }

    public CustomAnnotation2(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "CustomAnnotation{"
            + "name='" + name + '\''
            + '}';
    }

    public void test() {

    }
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
    String name() default "";
    // 如果默认值为-1，则代表此注解不存在
    int age() default -1;
    String[] hobbies() default {"音乐", "篮球"};
}

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyValue {
    String name();
    String desc();
    String type();
}

然后我们创建一个测试类

package com.decade.reflection;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;

public class reflectionDemo06 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class<?> c1 = Class.forName("com.decade.reflection.CustomAnnotation2");

        // 通过反射获取注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

        System.out.println("================================");

        // 获取注解的属性值
        MyAnnotation annotation = c1.getAnnotation(MyAnnotation.class);
        String name = annotation.name();
        System.out.println(name);

        System.out.println("================================");

        // 获取类中指定的注解
        Field nameField = c1.getDeclaredField("name");
        MyValue annotation1 = nameField.getAnnotation(MyValue.class);
        System.out.println(annotation1.desc());
        System.out.println(annotation1.name());
        System.out.println(annotation1.type());
    }
}

控制台输出结果如下
在这里插入图片描述

如有错误，欢迎指正

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/136780.html

赞 (0)
飞熊的头像飞熊bm
0 0

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！