注解与反射

1.注解(Annotation)

1.1 注解的定义

注解就是源代码的元数据，通俗的讲就是代码中的标签。
注解有如下特点：
1.注解是一个附属品，依赖其他元素(包，类，方法，属性等等)存在
2.注解本身没有作用，在恰当的时候由外部程序进行解析才会发生作用

1.2 注解的分类

1.按照来源分

• JDK自带注解，例如@Override,@Deprecated,@SuppressWornings
• 第三方注解
• 自定义注解

2.按照生命周期划分

• SOURCE:只存在于源代码中，编译成class文件就不存在了
• Class：存在与源代码中和class文件中
• RUNTIME：注解保留到运行时

1.3 元注解

元注解指的是用于修饰注解的注解

1.@Retention：指明 Annotation 的生命周期，传入的值是一个枚举类型，可选值为：

• RetentionPolicy.SOURCE
• RetentionPolicy.CLASS
• RetentionPolicy.RUNTIME

2.@Target：指明 Annotation 可以修饰程序哪些元素，传入的值为ElemetType[] 类型，值可为：

• ElementType.CONSTRUCTOR ：构造器
• ElementType.FIELD：属性
• ElementType.LOCAL_VARIABLE：局部变量ElementType.METHOD：方法
• ElementType.PACKAGE：包
• ElementType.PARAMETER：参数
• ElementType.TYPE：类、接口（包括注解类型和 enum 声明）

3.@Documented：使用此修饰的注解将会被 javadoc 工具提取成文档，使用此注解，其 @Retention 必须被设置为 RetentionPolicy.RUNTIME 。
4.@Inherited：具有继承性。

1.4 自定义注解

自定义注解需要注意的问题：

• 使用 @interface 关键字定义。
• 自动继承 java.lang.annotation.Annotation 接口。
• 配置参数的类型只能是八大基本类型、String、Class、enum、 Annotation 和对应的数组类型。
• 配置参数声明的语法格式如下（[] 表示可省略）：类型 变量名() [default 默认值];
• 如果只有一个配置参数，其参数名必须为 value。
• 如果定义的注解含有配置参数，那在使用注解时，必须指定参数值，指定形式为：“参数名=参数值”。如果只有一个参数，直接写参数值即可，定义中指定了默认值的参数可以不指定值，但没有的一定要指定值。
• 没有成员的注解为标记，包含成员的称为元数据。

1.5 代码解释

//Target表明我们的注解可以用在那些地方，用在方法，属性上
@Target(value={ ElementType.METHOD,ElementType.TYPE})
//Retention表明我们的注解在什么地方还有效
@Retention(value= RetentionPolicy.RUNTIME)
//Documented 表示是否将我们的注解生成在JAVAdoc中
@Documented
//Inherited 子类可以继承父类的注解
@Inherited
@interface my{
}

public class Main {
	//注解可以显示赋值，如果没有默认值，我们就必须给注解赋值
	@my(name="cc",school = "清华")
	public void cc(){}
	public static void main(String[] args) {}
}
@Target(value={ ElementType.METHOD,ElementType.TYPE})
@Retention(value= RetentionPolicy.RUNTIME)
@Documented
@Inherited
@interface my{
	//注解的参数：参数类型+参数名()
	String name() default "";
	int age()default 0;
	int id()default -1;//如果为-1，代表不存在
	String[] school();
}
	

2 反射

2.1 什么是反射

反射指的是程序在运行期间借助反射API取得任何类的内部信息，并通过这些内部信息去操作对应对象的内部属性和方法

任何一个类，在第一次使用时，就会被JVM加载到堆内存中，JVM加载类成功后，就会在方法区中产生一个对应的Class对象(一个类只要一个Class对象)，这个Class对象包含被加载类的全部结构信息

2.2 获取Class对象的常用方式

1 类的class属性

每一个类，都有一个 class 静态属性，这个静态属性就是类对应的 Class 对象。

Class<Person> cl1 = Person.class; 

2 Object 对象 的 getClass() 方法

Person p1 = new Person()；
Class<Person> cl2 = (Class<Person>) p1.getClass(); 

3 通过 Class 类的 forName() 方法（最常用）

try {
     Class cl3 = Class.forName("com.cc.Person");
 } catch (ClassNotFoundException e) {
     e.printStackTrace();
 }

4 通过 ClassLoader 类（不常用）

 ClassLoader cl = Person.class.getClassLoader();
 try {
     Class cl4 = cl.loadClass("com.cc.Person");
 } catch (ClassNotFoundException e) {
     e.printStackTrace();
 }

2.3 反射的基本使用

反射的基本使用包括创建对象，设置属性和调用方法，Class对象中大多数get方法有Declared和无Declared
1.无 Declared：只能获取到 public 修饰的，包括当前类和所有父类。
2.有 Declared：获取到当前类所有的（含有 private），但不包括其父类。

2.3.1 获得注解信息

package com.company;

import sun.awt.geom.AreaOp;

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

public class Main {

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

        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

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


        //获得类指定的注解 通过name来查看详细的信息，也可以通过id，age来获得信息
        Field f1 = c1.getDeclaredField("name");
        FieldCc annotation = f1.getAnnotation(FieldCc.class);
        System.out.println(annotation.colnumName());
        System.out.println(annotation.type());
        System.out.println(annotation.lenght());


    }
}
@Table(Value = "db_student")
class student{
    @FieldCc(colnumName = "db_id",type = "int",lenght = 10)
    private int id;
    @FieldCc(colnumName = "db_age",type = "int",lenght = 10)
    private int age;
    @FieldCc(colnumName = "db_name",type = "varchar",lenght = 3)
    private String name;

    public student() {
    }

    public student(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 "student{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
//类名的注解
@Target(value = ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table{
    String Value();
}

//属性的注解
@Target(value = ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldCc{
    String colnumName();
    String type();
    int lenght();

}

2.4 设计模式：代理模式

使用一个代理对象将原始对象包装起来，然后用该代理对象取代原始对象，任何对原始对象的调用都要通过代理对象，代理对象决定是否以及何时将代理方法调用转到原始对象上。

2.4.1 静态代理

代理类和原始对象在编译期间就确定下来了，不利于程序的扩展，且每一个代理之能为一个接口服务，这就会在开发的过程中产生多大的代理类

静态代理的实现：

• 代理类和原始对象实现相同的接口。
• 代理类保持原始对象的引用。
• 代理类里调用原始对象的方法。

2.4.2 动态代理模式

动态代理是通过 Java 的反射机制实现的。通过动态代理，只需一个代理对象就可以代理所有的对象。