Java注解与反射

概要

本文主要是总结Java注解与反射的相关知识，加深自己对Java类动态语言的理解，同时为日后学习Spring打下基础。

注解：

什么是注解

• Annotation的作用
  • 不是程序本身，但是可以对程序作出解释。
  • 可以被其他程序（比如：编译器等）读取。
• Annotation的格式：
  • 注解是以“@注释名”在代码中存在的，还可以添加一些参数值，例如：@SuppressWarnings(value="unchecked")。
• Annotation使用范围：
  • 附加在package、class、method、field等上面，相当于给他们添加了额外的辅助信息，然后通过反射机制编程实现对这些元数据的访问。

内置注解

• Override：

  定义在java.lang.Override中，此注释只适用于修辞方法，表示一个方法声明打算重写超类中的另一个方法声明。

• Deprecated：

  定义在java.lang.Deprecated中，此注释可以用于修辞方法、属性、类，表示不鼓励程序员使用这样的元素，通常是因为它很危险或者有更好的选择。

• SuppressWarnings：

  定义在java.lang.SuppressWarnings中，用来抑制编译时警告信息，与前两个注释不同，此注解需要添加一个参数才可正常使用：

  ➢SuppressWarnings("all")

  ➢SuppressWarnings("unchecked")

  ➢SuppressWarnings(value={"deprecation","unchecked"})

  ➢......

元注解

• 元注解的作用就是负责注解其他注解，Java定义了4个标准的meta-annotation类型，他们被用来提供对其他annotaion类型作说明。

• 这些类型和他们所支持的类在java.lang.annotation包可以找到:

  ➢@Target：用于描述注解的使用范围（即被描述的注解可以用在什么地方）

  ➢@Retention:表示需要在什么级别保存该注释信息，用于描述注解的生命周期（SOURCE<CLASS<RUNTIME）。

  ➢@Document:说明该注解将被包含在javadoc中。

  ➢@Inherited:说明子类可以继承父类中的该注解。

自定义注解

• 使用@interface自定义注解，格式：public @interface 注解名{定义内容}。

• 自定义注解内部的参数格式：参数类型+参数名()；若只有一个参数成员，参数名默认为value。

• 注解的元素必须要有值，我们定义注解元素时，一般默认使用空字符串，0作为默认值。

  //注解可以显式赋值，如果没有默认值，则必须赋值
  @myAnnotation(id = 3)
  public class testAnnotation {
      @myAnnotation(id = 5,school = {"THU","CMU"})
      public void test(){
  
      }
  }
  @Target(value = {ElementType.METHOD,ElementType.TYPE})
  @Retention(RetentionPolicy.RUNTIME)
  @interface myAnnotation{
      //注解的参数：参数类型+参数名()
      String name() default "";
      int id();
      int age() default 0;
      String[] school() default {"HDU"};
  }
  

反射：

什么是反射

• Reflection是Java被视为动态语言的关键，反射机制允许程序在执行期间借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

• Java在加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们通过这个对象可以看到类的结构，这种过程称为反射。

  • 正常方式：引入需要的“包类”名称➜通过new实例化➜取得实例化对象
  • 反射方式：实例化对象➜getClass()方法➜取得完整的“包类”名称

• 反射相关的API

  • java.lang.Class：代表一个类

  • java.lang.reflect.Method：代表类的方法

  • java.lang.reflect.Field：代表类的成员变量

  • java.lang.reflect.Constructor：代表类的构造器

    public class test{
        public static void main(String[] args) throws ClassNotFoundException {
            //通过反射获得类的Class对象
            Class<?> c1 = Class.forName("JavaDoc.User");
            Class<?> c2 = Class.forName("JavaDoc.User");
            Class<?> c3 = Class.forName("JavaDoc.User");
            //一个类在内存中只有一个Class对象
            //一个类被加载后，类的整个结构都会被封装在Class对象中
            System.out.println(c1.hashCode());
            System.out.println(c2.hashCode());
            System.out.println(c3.hashCode());
        }
    }
    //实体类 pojo ,Entity
    class User{...}
    //输出结果：hashCode相同
    1846274136
    1846274136
    1846274136
    

获得Class类的方式

• 若已知具体的类，通过类的class属性获取。

• 若已知某个类的实例化对象，调用该实例的getClass()方法获取Class对象。

• 若已知一个类的全类名，且该类在类路径下，可以通过Class类的静态方法forName()方法获取。

  public class test02{
      public static void main(String[] args) throws ClassNotFoundException {
          Student student = new Student();
          //通过forName获得
          Class c1 = Class.forName("JavaDoc.Student");
          //通过对象获得
          Class c2 = student.getClass();
          //通过类名.class获得
          Class c3 = Student.class;
  
          System.out.println(c1.hashCode());
          System.out.println(c2.hashCode());
          System.out.println(c3.hashCode());
          //获得父类类型
          System.out.println(c1.getSuperclass().hashCode());
      }
  }
  //实体类 pojo ,Entity
  class Person{...}
  class Student extends Person{...}
  

Java内存分析

Java内存区域	功能
堆	存放new的对象和数组，可以被所有的线程共享，不会存放别的对象引用
栈	存放基本类型变量（包含具体数值）和引用对象的变量（包含具体地址）
方法区	可以被所有线程共享，包含了所有class和static变量

这里只是浅显列出，详细分析需要参考Java的JVM。

Class类初始化

• 类的主动引用一定会发生类的初始化

  • 当虚拟机启动时，先初始化main方法所在的类。
  • 调用类的静态成员（除了final常量）和静态方法会发生初始化。
  • 使用java.lang.reflect包反射调用会发生初始化。

• 类的被动引用不会发生类的初始化

  • 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如当通过子类引用父类的静态变量，不会导致子类初始化。
  • 通过数组定义类的引用，不会触发此类的初始化。
  • 引用常量不会触发此类的初始化。

  public class test03{
      static {
          System.out.println("Main类被加载");
      }
      public static void main(String[] args){
          //主动引用
          Son son = new Son();
        	//final不会初始化父类和子类
          System.out.println(Son.M);
      }
  }
  class Father{
      static int b = 3;
      static {
          System.out.println("父类被加载");
      }
  }
  class Son extends Father{
    static {
          System.out.println("子类被加载");
          m = 200;
      }
      static int m = 100;
      static final int M = 1;
  }
  //输出结果
  Main类被加载
  父类被加载
  子类被加载
  100
  

类加载器

类加载器作用是用来把类装载进内存，JVM规范定义了如下类型的类加载器：

• 系统类加载器：

  负责java -classpath或- D，导入java.class.path所指定的目录下的类与jar包装入工作，是最常用的加载器。

• 扩展类加载器：

  负责jre/lib/ext目录下的jar包装入工作库。

• 引导类加载器：

  采取C++编写，是JVM自带的类加载器，负责Java平台的核心库，用来装载核心类库，无法直接获取。

• 类加载器采取双亲委派机制，自底向上检查类是否已经装载，自顶向下尝试加载类。

  自定义类加载器⇨System Classloader⇨Extension Classloader⇨Bootstrap Classloader

  public class test04{
      public static void main(String[] args){
          //获取系统类加载器
          ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
          System.out.println(systemClassLoader);
          //获取系统类加载器的父类加载器 --> 扩展类加载器
          ClassLoader parent = systemClassLoader.getParent();
          System.out.println(parent);
          //获取扩展类加载器的父类加载器 --> 根加载器（c/c++）
          ClassLoader parent1 = parent.getParent();
          System.out.println(parent1);
          //获取可加载的系统类加载器
          System.out.println(System.getProperty("java.class.path"));
      }
  }
  

类的运行时结构

• getName()
• getFields()
• getMethods()
• getConstructors()
• ......

public class test05{
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> c1 = Class.forName("JavaDoc.User");

        //getFields只能获取public类型信息
        System.out.println("===getFields====");
        Field[] field = c1.getFields();
        for (Field field1 : field) {
            System.out.println(field1);
        }
        //getDeclaredFields可获取所有信息
        System.out.println("===getDeclaredFields====");
        field = c1.getDeclaredFields();
        for (Field field1 : field) {
            System.out.println(field1);
        }
    }
}
class User{
    public double score;
    private String name;
    private int id;
    private int age;
}
//输出结果
===getFields====
public double JavaDoc.User.score
===getDeclaredFields====
public double JavaDoc.User.score
private java.lang.String JavaDoc.User.name
private int JavaDoc.User.id
private int JavaDoc.User.age

动态创建对象执行方法

创建类的对象：

调用Class对象的newInstance()方法

• 类必须有一个无参构造器。
• 类的构造器访问权限需要足够。

创建步骤：

• 通过Class类中的getDeclaredConstructor()取得本类的指定形参类型的构造器。
• 向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。
• 通过Constructor实例化对象。

public class test06{
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class<?> c1 = Class.forName("JavaDoc.User");
        //newInstance默认调用无参构造
        User user = (User) c1.newInstance();
        System.out.println(user);

        //通过构造器声明含参构造重新调用newInstance
        Constructor<?> constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        User user2 = (User) constructor.newInstance("zhangsan", 001, 20);
        System.out.println(user2);

        //通过反射机制调用User类中的方法
        Method setName = c1.getDeclaredMethod("setId", int.class);
        setName.invoke(user,001);
        System.out.println(user.getId());

        //通过关闭程序权限检测，操作程序的私有属性
        User user4 = (User) c1.newInstance();
        Field name = c1.getDeclaredField("name");
        name.setAccessible(true);
        name.set(user4,"zhangsan2");
        System.out.println(user4.getName());
    }
}
class User{
    ...
    public User() {
    }

    public User(String name, int id, int age) {
        this.name = name;
        this.id = id;
        this.age = age;
    }
		...
}

反射操作注解

public class test07{
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class<?> c1 = Class.forName("JavaDoc.User");
        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //获得注解内部value值
        Table table = c1.getAnnotation(Table.class);
        System.out.println(table.value());
        //获取内部指定字段的注解信息
        Field f1 = c1.getDeclaredField("name");
        fieldStudent field = f1.getAnnotation(fieldStudent.class);
        System.out.println(field.columnName());
        System.out.println(field.type());
        System.out.println(field.length());
    }
}
@Table(value = "db_User")
class User{
    @fieldStudent(columnName = "db_name",type = "varchar",length = 3)
    private String name;
    @fieldStudent(columnName = "db_id",type = "int",length = 10)
    private int id;
    @fieldStudent(columnName = "db_age",type = "int",length = 10)
    private int age;
}

//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table{
    String value();
}

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface fieldStudent{
    String columnName();
    String type();
    int length();
}
//程序输出
@JavaDoc.Table(value=db_User)
db_User
db_name
varchar
3