【学习笔记】注解与反射

一、注解

1. 什么是注解

  • Annotation 是从JDK5.0 开始引用的新技术。
  • 作用:不是程序本身,而是对程序做出解释。可以被其他程序(比如编译器等)读取。
  • 格式:注解是以@注释名在代码中存在的,还可以添加一些参数值。
  • 使用:可以附加在package、class、method、field等上面,相当于给他们添加了额外的辅助信息,可以通过反射机制实现对这些元数据的访问。

2.内置注解

  • @Override:只适用于修饰方法,表示一个方法生命打算重写超类中的另一个方法声明。
  • @Deprecated:可以修饰方法、属性、类,表示不鼓励程序员使用这样的元素。
  • @SuppressWarnings:用来抑制编译时的警告信息。

3.元注解

  • 元注解的作用就是负责注解其他注解,Java定义了4个标准的meta-annotation类型,他们用于为其他注解类型进行解释说明。
    • @Target:用于描述注解的使用范围。(包、类、方法、属性)
    • @Retention:用于描述注释的生命周期。(Source<Class<Runtime
    • @Document:说明该注解将被包含在javadoc
    • @Inherited:说明子类可以继承父类的该注解。

4. 自定义注解

使用@interface自定义注解时,自动继承了java.lang.annotation.Annotation接口。

  • 使用@interface声明注解,格式为@interface 注解名{定义内容}
  • 每一个方法实际上是生命了一个配置参数。
  • 方法的名称就是参数的名称。
  • 返回值类型就是参数的类型。(返回值只能是基本类型,class,String,enum)
  • 可以通过default来生命参数的默认值。
  • 如果只有一个参数成员,一般参数名为value,因为在使用时可以省略value。
  • 注解元素必须要有值,我们定义注解元素时,经常使用空字符串或0作为默认值。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Test02 {
@MyAnnotation(name = "ss")
public void test() {
System.out.println("--");
}
}

// 表示注解能使用在什么地方
@Target(value = ElementType.METHOD)
// 表示注解在什么地方有效
@Retention(value = RetentionPolicy.RUNTIME)
// 表示是否将注解生成在JavaDoc中
@Documented
// 表示子类可以继承父类的注解
@Inherited
@interface MyAnnotation {
// 注解的参数: 参数类型+参数名();
String name() default "";

int age() default 0;

int id() default -1;

String[] schools() default {"shmtu", "sspu"};
}

二、反射

1.静态语言与动态语言

  • 动态语言:运行时可以改变其结构的语言。在运行时,代码可以根据某些条件改变自身结构。
  • 静态语言:运行时结构不可变的语言。
  • Java不是动态语言,但可称为“准动态语言”。即Java有一定的动态性,我们可以立用反射机制获得类似动态语言的特性。

2. Java Reflection

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

Class c = Class.forName("java.lang.String")

加载完类之后,在堆内存的方法区中就产生了一个Class类型的对象(一个类只有一个Class对象),这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子,透过这个镜子看到类的结构,所以形象成的称为:反射。

优点:可以实现动态创建对象和编译,体现出很大的灵活性。

缺点:对性能有影响。使用反射基本上是一种解释操作,这类操作总是慢于直接执行相关操作。

3. Class类

对象照镜子后可以得到的信息:某个类的属性、方法和构造器、某个类到底实现了那些接口。对于每个类而言,JRE都为其保留了一个不变的Class类型的对象。一个Class对象包含了特定某个结构的有关信息。

  • Class本身也是一个类
  • Class对象只能由系统建立
  • 一个加载的类在JVM中只会有一个Class实例
  • 一个Class对象对应的是一个加载到JVM中的一个.class文件
  • 每个类的实例都会记得自己是由哪个Class所生成
  • 通过Class可以完整地得到一个类中的所有被加载的结构
  • Class类是Reflection的根源,针对任何你想动态加载、运行的类,唯有先获得Class对象。

a. class类的常用方法:

方法名 功能说明
static ClassforName(String name) 返回指定类名name的Class对象
Object newInstance() 调用缺省构造函数,返回Class对象的一个实例
getName() 返回此Class对象所表示的实体(类、接口、数组类或void)的名称
Class getSuperClass 返回当前Class对象的父类的Class对象
Class[] getinterfaces 获得当前Class对象的接口
ClassLoader getClassLoader() 返回该类的类加载器
Constructor[] getConstructors() 返回一个包含某些构造器对象的数组
Method getMethod(String name,Class.. T) 返回一个Method对象,此对象的形参类型为paramType
Field[] getDeclaredFields() 返回属性对象的一个数组

b. 获得Class实例

  1. 若已知具体类,通过class属性获取,这种方法最安全可靠,程序性能最高。Class cls = Person.class
  2. 已知某个类的实例,调用该实例的getClass()方法获取Class对象。Class cls = person.getClass()
  3. 已知一个类的全类名,且该类在类路径下,可通过Class类的静态方法forName()获得,可能会抛出ClassNotFoundException异常。Class cls = Class.forName("demo.Person")
  4. 内置基本数据类型可以直接用 类名.Type
  5. 可以使用ClassLoader
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Student student = new Student();
// 1. 通过对象获得
Class c1 = student.getClass();
System.out.println(c1.hashCode());
// 2. forName获得
Class c2 = Class.forName("com.windranger.basic.annotation.Student");
System.out.println(c2.hashCode());
// 3. 通过类名.class 获得
Class c3 = Student.class;
System.out.println(c3.hashCode());
// 4. 基本内置类型的包装类都有一个Type属性
Class c4 = Integer.TYPE;
System.out.println(c4);
// 获取父类类型
Class c5 = c1.getSuperclass();
System.out.println(c5);

c. 哪些类型可以有Class对象?

  • class:外部类,成员内部类,静态内部类,局部内部类,匿名内部类。
  • interface:接口
  • []:数组
  • enum:枚举
  • annotation:注解@interface
  • primitive type:基本数据类型
  • void
1
2
3
4
5
6
7
8
9
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;//基本数据类型
Class c8 = void.class;//void
Class c9 = Class.class;//Class

4. 获取运行时类的完整结构

通过反射获取运行时类的完整结构:Field、Method、Constructor、Superclass、Interface、Annotation。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 获取类的名字
System.out.println(c1.getName()); // 包名+类名
System.out.println(c1.getSimpleName());// 类名

// 获取类的属性
Field[] fields = c1.getFields(); // public 属性
Field[] fields = c1.getDeclaredFields(); // 所有属性
// 获取指定属性
Field field = c1.getField("name"); // 指定public属性
Field field = c1.getDeclaredField("name");// 指定属性

// 获取方法
Method[] methods = c1.getMethods(); // 获得本类和父类的public方法
Method[] methods = c1.getDeclaredMethods();//获得本类的所有方法
// 获取指定方法
Method method = c1.getMethods("名称","参数列表");//获得本类的所有方法

// 获取构造方法
Constructor[] constructors = c1.getConstructors();
Constructor[] constructors = c1.getDeclaredConstructors();
// 获取指定构造器
Constructor constructor = c1.getDeclaredConstructor("参数列表");

5. 使用Class对象

创建类的对象:调用Class对象的newInstance()方法。

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

调用指定方法:先用getMethod获取方法,再用invoke执行方法。

setAccessible():方法、属性、构造器都有;功能是启动和禁止访问安全检查的开关;参数为true时,禁用访问检查(并提高了反射效率);参数为false时,实施访问检查。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
@NoArgsConstructor
@AllArgsConstructor
@Data
class Person {
private String name;
private int age;
private int id;
}
Class c1 = Class.forName("com.windranger.basic.annotation.Person");//获得class对象

// 1. 使用无参构造器创建一个对象
Person person = (Person) c1.newInstance();//构造一个对象
System.out.println(person);
// Person(name=sss, age=0, id=0)

// 2. 通过有参构造器传入对象
Constructor constructor = c1.getConstructor(String.class,int.class,int.class);//获得一个构造器
Person person1 = (Person) constructor.newInstance("111",1,1);// 使用构造器
System.out.println(person1);
// Person(name=111, age=1, id=1)

// 3 使用方法传入参数
Method method = c1.getMethod("setName", String.class);// 得到方法
method.invoke(person,"sss"); // 使用方法
System.out.println(person);
// Person(name=sss, age=0, id=0)

// 4. 使用属性
Field name = c1.getDeclaredField("name"); // 获得属性
name.setAccessible(true); // 由于不能权限不够,不能直接操作私有属性,因此,开启访问权限
name.set(person,"sss"); // 设置属性值
System.out.println(person);
// Person(name=sss, age=0, id=0)

6.反射操作泛型

Java采用泛型擦除的机制来引入泛型,Java中的泛型仅仅是编译器javac使用的,确保数据的安全性和免去强制类型转换的问题。但是,一旦编译完成,所有和泛型有关的类型全部擦除。

为了通过反射操作这些类型,Java新增了ParameterizedTypeGenericArrayTypeTypeVariableWildcardType集中类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型。

  • ParameterizedType:表示一种参数化类型,例如Collection<String>
  • GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型
  • TypeVariable:是各种类型变量的公共父接口
  • WildcardType:代表一种通配符类型表达式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Test06 {
public List<Integer> test(Map<String,Integer> map, List<Integer> list){
System.out.println(map);
System.out.println(list);
return list;
}
public static void main(String[] args) throws NoSuchMethodException {
Method method = Test06.class.getMethod("test", Map.class,List.class);
// 获得 参数 的泛型信息
Type[] types = method.getGenericParameterTypes();
for (Type type : types) {
System.out.println(type);
// 判断是否为参数化类型,如果是则获取真实类型
if (type instanceof ParameterizedType){
Type[] actualTypes = ((ParameterizedType) type).getActualTypeArguments();
for (Type actualType : actualTypes) {
System.out.println(actualType);
}
}
}
// 获得返回值类型
Type type = method.getGenericReturnType();
System.out.println(type);
}
}

7.使用反射操作注解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public class Test {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class c1 = Class.forName("com.windranger.basic.annotation.Teacher");
// 获取注解
Annotation[] annotations = c1.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}

// 获取类上table注解的值
Table table = (Table) c1.getAnnotation(Table.class);
System.out.println(table.value());

// 获得参数name上的Field注解
Field field = c1.getDeclaredField("name");
FieldTest fieldTest = field.getAnnotation(FieldTest.class);
System.out.println(fieldTest.columnName());
}
}

@Data
@NoArgsConstructor
@AllArgsConstructor
@Table("db_teacher")
class Teacher {
@FieldTest(columnName = "db_id",type = "int",length = 10)
private int id;
@FieldTest(columnName = "db_age",type = "int",length = 10)
private int age;
@FieldTest(columnName = "db_name",type = "varchar",length = 10)
private String name;
}
// 类名注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table{
String value();
}
// 属性注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldTest{
String columnName();
String type();
int length();
}

三、类加载机制

1.Java内存结构

  • 堆内存:存放new的对象和数组;可以被所有的线程共享,不会存放别的对象引用。
  • 栈:存放基本数据类型;存放引用变量的对象。
  • 方法区(特殊的堆):可以被所有线程共享,包含了所有的class和static变量。

2. 类加载过程:

当程序主动使用某个类时,如果该类还未被加载到内存中,则系统通过以下三个步骤来对该类进行初始化。

  1. 类加载:将类的class文件字节码加载到内存中,并将这些静态数据转换为方法区的运行时数据结构,然后生成一个代表这个类的java.lang.Class对象。此过程由类加载器完成。
  2. 类链接:将Java类的二进制代码合并到JVM的运行状态之中。
    • 验证:确保加载的类信息符合JVM规范,没有安全问题。
    • 准备:正式为类变量(static)分配内存并设置类变量默认初始化的阶段,这些内存都将在方法区中进行分配。
    • 解析:虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程。
  3. 类初始化:JVM负责对类进行初始化。
    • 执行类构造器()方法的过程。类构造器方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中合并产生的。
    • 当初始化一个类的时候,如果发现其父类还没有进行初始化,则需要先触发其父类的初始化。
    • 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。

3. 什么时候会发生类初始化?

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

  • 当虚拟机启动,先初始化main方法所在的类。
  • new一个类的对象。
  • 调用类的静态成员(除final常量)和静态方法。
  • 使用java.lang.reflect包的方法对类进行反射调用。
  • 当初始化一个类,如果它的父类没有被初始化,则会先初始化它的父类。

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

  • 当访问一个静态域时,只有真正申明这个域的类才会被调用。如:当通过子类引用父类的静态变量,不会导致子类初始化,但父类被初始化。
  • 通过数组定义类引用,不会触发此类的初始化。Son[] sons = new Son[10]
  • 引用常量不会触发此类的初始化(常量在链接阶段就存入了调用类的常量池中)。

4. 类加载作用

  • 类加载:将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构,然后在堆中生成一个代表整个类的java.lang.Class对象,作为方法区中类数据的访问入口。
  • 类缓存:标准的JavaSE类加载器可以按要求查找类,但一旦某个类被加载到类加载器中,它将加载(缓存)一段时间。不过JVM垃圾回收机制可以回收这些Class对象。
  • 类加载器:用来把class装进内存。
    • 引导类加载器:C++编写,是JVM自带的类加载器,负责Java平台核心库,用来状态核心类库。该加载器无法直接获得。
    • 扩展类加载器:负责jre/lib/ext目录下的jar包或-D java.ext.dirs指定目录下的jar包装入工作库。
    • 系统类加载器:负责java -classpath-D java.class.path所指的目录下的类与jar包装入工作,是最常用的加载器。
  • 双亲委派机制。