注解与反射

笔记整理于@bilibili遇见狂神说

注解(Annotation)

什么是注解

可被程序读取的注释

注解的格式

@Override
@Deprecated

内置注解

//在java.lang.Override中定义,表示重写
@Override

//在java.lang.Deprecated中定义,表示已过时
@Deprecated

//镇压警告
@SuppressWarnings

元注解

解释其他注解的注解

//描述注解的使用范围
@Target

//表示需要在什么级别保存该注释信息
//SOURCE<CLASS<RUNTIME
//源码<编译<运行
@Retention

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

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

自定义注解

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

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{
	String name() default "";
	String[] schools() default {"安工大","铜陵一中"}
}

String name()不是方法,是参数类型+参数名

如果只有一个值可以使用value进行命名
注解默认值的名字是value,可以直接写值

反射(Reflection)

什么是反射

正常情况:引入需要的包类名称->通过new实例化->取得实例化对象

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

允许程序在执行迄今取得任何类的内部信息
并能直接操作任意对象内部的属性和方法

Class类

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

获取Class类的方法

已知类的全类名

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

已知具体的类,通过类的class属性获取,安全,可靠

Class clazz = Person.class;

已知某个类的实例

Class clazz = person.getClass();

内置基本数据类型可以直接用类名

ClassLoader..

总结:

package org.example;


//测试class类的创建方式有哪些
public class Test {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("这个人是"+person.name);

        //方式一：通过对象获得
        Class<?> c1 = person.getClass();
        System.out.println(c1.hashCode());
        //方式二：forName获得
        Class<?> c2 = Class.forName("org.example.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);
    }
}

//实体类
class Person{
    String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

class Student extends Person{
    public Student(){
        this.name= "学生";
    }
}

class Teacher extends Person{
    public Teacher(){
        this.name="老师";
    }
}

哪些类可以有class对象

package org.example;


import java.lang.annotation.ElementType;

//所有类型的class
public class Test04 {
    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;//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);

    }
}

获得类的信息

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

//获得类的信息
public class Test08 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("org.example.User");

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

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

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

        //获得类的方法
        Method[] methods = c1.getMethods();//获得本类以及父类的全部public方法
        for (Method method : methods) {
            System.out.println(method);
        }
        methods = c1.getDeclaredMethods();//获得本类的全部方法，包括私有
        for (Method method : methods) {
            System.out.println(method);
        }

        //获得指定方法
        Method getName = c1.getMethod("getName", null);
        Method setName = c1.getMethod("setName", String.class);
        System.out.println(getName);
        System.out.println(setName);

        //获得指定的构造器
        Constructor[] constructors = c1.getConstructors();//public
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        constructors = c1.getDeclaredConstructors();//全部
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        //获得指定的构造器
        Constructor<?> declaredConstructor = c1.getDeclaredConstructor(String.class,int.class,int.class);
        System.out.println(declaredConstructor);

    }
}

反射操作对象

package org.example;


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


//动态创建对象，通过反射
public class Test09 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class<?> c1 = Class.forName("org.example.User");
        //构建对象
        User user = (User)c1.newInstance();//调用了无参构造器
        System.out.println(user);
        //通过构造器创建对象
        Constructor<?> declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        User user1 = (User) declaredConstructor.newInstance("wfj",001,18);
        System.out.println(user1);
        //通过反射调用普通方法
        User user2 = (User)c1.newInstance();
        Method setName = c1.getDeclaredMethod("setName", String.class);
        setName.invoke(user2,"wfj");
        System.out.println(user2.getName());
        //通过反射操作属性
        User user3 = (User) c1.newInstance();
        Field name = c1.getDeclaredField("name");

        //安全检测关闭，使用私有属性
        name.setAccessible(true);

        name.set(user3,"wfj");
        System.out.println(user3.getName());
    }
}

setAccessible()方法性能比较高

具体：普通方法>关闭权限检测的反射>开启权限检测的反射方法

反射操作注解

ORM对象关系映射

类和表结构对应
属性和字段对应
对象和记录对应

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

package org.example;

import java.lang.annotation.*;

public class Test12 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class<?> c1 = Class.forName("org.example.Student2");

        //通过反射获取注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //获取注解value的值
        Table annotation = (Table) c1.getAnnotation(Table.class);
        String value = annotation.value();
        System.out.println(value);

        //获得类指定注解
        java.lang.reflect.Field f = c1.getDeclaredField("name");
        Field annotation1 = f.getAnnotation(Field.class);
        System.out.println(annotation1.columnName());
        System.out.println(annotation1.length());
        System.out.println(annotation1.type());
    }
}


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

    public Student2(){

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

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

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

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

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public int getAge() {
        return age;
    }

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


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


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

本栏目推荐文章
• 如何让spring扫描到自定义注解的组件
• 面试官：实际工作中哪里用到了自定义注解？
• @Scheduled注解与参数 1、fixedDelay 2、fixedRate 3 、initialDelay 4、cron
• Spring 基于注解管理bean
• 40 个 SpringBoot 常用注解：让生产力爆表！
• 简单实现Aop和注解配合使用
• 韩顺平java基础-11-枚举类与注解
• 比较一下配置类加注解的方式和使用XML的区别
• Spring学习记录之Spring-IoC注解式开发
• spring 事务注解

注解注解mq 注解bean 注解java 注解aop 注解test 注解valid 注解spring spring注解 注解python 注解mapper