注解和反射

最新推荐文章于 2025-05-23 17:03:50 发布

Syyccc初学Java

最新推荐文章于 2025-05-23 17:03:50 发布

阅读量61

点赞数

文章标签： java jvm mysql

本文链接：https://blog.youkuaiyun.com/m0_56159313/article/details/130541804

版权

注解和反射的重要性

注解和反射是所有框架的一个底层。

注解

Annotation是JDK5.0之后引入的一个新技术

作用：1.不是程序本身，可以对程序做出解释（这点和注释（comment）没什么区别）

2.可以被其他程序（比如：编译器）读取。

3.注解有对代码的检查作用

常用内置注解：


    @Override:此注解只适用于修饰方法，表示一个方法声明打算重写超类中的另一个声明
    @Deprecated:此注释可以用于方法，属性，类，表示不鼓励程序员使用这样的元素，通常是因为它很危险或者存在更好的选择
    @SuppressWarnings():用来抑制编译时的警告信息

注解可以在非常多的地方使用，例如package，class，method，field等上面，相当于给它们添加了额外的辅助信息（），我们可以通过反射机制编程实现对这些元数据的访问。

@interface：用于注解创建

注解的参数格式：参数类型参数名（）；

注解中的每一个方法实际上是声明了一个配置参数，方法的名称就是参数的名称，返回值类型就是参数类型（返回值只能是基本类型，Class,String,enum），可以通过default来声明参数的默认值，如果只有一个参数成员，一般参数名默认为value。注解元素必须要有值，我们定义注解元素是，经常使用空字符串，0作为默认值。

public @interface TestAnnotation {
    
    String value() default "中国计量大学";

}

注意：有默认值的话使用注解可以不加参数的值，不然必须指定参数的值，否则会报错

元注解的作用：负责注解其他注解，Java中有以下4个标准的meta-annotation类型，它们被用来提供对其他annotation类型做说明。

@Target：用于描述注解的使用范围（即：被描述的注解可以用在什么地方）

@Retention：表示注解在什么级别还存在该注释信息，用于描述注解的生命周期（SOURCE/源码<CLASS/.calss文件（编译后形成的文件）<RUNTIME（运行时）），Runtime所有地方都有效

@Document：说明该注解将被生成在Javadoc中

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

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {

    String school() default "中国计量大学";
    int age();
    int id()default -1;

}

反射

动态语言：是一类在运行时可以改变其结构的语言，通俗点就是在运行时代码可以根据某些条件改变自身的结构，例如JavaScript，Python，PHP

静态语言：与动态语言相对应，运行时结构不可变的语言，如Java，C++

Java不是动态语言，但Java可以称之为“准动态语言”。即Java具有一定的动态性，我们可以利用反射机制获得类似动态语言的特性。Java的动态性让编程变得更加灵活。

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

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

java反射机制提供的功能：1.在运行时判断任意一个对象所属的类 2.在运行是构造任意一个类的对象 3.在运行时判断任意一个类所具有成员变量和方法 4.在运行时获取泛型信息 5.在运行时调用任意一个对象的成员变量和方法 6.在运行时处理注解 7.生成动态代理 .......

对于每个类而言，JRE都为其保留一个不变的Class类型的对象。1.Class本身也是一个类 2.Class对象只能由系统建立 3.一个加载的类在JVM中只会有一个Class实例 4.一个Class对象对应的是一个加载到JVM中的一个.class文件 5.每个类的实例都会记得自己由哪个Class实例所生成（getClass（）方法） 6.Class类是Reflection的根源，针对任何你想动态加载，运行的类，唯有先获得相应的Class对象

创建Class类的方式

        //通过反射获取类的Class对象 //通过forName()获取，但需要知道包名
        Class user = Class.forName("com.kuanghui.pojo.User");
        //一个类在内存中只用一个Class对象
        //一个类被加载后，类的整个结构都会被封装到Class对象中
        System.out.println(user.hashCode());

        //通过类的class属性获取class
        Class user1 = User.class;
        System.out.println(user1.hashCode());

        //已知某个类的实例，通过实例Class
        User userEntity = new User("dhrn",51);
        Class user2 = userEntity.getClass();
        System.out.println(user2.hashCode());

注意：数组只要是元素类型与维度一样，那就是同一个Class。

类加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。类的加载（Load：将类的.class文件读入内存，并为之创建一个class对象。此过程由类加载器完成）--->类的链接（Link：将类的二进制数据合并到JRE中）--->类的初始化（Initialize:JVM负责对类进行初始化，由类构造器完成）

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

类加载器的作用：将class文件字节码内容加载到内存中，并将这些静态数据转化为方法区的运行时数据结构，然后在堆中生成一个代表这个类的Class对象，作为方法区中类数据的访问入口。

类缓存：一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

Class类常用方法

public class Test01 {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        Class user = Class.forName("com.kuanghui.pojo.User");
        //获得类的名字
        System.out.println(user.getName());
        System.out.println(user.getSimpleName());

        Field[] fields = user.getFields();//只能找到public属性
        Field[] declaredFields = user.getDeclaredFields();//找到所有属性

        Method[] methods = user.getMethods();//获取本类及其父类的public方法
        Method[] declaredMethods = user.getDeclaredMethods();//获取本类所有方法

        //获取指定方法
        Method methods1 = user.getMethod("getName", null);
        Method methods2 = user.getMethod("setName", String.class);

    }
}

动态创建对象执行方法

public class Test02 {

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //通过反射动态得创建对象
        //获得class对象
        Class c1 = Class.forName("com.kuanghui.pojo.User");
        //构造一个对象
        User user=(User)c1.newInstance();//本质调用的是类的无参构造器
        System.out.println(user);

        //通过指定构造器创建对象
        Constructor con = c1.getDeclaredConstructor(String.class, int.class);
        User instance = (User)con.newInstance("wanfg", 13);
        System.out.println(instance);

        //通过反射调用普通方法
        User user1 = (User) c1.newInstance();
        //通过反射获取一个方法
        Method getAge = c1.getDeclaredMethod("getAge", null);
        System.out.println(getAge.invoke(user1));
        Method setAge = c1.getDeclaredMethod("setAge", int.class);
        setAge.invoke(user1,15);
        System.out.println(getAge.invoke(user1));

        //通过反射去操作属性
        Field id = c1.getDeclaredField("id");
        //private的属性不能直接访问，不能直接操作私有属性，需要关闭程序的安全检测
        //必须设置SetAccessible
        id.setAccessible(true);
        id.set(user1,"王");
        System.out.println(user1.getId());

    }

}

setAccessible（）关闭访问安全检查可以提高反射的效率，因为如果没有关闭，这个安全检查就会被频繁调用。

ORM（Object Relationship Mapping）-->对象关系映射

类和表映射：类和表结构对应，属性和字段对应，对象和记录对应

public class Test3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("com.kuanghui.Test.Student");
        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
//        for(Annotation annotation:annotations){
//            System.out.println(annotation);
//        }
        Arrays.stream(annotations).forEach(System.out::println);

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

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

        //当以后使用框架时，我们需要通过反射去读取他们的注解

    }
}

@Table("db_student")
class Student{
    @Field(columnName = "id",type = "int",length = 10)
    private int id;
    @Field(columnName = "id",type = "int",length = 10)
    private int age;
    @Field(columnName = "id",type = "int",length = 10)
    private String name;
    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;
    }



}

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

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Field{
    String columnName();
    String type();
    int length();
}