java注解和反射

1、注解

1、什么是注解

• Annotation是从JDK5.0开始引入的新技术
• Annotation的作用
  • 不是程序本身，可以对程序做出解释
  • 可以被其他程序读取
• Annotation的格式
  • 注解是以“@注释名”在代码中存在的，还可以添加一些参数值
• 注解可以作用在package，class，method，field等上面

2、内置注解

• @Override：定义在java.lang.Override中，此注解只适用于修饰方法，表示一个方法声明 打算重写超类中的另一个方法
• @Deprecated：定义在java.lang.Deprecated中，此注解可以用于修饰方法、属性，类，表示不鼓励程序员使用这样的元素，通常是因为它很危险或有更好的选择
• @SuppressWarnings：定义在java.lang.SuppressWarnings中，用来抑制编译时的警告信息，与前两个不同，你需要添加一个参数才能正确使用，这些参数都是已经定义好了的，我们选择使用就行
  • @SuppressWarnings(“all”)
  • @SuppressWarnings(“unchecked”)
  • @SuppressWarnings(value = {“unchecked”,“deprecation”})

3、元注解

作用：就是负责注解其他注解

java定义了4个标准的meta-annotation类型

1. @Target：用于描述注解的范围（即：被描述的注解可以用在什么地方）
2. @Retention：表示需要在什么保存该注释信息，用于描述注释的生命周期
   • SORCE（源代码的时候用）
   • CLASS（CLASS时有用）
   • RUNTIME（运行时有用）
3. @Documented：说明该注解被包含在Javadoc中
4. @Inherited：说明子类可以继承父类中的该注解

4、自定义注解

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

要求：

• interface用来声明一个注解，格式:public @interface注解名{定义内容}

• 其中的每一个方法实际上是声明了一个配置参数

• 方法的名称就是参数的名称

• 返回值类型就是参数的类型（返回值只能是基本类型,Class , String , enum ).

• 可以通过default来声明参数的默认值

• 如果只有一个参数成员，一般参数名为value

• 注解元素必须要有值，我们定义注解元素时,经常使用空字符串,0作为默认值．

  例子：

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{
    // 注解的参数：参数类型+参数名();
    String name() default "";
    int age() default 0;
    int id() default -1;

    String[] schools() default {"北大","清华"};
}

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

2、反射简介

1、动态语言

• 是程序类在运行时可以改变其结构的语言∶例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。
• 主要动态语言:Object-C、C#、JavaScript、PHP、Python等。

2、静态语言

• 与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++。
• Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性,我们可以利用反射机制获得类似动态语言的特性。Java的动态性让编程的时候更加灵活!

3、反射概述

什么是反射

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

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

java反射机制提供的功能

• 在运行时判断任意一个对象所属的类
• 在运行时构造任意一个类的对象
• 在运行时判断任意一个类所具有的成员变量和方法
• 在运行时获取泛型信息
• 在运行时调用任意一个对象的成员变量和方法
• 在运行时处理注解
• 生成动态代理
• 等等

Java反射优点和缺点

• 优点：可以实现动态创建对象和编译，体现出很大的灵活性
• 缺点：对性能有影响。因为反射是在运行时运行的

3、Class类

1、说明：

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

2、Class类的常用方法

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

3、获取Class类的几种方式

// 方式一：通过对象获得
Class c1 = person.getClass();
System.out.println(c1.hashCode());
// 方式二：forName获得（全限定类名）
Class c2 = Class.forName("com.longyu.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 c5 = c1.getSuperclass();
System.out.println(c5);

4、哪种类型可以有Class对象

• class：类
• interface：接口
• []：数组
• enum：枚举
• annotation：注解
• primitive type：基本数据类型
• void

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; // void
Class c9 = Class.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 java.lang.Object
interface java.lang.Comparable
class [Ljava.lang.String;
class [[I
interface java.lang.Override
class java.lang.annotation.ElementType
class java.lang.Integer
void
class java.lang.Class

​

4、类加载内存分析

1、java内存分析

2、类的加载过程

1. 类的加载

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

2. 类的链接

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

   • 验证：确保加载的类信息符合JVM规范，没有安全方面的问题。
   • 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
   • 解析：虚拟机常量池内的符号引用（常亮名）替换为直接引用（地址）的过程。

3. 类的初始化

   • 执行类加载器<clinit>()方法的过程。类构造器<clinit>()方法是由编译器自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
   • 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
   • 虚拟机会保证一个类<clinit>()方法在多线程环境中被正确加锁和同步。

3、什么时候会发生类的初始化

1、类的主动引用（一定会发生类的初始化）

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

2、类的被动引用（不会发生类的初始化）

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

4、类加载器的作用

• .java->Java编译器->.class->类加载器->字节码校验器->解释器->操作系统
• 类加载器作用：将类（class）装载进内存。
  • 引导类加载器(rt.jar)
  • 扩展加载器
  • 系统加载器

5、通过反射操作对象

1、通过Class对象来创建对象

// 获得class对象
Class c1 = Class.forName("com.test.reflection.User");
// 构造一个对象
User user = (User) c1.newInstance(); // 本质上调用类的无参构造
System.out.println(user);

2、通过构造器创建对象

// 获得class对象
Class c1 = Class.forName("com.test.reflection.User");
// 通过构造器创建对象
Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
User user1 =(User) constructor.newInstance("小明",001,18); 
System.out.println(user1);

3、通过反射调用方法

// 获得class对象
Class c1 = Class.forName("com.test.reflection.User");

User user2 = (User) c1.newInstance();
// 通过反射获取一个方法
Method setName = c1.getDeclaredMethod("setName", String.class);
setName.invoke(user2,"小明");
System.out.println(user2.getName());

​ ps: invoke：激活的意思 // (对象，“方法的值”);

4、通过反射操作属性

// 获得class对象
Class c1 = Class.forName("com.test.reflection.User");
// 通过反射操作属性
User user3 = (User) c1.newInstance();
Field name = c1.getDeclaredField("name");

//不能直接操作私有属性
name.setAccessible(true);
name.set(user3,"小明22");
System.out.println(user3.getName());

​ ps : setAccessible : 作用是启动和禁用访问安全检查的开关

6、通过反射获取泛型

1、获取参数为泛型的方法

// 通过反射获取泛型
public class Test11 {

    public void test01(Map<String,User> map, List<User> list){
        System.out.println("test01");
    }

    public static void main(String[] args) throws NoSuchMethodException {
        Method method = Test11.class.getMethod("test01", Map.class, List.class);

        // 获取泛型的方法
        Type[] genericParameterTypes = method.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); // 打印参数类型
                }
            }
        }
    }


}

2、获取返回值类型为泛型的方法

// 通过反射获取泛型
public class Test11 {
    public Map<String,User> test02(){
        System.out.println("test02");
        return null;
    }

    public static void main(String[] args) throws NoSuchMethodException {
 
        // 获取返回值类型为泛型的方法
      	Method  method = Test11.class.getMethod("test02",null);

        Type genericReturnType = method.getGenericReturnType();
        // 判断该泛型是否为参数化类型
        if(genericReturnType instanceof ParameterizedType){
            // 强转为参数信息
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument); // 打印参数类型
            }
        }
    }


}

7、获取注解信息

1、环境搭建

创建两个注解

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

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

}

实体类使用注解

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

    @Override
    public String toString() {
        return "Student2{" +
                "id=" + id +
                ", age=" + age +
                ", 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;
    }

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

    public Student2(){

    }

}

2、通过反射获取注解

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

3、获取注解value的值

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

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

}

4、获取类指定的注解

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

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