Java-注解和反射

注解-Annotation

注解概念

1. 注解Annotation 是从JDK5.0开始引入的新技术;

2. Annotation的作用:

    - 不是程序本身 , 可以对程序作出解释.(这一点和注释(comment)没什么区别)
    - 可以被其他程序(比如:编译器等)读取.
   

3. Annotation的格式:

    - 注解是以"@注释名"在代码中存在的
    - 还可以添加一些参数值 , 例如:@SuppressWarnings(value="unchecked")
   

4. Annotation在哪里使用?

    - 可以附加在package , class , method , field 等上面 , 相当于给他们添加了额外的辅助信息
    - 我们可以通过反射机制实现对这些元数据的访问
   

内置注解(3个)

1. @Override

    定义在 java.lang.Override 中 , 此注释只适用于修辞方法 , 表示一个方法声明打算重写超类中的另一个方法声明.
   

2. @Deprecated

    定义在java.lang.Deprecated中 , 此注释可以用于修辞方法 , 属性 , 类 ，过时被淘汰
    比如: ~~test()~~(中间有一个杠)
   

3. @SuppressWarnings

    定义在java.lang.SuppressWarnings中,用来抑制编译时的警告信息.
    与前两个注释有所不同,你需要添加一个参数才能正确使用,这些参数都是已经定义好了的,我们选择性的使用就好了 .
    @SuppressWarnings("all")
    @SuppressWarnings("unchecked")
    @SuppressWarnings(value={"unchecked","deprecation"})  .....
   

元注解(4个)

1. 描述

    元注解的作用就是负责注解其他注解 , Java定义了4个标准的meta-annotation类型,他们被用来提供对其他annotation类型作说明 .
    这些类型和它们所支持的类在java.lang.annotation包中可以找到 .( @Target , @Retention ,@Documented , @Inherited )
    - @Target : 用于描述注解的使用范围(即:被描述的注解可以用在什么地方)
    - @Retention : 表示需要在什么级别保存该注释信息 , 用于描述注解的生命周期(SOURCE < CLASS < RUNTIME) 一般常用RUNTIME，表示运行时有效
    - @Document：说明该注解将被包含在javadoc中
    - @Inherited：说明子类可以继承父类中的该注解
   

2. 自定义一个注解

   public class MyAnnotation {
   
   	@MyAnnotation
       public void test(){
   
       }
   }
   @Target(value={ElementType.METHOD,ElementType.TYPE})  # {方法上，类上}
   @Retention(value=RetentionPolicy.RUNTIME) #运行时有效
   @Inherited
   @Documented
   @interface MyAnnotation {
   }
   

自定义注解

1. 使用 @interface自定义注解时 , 自动继承了java.lang.annotation.Annotation接口
2. 分析 :
   • @interface用来声明一个注解 , 格式 : public @ interface 注解名 { 定义内容 }
   • 其中的每一个方法实际上是声明了一个配置参数.
   • 方法的名称就是参数的名称.
   • 返回值类型就是参数的类型 ( 返回值只能是基本类型,Class , String , enum ).
   • 可以通过default来声明参数的默认值如果只有一个参数成员 , 一般参数名为value
   • 注解元素必须要有值 , 我们定义注解元素时 , 经常使用空字符串,0作为默认值
3. 代码展示

   public class MyAnnotation {
       //显示定义值/不显示值就是默认值
       @MyAnnotation2(age=18,name="孙智恒",id=001,schools={"xxxx"})
       public void test2(){
   
       }
       //***只有一个参数,默认名字一般是value,使用可省略不写***
       @MyAnnotation3("aaa")
       public void test3(){
   
       }
   }
   
   @Target(value={ElementType.METHOD})
   @Retention(value=RetentionPolicy.RUNTIME)
   @interface MyAnnotation2 {
       //参数类型 参数名称
       String name() default "";
       int age() default 0;
       int id() default 1;
       String[] schools() default {"szh1","szh2"};
   }
   
   @Target(value={ElementType.METHOD})
   @Retention(value=RetentionPolicy.RUNTIME)
   @interface MyAnnotation3 {
       //参数类型 参数名称
       String value();
   }
   

反射-Reflection

JavaReflection描述

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

(3).Java反射优点和缺点优点：
优点：可以实现动态创建对象和编译，体现出很大的灵活性 !
缺点：对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作。
(4).反射主要API介绍:
java.lang.Class : 代表一个类
java.lang.reflect.Method : 代表类的方法
java.lang.reflect.Field : 代表类的成员变量
java.lang.reflect.Constructor : 代表类的构造器

获取Class对象的方式

(1)在Object类中定义了以下的方法
public inal Class getClass();
此方法将被所有子类继承以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。
(2)Class 本身也是一个类Class 对象,只能由系统建立对象一个加载的类在 JVM 中只会有一个Class实例一个Class对象对应的是一个加载到JVM中的一个
(3)class文件每个类的实例都会记得自己是由哪个 Class 实例所生成,通过Class可以完整地得到一个类中的所有被加载的结构
(4)Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

//获得class办法一:通过对象获得
Class clazz1 = person.getClass();
//获得class办法二:通过字符串获得(包名+名)
Class clazz2 = Class.forName("com.reflection.Student");
//获得class办法三:通过类的静态成员class获得
Class clazz3 = Person.class;
//获得class办法四:只针对内置的基本数据类型
Class clazz4 = Integer.TYPE;
//获得父类类型
Class clazz5 = clazz2.getSuperclass();

Class类的常用方法

获取Class类的实例

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

Class clazz = User.class;

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

Class clazz = user.getClass();

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

Class clazz = Class.forName("com.szh.web.User");

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

Class<Integer> clazz = Integer.TYPE;

哪些类型存在Class对象

	Class c1 = Object.class; //类
	Class c2 = Comparable.class; //接口
	Class c3 = String[].class; //一维数组
	Class c4 = int[][].class;  //二维数组
	Class c5 = ElementType.class; //枚举
	Class c6 = Override.class; //注解
	Class c7 = Integer.class; //基本数据类型
	Class c8 = void.class; //void
	Class c9 = Class.class; //Class

反射获取类名，属性，方法，构造方法

// 获取类的Class对象
Class clazz = Class.forName("com.szh.basicjava.reflection.User");

// 获取类名
String strName01 = clazz.getName();// 获取包名+类名:com.szh.basicjava.reflection.User
String strName02 = clazz.getSimpleName();// 直接获取类名:User

// 获取属性
Field[] field01 = clazz.getFields(); // 只返回属性为public的字段
Field[] field02 = clazz.getDeclaredFields(); // 返回所有的属性
Field field03 = clazz.getDeclaredField("id"); // 获取属性为id的字段

// 获取普通方法
Method[] Method01 = clazz.getMethods(); // 返回本类和父类所有的public方法
Method[] Method02 = clazz.getDeclaredMethods(); // 返回本类所有的方法
Method method = clazz.getDeclaredMethod("getId", null); // 返回getId这个方法，如果没有参数，就默认为null
Method method1 = clazz.getDeclaredMethod("getId", String.class);

// 获取构造方法
Constructor[] constructors = clazz.getConstructors();//返回所有的public构造方法方法
Constructor[] declaredConstructors = clazz.getDeclaredConstructors();//返回所有的构造方法
Constructor declaredConstructor = clazz.getDeclaredConstructor(int.class, String.class, int.class);// 根据参数制定构造方法

反射创建对象，调用方法，操作属性

// 获取类的Class对象
Class clazz = Class.forName("com.szh.basicjava.reflection.User");

// 通过反射创建对象
User u1 = (User) clazz.newInstance(); // 默认通过User类的无参构造函数创建
Constructor c2 = clazz.getDeclaredConstructor(int.class, String.class, int.class);// 指定构造器创建对象
User u2 = (User) c2.newInstance(1001, "张三", 10);

// 通过反射调用普通方法
User u3 = (User) clazz.newInstance();
Method method03 = clazz.getDeclaredMethod("setId", int.class);
method.invoke(u3, 1002); // 激活方法,把对象u3的id置为1002

// 通过反射操作类的属性
User u4 = (User) clazz.newInstance();
Field f = clazz.getDeclaredField("name");
f.setAccessible(true); // ***访问私有属性，取消安全监测***
f.set(u4, "李四");

整合-反射读取注解

Demo:利用注解和反射完成类和表结构的映射关系

Object relationship Mapping --> 对象关系映射
类和表结构对应      
属性和字段对应

1.定义注解

// 定义类的注解
@Target(value={ElementType.TYPE})//类上
@Retention(value= RetentionPolicy.RUNTIME)
@interface UserTable {
    String value();
}

// 定义类中属性的注解
@Target(value={ElementType.FIELD})//属性上
@Retention(value=RetentionPolicy.RUNTIME)
@interface UserField {
    String columnName();// 别名
    String type();// 类型
    int length(); // 长度
}

2.在类中使用注解

@UserTable("db_user")
public class User implements Serializable {

    @UserField(columnName = "db_id",type = "int",length = 10)
    private int id;
    @UserField(columnName = "db_name",type = "varchar",length = 200)
    private String name;
    @UserField(columnName = "db_age",type = "int",length = 3)
    private int age;

    public User() {
    }

    public User(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 "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

3.使用反射获取注解

public class Test {
    public static void main(String[] args) {
        try{
            //反射,Class可以获得类的全部信息
            Class clazz = Class.forName("com.szh.basicjava.reflection.User");

            //获得类的注解
            Annotation[] annotations = clazz.getAnnotations();
            for(Annotation annotation:annotations) {
                System.out.println(annotation);
            }
            //获得类的注解value的值
            UserTable userTable = (UserTable) clazz.getAnnotation(UserTable.class);
            System.out.println(userTable.value());

            //获得类指定注解的值
            Field name = clazz.getDeclaredField("name");
            UserField userField = name.getAnnotation(UserField.class);
            System.out.println(userField.columnName() +"==="+userField.type()+"==="+userField.length());

            //我们可以根据得到的类的信息,通过JDBC生成相关的SQL语句,执行就可以动态生成数据库表

        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

4.测试