注解与反射

发表于 | 更新于:
寄蜉蝣于天地，渺沧海之一粟

反射就是把java类中的各种成分映射成一个个的Java对象

1. 注解

可以被程序读取的注释

1.1 内置注解

  • 栗子：
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
package com.xxy.test;

//测试学习什么是注解



import java.lang.annotation.*;
import java.util.ArrayList;
import java.util.List;

    @SuppressWarnings("all") //抑制编译警告信息,不建议
public class Test01 extends Object{

    @Override //重写的注解
    public String toString() {
        return "Test01{}";
    }

    @Deprecated //不推荐使用的注解
    public static void test() {
        System.out.println("djsnfj");
    }

    public void test1() {
        List list = new ArrayList();
    }
    public static void main(String[] args) {
        test();
    }

}

1.2 元注解(meta-annotation)

使用@interface自定义注解时，自动继承了java.lang.annotation接口，注解元素必须要有值

  • 栗子：
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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package com.xxy.test;

//测试学习什么是注解



import java.lang.annotation.*;
import java.util.ArrayList;
import java.util.List;

    @SuppressWarnings("all") //抑制编译警告信息,不建议
public class Test01 extends Object{

    @Override //重写的注解
    public String toString() {
        return "Test01{}";
    }

    @Deprecated //不推荐使用的注解
    public static void test0() {
        System.out.println("djsnfj");
    }
    //注解可以显示赋值，没有默认值，必须赋值
    @MyAnnotation1()
    @MyAnnotation2("dh")
    public void test1() {
        List list = new ArrayList();
    }
    public static void main(String[] args) {
        test0();
    }

}
//定义一个注解 meta-annotation
//Documented表示是否将我们的注释生成在JavaDoc中
@Documented
//Inherited表示子类可以继承父类的注解
@Inherited
//Retention表示我们注解什么时候有效 RUNTIME > CLASS > SOURCE
@Retention(RetentionPolicy.RUNTIME)
//Target表示我们可以注释哪些地方
@Target({ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.LOCAL_VARIABLE, ElementType.METHOD, ElementType.PACKAGE, ElementType.PARAMETER, ElementType.TYPE})
@interface MyAnnotation1 {
    //注解的参数
    String name() default "";
    int age() default 0;
    int id() default -1;
    String[] schools() default {"什么大学","hello大学"};
}


//Documented表示是否将我们的注释生成在JavaDoc中
@Documented
//Inherited表示子类可以继承父类的注解
@Inherited
//Retention表示我们注解什么时候有效 RUNTIME > CLASS > SOURCE
@Retention(RetentionPolicy.RUNTIME)
//Target表示我们可以注释哪些地方
@Target({ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.LOCAL_VARIABLE, ElementType.METHOD, ElementType.PACKAGE, ElementType.PARAMETER, ElementType.TYPE})
@interface MyAnnotation2 {
        /*String name();*/
    //只有一个注解的参数建议用value
    String value();
}

1.3 反射操作注解

  • 栗子
  • 自定义注解一
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.xxy.annotation;

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

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TableORM {
    String value();
}


  • 自定义注解二
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.xxy.annotation;

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

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Field {
    String columnName() default "";
    String type() default "";
    int length() default 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
26
27
28
29
30
31
package com.xxy.test;

import com.xxy.annotation.TableORM;

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

//通过反射获取注解
public class Test08 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("com.xxy.entity.User");
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

        //获取注解value的值
        TableORM annotation = (TableORM) c1.getAnnotation(TableORM.class);
        String value = annotation.value();
        System.out.println(value);

        //获取类指定注解
        Field name = c1.getDeclaredField("name");
        com.xxy.annotation.Field annotation1 = name.getAnnotation(com.xxy.annotation.Field.class);
        System.out.println(annotation1.columnName());
        System.out.println(annotation1.type());
        System.out.println(annotation1.length());

    }
}

2. 反射机制

Class类是反射机制的根源，可以通过Object类中所提供的方法获取一个Class实例，

1
2
3
graph LR
A[实例化对象] --> B(getClass方法) --> C(得到完整的包类的名称)

  • 动态语言

在运行时可以改变结构的语言，例如JavaScript，PHP，Python

  • 静态语言

运行时不可以改变结构，例如Java【准动态语言，可以通过反射改变结构】，C，C++

3. Class类对象实例化

在运行期间，一个类，只有一个Class对象产生

  • 通过Class.forName()方法【最常见】

  • 通过Object的getClass()方法

  • 通过“类.class”的形式

  • 栗子

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
47
48
49
50
51
52
53
54
55
package com.xxy.test;

import com.xxy.entity.User;

import java.lang.annotation.ElementType;

public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {

        User user = new User();
        System.out.println(user);

        //方式一：通过对象.getClass获得
        Class c1 = user.getClass();
        System.out.println(c1.hashCode());
        //方式二：通过反射forName获取类的class对象
        Class c2 = Class.forName("com.xxy.entity.User");
        System.out.println(c2.hashCode());

        //方式三：通过类名.class获得
        Class c3 = User.class;
        System.out.println(c3.hashCode());

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

        //获得父类类型
        Class superclass = c2.getSuperclass();
        System.out.println(superclass);

        Class c4 = Object.class;  //类
        Class c5 = Comparable.class;//接口
        Class c6 = String[].class;//一维数组
        Class c7 = int[][].class;//二维数组
        Class c8 = Override.class;//注解
        Class c9 = ElementType.class;//枚举
        Class c10 = Integer.class;//基本数据类型
        Class c11 = void.class;//空类型
        Class c12 = Class.class;//Class

        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(c10);
        System.out.println(c11);
        System.out.println(c12);
      
    }

}

4. 对象实例化

创建一个类的实例时（new,反射，浅克隆，反序列化(深克隆)）

4.1 创建运行时类的对象

  • 栗子：
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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package com.xxy.test;

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

//获取类的信息
public class Test05 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("com.xxy.entity.User");

        //获得类名
        System.out.println(c1.getName());//获取包名+类名
        System.out.println(c1.getSimpleName());//获取包名
        System.out.println("-------------------");
        //获得类的属性,私有不能找到
        Field[] fields = c1.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        //可以找到私有属性的值
        Field[] declaredFields = c1.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        //获取指定属性的值
        Field name = c1.getDeclaredField("name");
        System.out.println(name);
        System.out.println("-------------------");
        //获取类的public方法
        Method[] methods = c1.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        //获取类的所有方法
        Method[] declaredMethods = c1.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }

        //获取指定方法,需要考虑重载
        Method getAge = c1.getMethod("getAge",null);
        Method setAge = c1.getMethod("setAge", int.class);
        System.out.println(setAge);
        System.out.println(getAge);
        System.out.println("-------------------");
        //获取指定构造器
        Constructor[] constructors = c1.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        Constructor[] declaredConstructors = c1.getDeclaredConstructors();
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println("#" + declaredConstructor);
        }

        //获取指定构造器
        Constructor declaredConstructor = c1.getDeclaredConstructor(int.class, String.class, int.class);
        System.out.println("指定：" + declaredConstructor);
    }
}

4.2 通过反射动态创建对象

  • 栗子
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
package com.xxy.test;

import com.xxy.entity.User;

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

public class Test06 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class c1 = Class.forName("com.xxy.entity.User");
        //无参构造
      /*  User user = (User) c1.newInstance();
        System.out.println(user);*/
        //有参构造
        Constructor declaredConstructor = c1.getDeclaredConstructor(int.class, String.class, int.class);
        User user1 = (User) declaredConstructor.newInstance(11, "djhf", 54);
        System.out.println(user1);

        //通过反射调用普通方法
        Method setAge = c1.getDeclaredMethod("setAge", int.class);
        //invoke 激活方法的值
        setAge.invoke(user1,77);
        System.out.println(user1.getAge());

        //通过反射操作属性
        System.out.println("________________");
        Field name = c1.getDeclaredField("name");
        //关闭访问权限，设置可访问
        name.setAccessible(true);
        name.set(user1,"aaa");
        System.out.println(user1.getName());
        System.out.println(user1);


    }
}

4.3 性能问题

普通方法（new） > 设置可访问 > 不设置可访问

类.class > Class.forName(“”) > getClass()

4.4 反射获取泛型

  • 栗子
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
package com.xxy.test;

import com.xxy.entity.User;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

//通过反射获取泛型
public class Test07 {
    public void test01(Map<String, User> map, List<User> list) {
        System.out.println("test01");
    }

    public Map<String,User> test02() {
        System.out.println("test02");
        return null;
    }

    public static void main(String[] args) throws NoSuchMethodException {
        Method test01 = Test07.class.getMethod("test01", Map.class, List.class);
        Type[] genericParameterTypes = test01.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println("#" + genericParameterType);
            if (genericParameterType instanceof ParameterizedType) {//如果是参数化类型，获取真实的参数类型
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }
            }
        }

        

    }

}

5. ClassLoader类加载器

5.1 类的加载过程

1
2
3
graph LR
A[类的加载Load] -->|class字节码内容加载到内存中,生成java.lang.Class对象| B(类的连接Link) -->|验证,准备,解析| C(类的初始化Initialize) -->|执行类构造器clinit,初始化父类,正确加载线程安全锁和同步| D[默认磁盘加载]

  • 栗子
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
package com.xxy.test;

public class Test03 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.m);
        /**
         * 1. 加载到内存，会产生一个类对应class对象
         * 2. 连接，连接后m=0
         * 3. 初始化
         * <clinti>()  {
         *   System.out.println("A类静态代码初始化");
         *          m = 200;
         *          m = 100;
         * }
         */
    }
}

class A {
    static {
        System.out.println("A类静态代码初始化");
         m = 200;
    }
    static int m = 100;

    /**
     * 方法区里面，
     * m=200
     * m=100
     */

    public A() {
        System.out.println("A类的无参构造");
    }
}

5.2 类初始化

  • 类的主动引用
    • 先初始化main()方法所在的类
    • new一个类的对象
    • 调用静态成员（除了final常量）和静态方法
    • 使用java.lang.reflect包的方法对类进行反射调用
    • 初始化一个类时，如果父类没有被初始化，则会先初始化父类
  • 类的被动引用
    • 当访问一个静态域时，只有真正声明这个域的类才会被初始化
    • 通过数组定义类引用，不会触发此类的初始化
    • 引用常量不会触发此类的初始化（常量池）

5.3 类加载器的作用

  • BootStrap【根加载器，系统类加载器】

由C++语言编写，主要目的是加载Java底层系统提供的核心类库

  • ExtensionsClassloader【平台类加载器】

进行模块加载

  • APPClassloader【应用程序类加载器】

加载CLASSPATH所指定的类文件或者JAR文件

  • 自定义加载器【远程服务加载、数据库加载】

  • 栗子

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
47
48
49
50
51
52
53
54
55
56
57
58
package com.xxy.test;

public class Test04 {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);

        //获取系统加载器的父类加载器-->扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);

        //获取扩展类加载器的父类加载器-->根加载器
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

        //测试当前的类是哪个加载器加载的
        ClassLoader classLoader = Class.forName("com.xxy.test.Test04").getClassLoader();
        System.out.println(classLoader);

        //测试jdk内置的类是谁加载的
        ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader1);

        //获取系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
        //双亲委派机制：向上找包，找不到就用自己的包，安全性
        /**
         * D:\install\java\jdk\jre\lib\charsets.jar;
         * D:\install\java\jdk\jre\lib\deploy.jar;
         * D:\install\java\jdk\jre\lib\ext\access-bridge-64.jar;
         * D:\install\java\jdk\jre\lib\ext\cldrdata.jar;
         * D:\install\java\jdk\jre\lib\ext\dnsns.jar;
         * D:\install\java\jdk\jre\lib\ext\jaccess.jar;
         * D:\install\java\jdk\jre\lib\ext\jfxrt.jar;
         * D:\install\java\jdk\jre\lib\ext\localedata.jar;
         * D:\install\java\jdk\jre\lib\ext\nashorn.jar;
         * D:\install\java\jdk\jre\lib\ext\sunec.jar;
         * D:\install\java\jdk\jre\lib\ext\sunjce_provider.jar;
         * D:\install\java\jdk\jre\lib\ext\sunmscapi.jar;
         * D:\install\java\jdk\jre\lib\ext\sunpkcs11.jar;
         * D:\install\java\jdk\jre\lib\ext\zipfs.jar;
         * D:\install\java\jdk\jre\lib\javaws.jar;
         * D:\install\java\jdk\jre\lib\jce.jar;
         * D:\install\java\jdk\jre\lib\jfr.jar;
         * D:\install\java\jdk\jre\lib\jfxswt.jar;
         * D:\install\java\jdk\jre\lib\jsse.jar;
         * D:\install\java\jdk\jre\lib\management-agent.jar;
         * D:\install\java\jdk\jre\lib\plugin.jar;
         * D:\install\java\jdk\jre\lib\resources.jar;
         * D:\install\java\jdk\jre\lib\rt.jar;
         * D:\JavaWork\reflex\out\production\reflex;
         * D:\install\IDEA\IntelliJ IDEA 2019.1\lib\idea_rt.jar
         */

    }
}

6. 总结

本次总结了注解和反射的基础，里面如果有错误或者建议，欢迎评论区指出。