自定义注解、反射机制、Java内存分析、Class类的常用方法、Class类的获得方式、发生类的初始化、通过反射动态的创建对象执行方法、setAccessible、反射获取泛型信息、反射获取注解信息

1、注解

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

//自定义注解
public class Test {
    //注解可以显示赋值，如果没有默认值，我们就必须给注解赋值
    @MyAnnotation1(name = "zhao", age = 22, id = 1, school = {"湖师"})
    public void test1(){}
    @MyAnnotation2("aaaa")
    public void test2(){}
}

//Target--表示注解可以用在哪些地方
@Target(value = {ElementType.METHOD, ElementType.TYPE})
//@Target({ElementType.METHOD, ElementType.TYPE})

//Retention--表示在什么地方还有效--runtime>class>sources
@Retention(value = RetentionPolicy.RUNTIME)
//@Retention(RetentionPolicy.RUNTIME)
//Documented--表示是否将注解生成在Javadoc中
@Documented

//Inherited--表示子类可以继承父类的注解
@Inherited

//定义注解--@interface 注解名
@interface MyAnnotation1{
    //注解的参数：参数类型 + 参数名();
    String name() default "";
    int age() default 0;
    int id() default -1;//一般用默认值-1，代表不存在
    //数组
    String[] school() default {"湖北师范大学","武汉大学"};
}

@Target(value = {ElementType.METHOD, ElementType.TYPE})
@Retention(value = RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
    String value();
}

2、反射机制

• Reflection（反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并直接操作任意对象的内部属性及方法。
• 加载完类后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，形象的称之为反射。

2.1 Java反射的优缺点

• 优点：可以实现动态创建对象和编译，体现出很大的灵活性
• 缺点：对性能有影响。

2.2反射相关的常用API

• java.lang.Class ：代表类
• java.lang.reflect.Methond ：代表类的方法
• java.lang.reflect.Field ：代表类的成员变量
• java.lang.reflect.Constructor ：代表类的构造器

3、 Java内存分析

3.1 Java内存

分为堆、栈、方法区。

• 堆：

  • 存放new的对象和数组。
  • 可以被所有的线程共享，不会存放别的对象引用。

• 栈：

  • 存放基本变量类型，包含这个基本类型的具体数值。
  • 引用对象的变量，存放这个引用在堆里的具体地址。

• 方法区：

  • 可以被所有线程共享。
  • 包含了所有的class和static变量。

4、 Class类

• Class本身也是一个类，Class对象只能由系统建立对象。
• 一个类在内存中只有一个Class对象，类被加载后，类的整个结构都会被封装在Class对象中。
• Class类是Reflection的根源，针对任何你想动态加载、运行的类，只有先获得相应的Class对象。

4.1Class类的常用方法

• static ClassforName(String name)—返回指定类名name的Class对象
• Object newlnstance()—调用缺省构造函数，返回Class对象的一个实例
• getName()—返回此Class对象所表示的实体(类，接口，数组类或void)的名称。
• Class getSuperClass()—返回当前Class对象的父类的Class对象
• Class[] getinterfaces()—获取当前Class对象的接口
• ClassLoader getClassLoader()—返回该类的类加载器
• Constructor[] getConstructors()—返回一个包含某些Constructor对象的数组
• Method getMothed(String name,Class… T)—返回一个Method对象，此对象的形参类型为paramType
• Field[] getDeclaredFields()—返回Field对象的一个数组

4.2 Class类的获得方式

//测试class类的获得方式有哪些
public class TestClass {
    public static void main(String[] args) throws ClassNotFoundException {
        Person p1 = new Student();
        System.out.println("This is"+p1.name);

        //方式一：已知类的实例，通过 对象.getClass() 获得
        Class c1 = p1.getClass();
        System.out.println(c1);
        System.out.println(c1.hashCode());

        //方式二：已知类的全类名，通过 Class.forName("路径") 获得
        Class c2 = Class.forName("com.zhao.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 c1Superclass = c1.getSuperclass();
        System.out.println(c1Superclass);
    }
}
class Person{
    public 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 = "student";
    }
}
class Teacher extends Person{
    public Teacher() {
        this.name = "teacher";
    }
}

4.3 哪些类型可以有Class对象

//所有类型的class
public class TestTypeClass {
    public static void main(String[] args) {
        Class c1 = Object.class;//类
        Class c2 = Runnable.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

        //按住alt键，可以选中多行的一部分复制粘贴
        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);

        //只要元素类型与维度一样，就是同一个Class
        int[] a = new int[10];
        int[] b = new int[100];
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());
    }
}

4.4类的加载过程

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

• 类的加载（Load）：将文件的class文件读入内存，并为之创建一个java.lang.Class对象，此过程由类的加载器完成。

• 类的链接（Link）：将类的二进制数据合并到 JRE 中。

• 类的初始化（Initialize）：JVM 负责对类进行初始化。

4.5 类的加载与ClassLoader的理解

• 加载:将 class 文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构,然后生成一个代表这个类的 java.lang.Class 对象。

• 链接:将 Java 类的二进制代码合并到 JVM 的运行状态之中的过程。

  • 验证:确保加载的类信息符合 JVM 规范，没有安全方面的问题。

• 准备:正式为类变量(static)分配内存，并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。

  • 解析:虚拟机常量池内的符号引用（常量名）替换为直接引用(地址)的过程。

• 初始化:

  • 执行类构造器 () 方法的过程。类构造器 () 方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。(类构造器是构造类信息的，不是构造该类对象的构造器)。

• 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。

  • 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。

4.6 发生类的初始化

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

  • 当虚拟机启动，先初始化main方法所在的类

  • new一个类的对象

  • 调用类的静态成员(除了 final 常量)和静态方法

  • 使用 java.lang.reflect 包的方法对类进行反射调用

  • 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类

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

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

4.7、创建运行时类的对象

//获得类的信息
public class TestClass2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c = Class.forName("com.zhao.reflection.User");

        //获得类的名字
        System.out.println(c.getName());//获得包名.类名
        System.out.println(c.getSimpleName());//获得类名

        //获得类的属性
        Field[] f1 = c.getFields();//只能获得public属性
        for (Field field : f1) {
            System.out.println(field);
        }
        Field[] f2 = c.getDeclaredFields();//获得全部属性
        for (Field field : f2) {
            System.out.println(field);
        }
        //获得指定属性
        Field n = c.getDeclaredField("age");
        System.out.println(n);

        //获得类的方法
        Method[] m1 = c.getMethods();//获得本类及父类的全部public方法
        for (Method m : m1) {
            System.out.println(m);
        }
        Method[] m2 = c.getDeclaredMethods();//获得本类所有方法
        for (Method m : m2) {
            System.out.println(m);
        }
        //获得指定方法
        Method method1 = c.getDeclaredMethod("getAge",null);
        Method method2 = c.getDeclaredMethod("setAge", int.class);
        System.out.println(method1);
        System.out.println(method2);

        //获得构造器
        Constructor[] con1 = c.getConstructors();
        for (Constructor cc : con1) {
            System.out.println(cc);
        }
        Constructor[] con2 = c.getDeclaredConstructors();
        for (Constructor cc : con2) {
            System.out.println(cc);
        }
        Constructor cc1 = c.getConstructor();
        Constructor cc2 = c.getConstructor(String.class, int.class, int.class);
        System.out.println(cc1);
        System.out.println(cc2);
    }
}

4.8动态创建对象执行方法

//动态的创建对象，通过反射
public class TestClass3 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //获得Class对象
        Class c = Class.forName("com.zhao.reflection.User");

        //构造一个对象
        User u1 = (User) c.newInstance();//本质是调用了类的无参构造器
        System.out.println(u1);

        //通过构造器创建对象
        Constructor constructor = c.getDeclaredConstructor(String.class, int.class, int.class);
        User u2 = (User) constructor.newInstance("zhao", 1, 22);
        System.out.println(u2);

        //通过反射调用普通方法
        User u3 = (User) c.newInstance();
        //通过反射获取一个方法
        Method setName = c.getDeclaredMethod("setName", String.class);
        //invoke(对象, "方法的参数值")
        //若原方法为private的方法,则需要关闭程序的安全检测，方法.setAccessible(true)
        setName.invoke(u3, "zhaowu");
        System.out.println(u3.getName());

        //通过反射操作属性
        User u4 = (User) c.newInstance();
        //通过反射获取一个属性
        Field age = c.getDeclaredField("age");
        //不能直接操作私有属性，需要关闭程序的安全检测,属性.setAccessible(true)
        age.setAccessible(true);
        age.set(u4,20);
        System.out.println(u4.getAge());
    }
}

4.9 setAccessible

• Method和Field、Constructor对象都有setAccessible()方法。

• setAccessible作用是启动和禁用访问安全检查的开关。

• 参数值为true则指示反射的对象在使用时应该取消Java语言访问检查。

  • 提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置为true.

  • 使得原本无法访问的私有成员也可以访问。

• 参数值为false则指示反射的对象应该实施Java语言访问检查

5、性能对比

public class TestPerformance {
    //普通方式调用
    public void test1(){
        long startTime = System.currentTimeMillis();
        User user = new User();
        for (int i = 0; i < 100000000; i++) {
            user.getName();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("普通方式--"+(endTime-startTime)+"ms");
    }
    //反射方式调用
    public void test2() throws ClassNotFoundException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException {
        long startTime = System.currentTimeMillis();
        Class c = Class.forName("com.zhao.reflection.User");
        User user = (User) c.newInstance();
        Method getName = c.getDeclaredMethod("getName", null);
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(user, null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射方式--"+(endTime-startTime)+"ms");
    }
    //关闭检测后反射方式调用
    public void test3() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        long startTime = System.currentTimeMillis();
        Class c = Class.forName("com.zhao.reflection.User");
        User user = (User) c.newInstance();
        Method getName = c.getDeclaredMethod("getName", null);
        getName.setAccessible(true);
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(user, null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("关闭检测后--"+(endTime-startTime)+"ms");
    }

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
        TestPerformance t = new TestPerformance();
        t.test1();
        t.test2();
        t.test3();
    }
}

6、反射获取泛型信息

//通过反射获取泛型信息
public class TestGeneric {
    //泛型作为方法的参数
    public void test1(Map<String,User> map, List<User> list){
        System.out.println("test1");
    }
    //泛型作为方法的返回值
    public Map<String,User> test2(){
        System.out.println("test2");
        return null;
    }

    public static void main(String[] args) throws NoSuchMethodException {
        //获取方法，通过方法获取泛型的参数化类型，
        //然后判断是否属于参数化类型，并强转成参数化类型，然后获得真实的参数化类型
        Method method1 = TestGeneric.class.getMethod("test1", Map.class, List.class);
        Type[] genericParameterTypes = method1.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);
                }
            }
        }
        System.out.println();
        Method method2 = TestGeneric.class.getMethod("test2",null);
        Type genericReturnType = method2.getGenericReturnType();
        if(genericReturnType instanceof ParameterizedType){
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }
}

7、反射获取注解信息

//反射操作注解
public class TestAnnotation2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c = Class.forName("com.zhao.reflection.Student2");
        //通过反射获得注解
        Annotation[] annotations = c.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //获得注解的value值
        TableZhao tableZhao = (TableZhao) c.getAnnotation(TableZhao.class);
        String value = tableZhao.value();
        System.out.println(value);

        //获得指定属性的注解
        Field f = c.getDeclaredField("name");
        FieldZhao annotation = f.getAnnotation(FieldZhao.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());
    }
}

@TableZhao("db_student")
class Student2{
    @FieldZhao(columnName = "db_id",type="int",length = 10)
    private int id;
    @FieldZhao(columnName = "db_name",type="varchar",length = 10)
    private String name;
    @FieldZhao(columnName = "db_age",type="int",length = 3)
    private int age;

    public Student2() {
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Student2{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableZhao{
    String value();
}
//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldZhao{
    String columnName();
    String type();
    int length();
}