【狂神】注解与反射基本原理

1. 注解

1.1、什么是注解

从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。

注解Annotation的作用：

• 不是程序本，身可以对程序做出解释（者一点和注释（comment)没有区别）
• 可以是被其他程序（比如：编译器等）读取

Annotation 的格式：

• 注解是以“@注释名”在代码中存在的

1.2、自定义注解

元注解：即注解注解的注解

• 使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口
• @Target:用于描述注解的使用范围（即:被描述的注解可以用在什么地方）
• @Rentention:表示需要在什么级别保存该注释信息，用于描述注解的生命周期
  • （SOURCE <CLASS < RUNTIME) 一般默认为 class
• @Duocument:说明该注解将包含在javadoc中
• @inherited:说明子类可以继承父类中的该注解

public class Test02 {
    @ MyAnnotation(name = "李思强")
    public void test(){
    }
    @Target(value = {ElementType.TYPE, ElementType.METHOD})//type是类的范围
    @Retention(value = RetentionPolicy.RUNTIME)
    @Documented()
    @Inherited()
    @interface MyAnnotation {
        String name() default "";
        int age() default 18;
        int id() default -1;//如果默认值为一，则表示不存在
    }
}

2.反射

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力，通过反射可以调用私有方法和私有属性，大部分框架也都是运用反射原理的。

2.1、静态 VS 动态语言

动态语言：能在运行时可以改变其结构的语言，类如JavaScript语言

function f(){
    var x = "var a=2;var b=3; alert(a+b)";
    eval(x);
}

静态语言:运行时结构不发生改变，类如Java, C ,C#

java又称“准动态语言”，我们可以利用反射机制获得类似动态语言的特性，Java的动态性更加灵活。

2.2 、Java Reflection

反射机制允许程序在执行期借助Reflection API取得任何类的内部信息，并能直接操作对象的内部属性及方法

正常方法： 引入需要的“包类”名称------->通过new实例化------>取得实例化对象

反射方式： 实例化对象-------->getClass()方法-------->得到完整的“包类”名称

2.3、 反射的概念

1. 通过反射获取类的class对象
2. 一个类在内存中只有一个Class对象
3. 一个类被加载后，类的结构都会被封装在Class对象中

Class c1 = Class.forName(“com.cetu.reflection.User”)

2.4 、获取Class类的实例

1. 已知具体类，通过类的class属性获取

   Class c1 = Person.class;

2. 已知某个类的实例，调用该实例的getClass()方法获取Class对象

   Class c2 = person.getClass();

3. 已知类的全名，且该类在类路径下

   Class c3 = Class.forName(“包名”)

int[] a = new int[10];

int[] b = new int[100];

System.out.println(a.getClass().hashCode());

System.out.println(b.getClass().hashCode());

1163157884

1163157884   //

2.5、 类什么时候初始化

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

2.6、获取运行时类的完整结构

通过反射获取运行时类的完整结构

Field (属性) Method (方法) Constructor (构造器) Interface (接口) Annotation (注解) Declared:可获取private属性和方法。

Field[] fields = c1.getFields();  //只能找到public属性
fields = c1.getDeclaredFields();//找到全部属性
 Method method = c1.getMethod();//获得本类及其父类的全部public方法
Type[] gennericParameterTypes method.getGennericParameterTypes();//获取泛型的信息
 Method[] declaredMethods = c1.getDeclaredMethods();//获取本类的所有方法

2.7、 动态创建对象执行方法

有了Class对象，能做什么？

• 创建类的对象：调用Class对象的NewInstance()方法
  • 类必须有一个无参构造器（有参构造器在调用的时候需要将参数传递进去，才可以实例化操作）
  • 类的构造器的访问权限需要足够

//动态的创建对象，通过反射
public class Test09 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //获得Class对象
        Class c1 = Class.forName("com.cetu.reflection.User");
        //构造一个对象
        User user = (User) c1.newInstance(); //本质是调用了类的无参构造器
        System.out.println(user);

        //通过构造器创建对象-------------------------------------------------------
        Constructor constructor = c1.getDeclaredConstructor(String.class,int.class,int.class);
        User user2 = (User) constructor.newInstance("李思强",007,18);
        System.out.println(user2);

        //通过反射调用普通方法-----------------------------------------------------
        User user3 = (User) c1.newInstance();
        Method setName = c1.getDeclaredMethod("setName", String.class);
        //invoke:激活的意思
        //(对象，“方法的值”)
        setName.invoke(user3,"李思强");
        System.out.println(user3.getName());

        //通过反射操作属性---------------------------------------------------------
        System.out.println("===============分割符=============");
        User user4 = (User) c1.newInstance();
        Field name = c1.getDeclaredField("name");   //获得属性
        //不能直接操作私有属性，我们需要关闭程序的安全检测，属性或者方法的setAccessible(true);
        name.setAccessible(true);//打开私有属性的权限
        name.set(user4,"李思强2");
        System.out.println(user4.getName());
    }
}

2.8、性能比对

public class Test10 {
    //普通方法调用
    public static void test01(){
        User user = new User();
        long startime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            user.getName();
        }
        long endtime = System.currentTimeMillis();
        System.out.println("普通方式："+(endtime-startime)+"ms");
    }
    //反射方式调用
    public static void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName", null);
        long startime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
          getName.invoke(user,null);
        }
        long endtime = System.currentTimeMillis();
        System.out.println("反射方式调用方式："+(endtime-startime)+"ms");
    }
    //反射方式调用  关闭检测
    public static void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName", null);
        getName.setAccessible(true);
        long startime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(user,null);
        }
        long endtime = System.currentTimeMillis();
        System.out.println("关闭检测方式："+(endtime-startime)+"ms");
    }
    public static void main(String[] args) throws Exception {
        test01();
        test02();
        test03();
    }
}

由此看出，通过反射的方法对类进行操作，可以获得类的所有属性，方法。并能更快的返回需要的信息。

具体反射的应用可用在单例上，可以查看之前的单例模式的笔记。