浅尝注解和反射

注解和反射

一、注解

格式：

可以被其他程序读取，格式“@+注释名”如：@Override， 还可以加一些参数值，如：@SuppressWarnings(value = "unchecked").

使用：

可以附加在package、class、method、field等上面，相当于添加了额外的辅助信息，可以通过反射机制编程实现对这些数据元的访问，如，在使用数据库时用注解标识出具体信息，可以通过读出注解拼出SQL语句，生成表(即用来解释类和表结构的映射关系)

内置注解：

@Override //重写

@Deprecated //过时的，不推荐使用，或者存在更好的方式

@SuppressWarnings("all")//镇压警告，消除警告

元注解

负责注解其他注解

@Target //*用于描述注解的使用范围（“注解可以在什么地方使用”）
//Field用于属性、Method用于方法、Type用于类...

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

@Document//说明该注解将被包含在Javadoc中

@Inherit//说明子类可以继承父类中的该注解

//测试元注解
package annotation;

import java.lang.annotation.*;

@MyAnnotation
public class test02 {
    @MyAnnotation
    void run(){
        
    }
}
//定义一个注解

@Target(value = {ElementType.METHOD, ElementType.TYPE}) //表示注解可以用在哪些地方， METHOD用在方法上
@Retention(value = RetentionPolicy.RUNTIME) //表示注解在什么地方还有效 源码时 < class时 < 运行时  
@Documented    
@Inherited
@interface MyAnnotation{
    
}

例：

package annotation;

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

public class test03 {

    @MyAnnotation01(name = "gw")    //若所需的参数只有一个则可以省略 =
    public void test(){

    }
}

@Target(value = {ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation01{
    //注解的参数， 参数类型 + 参数名
    String name() default "";//如果没有默认值且重写没有赋值，则报错
    int age() default 0;
    int id() default -1;
    String[] schools() default {"CDUT", "CUDT"};

}

二、反射

创建运行时类的对象、获取运行时类的完整结构、调用运行时类的指定结构、可以获取注解、泛型（即通过对象得到类），java的反射机制增加了java的动态性

使用场景：

如果程序对象是自己new的，那程序相当于写死了给jvm去跑。假如一个服务器上突然遇到某个请求哦要用到某个类，哎呀但没加载进jvm，是不是要停下来自己写段代码，new一下，哦启动一下服务器，（脑残）！反射就是在服务器不停止工作的情况下满足用户提出的未加载至程序中的类中

例如： 实例化一个 person()对象， 不使用反射， new person(); 如果想变成实例化其他类， 那么必须修改源代码，并重新编译。
      使用反射： class.forName("person").newInstance()； 而且这个类描述可以写到配置文件中，如 **.xml, 这样如果想实例化其他类，只要修改配置文件的"类描述"就可以了，不需要重新修改代码并编译。

//***一个类在内存中只有一个Class对象***
//***一个类被加载后类的整个结构都会被封装在该Class对象中***

获取Class类的实例

a)若已知具体的类，通过类的class属性获取，该方法最为安全可靠，性能最高

Class c1 = Person.class;//Person为类名

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

Class c2 = person.getClass();//person为Person类下的实例

c)已知一个类的全类名， 且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException

Class c3 = Class.forName("demo01.Student");

d)内置基本数据类型可以直接用类名.Type

e)还可以用ClassLoader

可以通过c1.getSuperclass()获得父类的类型

可以获得Class对象的类型

• class：外部类，成员（成员内部类、静态内部类），局部内部类，匿名内部类
• interface：接口
• []数组
• enum：枚举
• annotation：注解@interface
• 基本数据类型
• void

public class test02 {
    public static void main(String[] args) {
        Class c1 = Object.class;
        Class c2 = Comparable.class;
        Class c3 = String[].class;
        Class c4 = int[][].class;
        Class c5 = Override.class;
        Class c6 = ElementType.class;
        Class c7 = Integer.class;
        Class c8 = void.class;
        Class c9 = Class.class;

        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());
    }
}

三、类的内存分析，类的生成过程

如何生成Class对象

加载：将class文件字节码内容加载到内存中，并将这些静态数据转化成方法区的运行时数据结构，然后生成java.lang.Class对象

链接：验证、准备、解析

初始化：执行类构造器()方法，由编译器自动收集所有类变量的赋值动作和静态代码块的语句

类什么时候初始化

主动引用：

• 虚拟机启动，先初始化main所在的类
• new一个类的对象时
• 调用类的静态成员（除了final常量）和静态方法
• 使用java.lang.reflect包的方法对内进行优先反射调用
• 当初始化一个类，其父类为被初始化，优先初始化父类

被动引用（不会发生初始化）：

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

四、通过反射获取运行时类的Method、Field、Constructor、Superclass、Interface、Annotation

获得类的一些基本属性

package reflection;

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

//获得类的信息
public class test03 {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("reflection.User");

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

        //获得类的属性Field
        Field[] fields = c1.getFields();//只能找到public属性
        fields = c1.getDeclaredFields();//能找到全部的属性
        for (Field field : fields) {
            System.out.println(field);
        }

        //获得指定属性的值
        Field name = c1.getDeclaredField("name");
        System.out.println(name);

        //获得类的方法Method
        System.out.println("========================");
        Method[] methods = c1.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        methods = c1.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println("declared:" + method);
        }
        
        //获得指定方法
        Method getName = c1.getMethod("getName",null);
        Method setName = c1.getMethod("setName", String.class);
        System.out.println(getName);
        System.out.println(setName);

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

}

通过反射获取对象

package reflection;

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

//通过反射创建对象
public class test04 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class c1 = Class.forName("reflection.User");
		//通过newInstance()创建(不推荐)
        User user = (User)c1.newInstance();
        System.out.println(user);

        //通过构造器调用方法
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        User user2 = (User)declaredConstructor.newInstance("123", 1, 2);
        System.out.println(user2);

        //通过反射获取一个方法
        User user3 = (User)c1.newInstance();
        Method setName = c1.getDeclaredMethod("setName", String.class);
        setName.invoke(user3, "kuang");
        System.out.println(user3.getName());
        //获得方法Method后用invoke(对象名， 参数)函数来调用该方法
        
        //通过反射操作属性
        User user4 = (User)c1.newInstance();
        Field name = c1.getDeclaredField("name");
        name.setAccessible(true);			//通过该方法可以操作private变量
        name.set(user4, "kuangshen");
        System.out.println(user4.getName());
    }
}

获取注解信息

package reflection;

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

public class test05 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("reflection.Student2");

        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //获得注解value的值
        TableGw tableGw = (TableGw)c1.getAnnotation(TableGw.class);
        String value = tableGw.value();
        System.out.println(value);
        //获得类的指定注解
        Field f = c1.getDeclaredField("id");
        FieldGw annotation = f.getAnnotation(FieldGw.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());
    }
}
@TableGw("db_student")
class Student2{
    @FieldGw(columnName = "db_id", type = "int", length = 10)
    private int id;
    @FieldGw(columnName = "db_age", type = "int", length = 10)
    private int age;
    @FieldGw(columnName = "db_name", type = "varchar", length = 3)
    private String name;

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

    public int getId() {
        return id;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Student2{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

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

}

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldGw{
    String columnName();    //列名
    String type();
    int length();
}