JAVA-注解Annotation与反射Reflection

最新推荐文章于 2023-03-06 12:26:25 发布
最新推荐文章于 2023-03-06 12:26:25 发布
阅读量225 收藏 1
点赞数 1
分类专栏： java 文章标签： java 注解 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56981185/article/details/124944921
版权

注解

概念

  • Annotation是从JDK5.0开始引入的新技术
  • Annotation的作用：
  1. 不是程序本身，可以对程序作出解释
  2. 可以被其他程序（如编译器）读取
  • Annotation的格式：
    "@注释名"或"@注释名(参数值)"
  • Annotation使用位置：
    可以附加在package，class，method，field等等上面，相当于为其添加了额外的辅助信息，可以通过反射机制编程实现对这些元数据的访问

内置注解

  • @Override:定义在java.lang.Override中，表示一个方法声明打算重写超类中的另一个方法声明
  • @Deprecated：定义在java.lang.Deprecated中，表示不鼓励程序员使用这样的元素
  • @SuppressWarnings:定义在java.lang.SuppressWarnings中，用来抑制编译时的警告信息，他需要添加一个参数才能正确使用，这些参数是已经定义好的参数，例如
  1. @SuppressWarnings(“all”)
  2. @SuppressWarnings(“unchecked”)
  3. …

元注解

元注解的作用就是负责注解其他注解，java定义了4个标准的meta-annotation类型，他们被用来提供对其他annotation类型作说明

package com.utils;

import java.lang.annotation.*;

public class TestAnnotation {
    @MyAnnotation
    public static void main(String[] args) {
        System.out.println("测试注解");
    }
}

//Target 表示这个注解可以作用的地方
@Target(value = {ElementType.TYPE,ElementType.METHOD})
//Retention 表示我们的注解在什么地方起作用，runtime>class>sources
@Retention(value = RetentionPolicy.RUNTIME)
//Documented 表示是否将该注解生成在javaDoce中
@Documented
//Inherited 表示子类可以继承父类的注解
@Inherited
//定义一个注解使用@interface
@interface MyAnnotation{

}

自定义注解

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

package com.utils;

import java.lang.annotation.*;

public class TestAnnotation {
    @MyAnnotation
    public static void main(String[] args) {
        System.out.println("测试注解");
    }
}

//Target 表示这个注解可以作用的地方
@Target(value = {ElementType.TYPE,ElementType.METHOD})
//Retention 表示我们的注解在什么地方起作用，runtime>class>sources
@Retention(value = RetentionPolicy.RUNTIME)
//Documented 表示是否将该注解生成在javaDoce中
@Documented
//Inherited 表示子类可以继承父类的注解
@Inherited
//定义一个注解使用@interface
@interface MyAnnotation{

    //注解的参数 : 参数类型 参数名();
    String name() default "";
    int age() default 0;
    int length() default -1;//如果默认值为-1，代表不存在
}

//只有一个参数
@interface MyAnnotation2{

    String value();
}

反射机制

动态语言与静态语言

  • 动态语言：
    是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化，即在运行时代码可以根据某一些条件改变自身结构
    主要的一些动态语言例如：C#、JavaScript、PHP、Python等
  • 静态语言：
    即运行时结构不可变的语言，例如java、C、C++等等

Java虽然不是动态语言，但是Java具有一定的动态性，可以利用反射机制获得类似动态语言的特性，Java的动态性让编程的时候更加灵活！

反射

  • Reflection(反射)是java被视为动态语言的关键，反射机制允许程序在执行期间借助于Reflection API取得任何类的内部消息，并能够直接操作任意对象的内部属性以及方法
  • 加载玩类后，在堆内存的方法区就产生了一个Class类型的对象(一个类只有一个Class对象)，这个对象包含了完整的类的结构信息，
    在这里插入图片描述

反射优缺点

  • 优点：可以实现动态创建爱你对象和编译，体现出很大的灵活性
  • 缺点：对性能有影响，使用反射基本上是一种解释操作，我们可以告诉JVM,我们希望做什么并且它满足我们的要求，这类操作总是慢于 直接执行相同的操作。

Class类

在这里插入图片描述

获取Class实例在这里插入图片描述
获取类的运行时结构
package com.utils;

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

public class Test29 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class aClass = Class.forName("com.utils.Student");

        //获得类的名字
        System.out.println(aClass.getName());//包名+类名
        System.out.println(aClass.getSimpleName());//类名
        //获得类的属性
        Field[] fields = aClass.getFields();//只能获取public属性
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("--------");
        Field[] fields2 = aClass.getDeclaredFields();//获得全部属性
        for (Field field : fields2) {
            System.out.println(field);
        }
        //获得指定属性的值
        Field age = aClass.getDeclaredField("age");
        System.out.println(age);

        //获得类的方法
        System.out.println("----------");
        Method[] methods = aClass.getMethods();//获得本类及其父类全部public方法
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("----------");
        Method[] declaredMethods = aClass.getDeclaredMethods();//获得本类的所有方法
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }
        System.out.println("-------------");
        //获得指定方法
        Method method = aClass.getMethod("getName",null);
        Method method1 = aClass.getMethod("setName",String.class);
        System.out.println("-------------");
        //获得构造器
        Constructor[] constructors = aClass.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        Constructor[] declaredConstructors = aClass.getDeclaredConstructors();
        for (Constructor constructor : declaredConstructors) {
            System.out.println(constructor);
        }
        //获得指定的构造器
        Constructor declaredConstructor = aClass.getDeclaredConstructor(String.class,String.class);
        System.out.println(declaredConstructor);
    }
}
动态创建对象
package com.utils;

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

public class Test30 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException, NoSuchFieldException {
        //获得Class对象
        Class aClass = Class.forName("com.utils.Student");

        //1.构造一个对象
        Student o = (Student)aClass.newInstance();//本质是调用了类的无参构造器

        //2.通过构造器创建对象
        Constructor declaredConstructor = aClass.getDeclaredConstructor(String.class, String.class);
        Student user = (Student) declaredConstructor.newInstance("cx", "12");
        System.out.println(user);

        //通过反射调用方法
        Method setName = aClass.getDeclaredMethod("setName", String.class);
        setName.invoke(user,"cxe");
        System.out.println(user);

        //通过反射修改属性值
        Field name = aClass.getDeclaredField("name");
        name.setAccessible(true);//关掉权限检测，不然会报错，说私有属性不能访问
        name.set(user,"cx");
        System.out.println(user);
    }
}
setAccessible对性能的影响
package com.utils;

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

public class Test31 {
    public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
        Test31 test31 = new Test31();
        test31.t1();
        test31.t2();
        test31.t3();
    }

    //普通方式调用 最快
    public void t1(){
        Student student = new Student();
        long l = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            student.getName();
        }
        long l1 = System.currentTimeMillis();
        System.out.println(l1-l);
    }

    //反射方式 不关闭权限检测  最慢
    public void t2() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Student student = new Student();
        Class aClass = student.getClass();
        Method getName = aClass.getDeclaredMethod("getName");
        long l = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(student,null);
        }
        long l1 = System.currentTimeMillis();
        System.out.println(l1-l);
    }

    //反射方式 关闭权限检测 较慢
    public void t3() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Student student = new Student();
        Class aClass = student.getClass();
        Method getName = aClass.getDeclaredMethod("getName");
        //关闭权限检测
        getName.setAccessible(true);
        long l = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(student,null);
        }
        long l1 = System.currentTimeMillis();
        System.out.println(l1-l);
    }


}
反射操作泛型
  • java采用泛型擦除的机制来引入泛型，java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除，为了通过反射操作这些类型，java新增了ParameterizedType、GenericArrayType、TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型
  1. ParameterizedType:表示一种参数化类型，比如Collection< String >
  2. GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型
  3. TypeVariable：是各种类型变量的公共父接口
  4. WildcardType：代表一种通配符类型表达式
package com.utils;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

public class Test32 {
    public void t1(Map<String,Student> map, List<Student> list){
        System.out.println("t1");
    }
    public Map<String,Student> t2(){
        System.out.println("t2");
        return null;
    }
    public static void main(String[] args) throws NoSuchMethodException {
        Method t1 = Test32.class.getMethod("t1", Map.class, List.class);
        Type[] genericParameterTypes = t1.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println(genericParameterType);
            System.out.println("-------------");
            if (genericParameterType instanceof ParameterizedType){
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }
            }
        }

        System.out.println("---------------");
        Method t2 = Test32.class.getMethod("t2");
        Type genericReturnType = t2.getGenericReturnType();
        if (genericReturnType instanceof ParameterizedType){
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }

    }
}
反射操作注解
ORM

Object relationship Mapping :对象关系映射

  • 类和表结构对应
  • 属性和字段对应
  • 对象和记录对应
package com.utils;

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

@tableclass("cx_table")
public class Test33 {
    @columnfield(columnName="tb_id",type="int",length=12)
    private int id;
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class aClass = Class.forName("com.utils.Test33");
        //通过反射获得注解
        Annotation[] annotations = aClass.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //获得注解的value的值
        tableclass annotation = (tableclass)aClass.getAnnotation(tableclass.class);
        System.out.println(annotation.value());

        //获得类指定的注解
        Field ids = aClass.getDeclaredField("id");

        columnfield annotation1 = ids.getAnnotation(columnfield.class);
        System.out.println(annotation1.columnName());
        System.out.println(annotation1.type());
        System.out.println(annotation1.length());
    }
}

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

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

=========================================================
注解与反射 推荐狂神说

陈行恩
关注
专栏目录
注解与反射
The_Ink的博客
07-27 1092
注解与反射 注解（Annotation） 什么是注解 Annotation是从JDK5.0开始引入的新技术 Annotation的作用： 不是子程序本身，可以对程序作出解释（这一点和注释（comment）没什么区别） 可以被其他程序（比如：编译器等）读取 Annotation的格式： 注解是以“@注释名”在代码中存在的，可以添加一些参数值，例如：@SuppressWarnings(value=“unchecked”) Annotation在哪里使用： 可以附加在package、class、m
java-reflection-annotation-test:探索java反射和注解之美
07-09
接下来，我们来谈谈Java注解（Annotation）。注解是一种元编程手段，它允许我们在代码中添加元数据。这些元数据可以被编译器、IDE或运行时系统用来进行代码分析、验证、优化等。注解分为三种类型： 1. **保留注解**...
java 反射 annotation_Java自定义Annotation,通过反射解析Annotation
weixin_42300329的博客
02-24 141
创建一个自定义的Annotationimport java.lang.annotation.*;import java.lang.reflect.Method;@Documented@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface MethodInfo {String author() d...
java注解(Annotation)和反射(Reflection)
缘友一世的博客
12-28 716
interface@interface@interface自定义注解，自动继承了java.lang.annotation.Annotationjava.lang.annotation.Annotation接口@interface@interface@interfacepublic@interface。
JavaSE 注解(Annotation)和反射(Reflection)
weixin_43664907的博客
02-25 185
注解Annotation 1、什么是注解 Annotation是从JDK5.0开始引入的新技术 Annotation的作用 不是程序本身，可以对程序做出解释。(这一点和注释(comment)没什么区别) 可以被其他程序（比如：编译器）读取。 Annotation的格式 主解是以“@注释名”在代码中存在的 还可以添加一些参数值，例如：@SuppressWarings(values=“unchecked”) Annotation在哪里使用？ 可以附加在package，class，method，f
注解Annotation
01-14 111
元注解：　　元注解的作用就是负责注解其他注解。Java5.0定义了4个标准的meta-annotation类型，它们被用来提供对其它 annotation类型作说明。Java5.0定义的元注解：　　　　1.@Target,　　　　2.@Retention,　　　　3.@Documented,　　　　4.@Inherited　　这些类型和它们所支持的类在java.lang.annotati...
java--注解和反射
最新发布
qq_45929019的博客
03-06 904
java专题---注解和反射的理解。
Java---注解与反射
鹤鸣呦呦、、的博客
07-28 202
注解与反射学习-----为SSM框架打下基础
Android-注解与反射注解知识点反射知识点注解java反射
08-13
在Android开发中，注解（Annotation）和反射（Reflection）是两个重要的概念，它们极大地提升了代码的可维护性、灵活性和动态性。本篇将详细阐述这两个知识点，并结合实际示例进行讲解。 **注解（Annotation）** 1...
Java基础-注解和反射
09-11
### Java基础-注解和反射 #### 注解(Annotation) 从JDK5开始，Java引入了一个重要的特性——元数据支持，即注解。这是一项强大的功能，它允许开发者在不改变原有代码逻辑的情况下向源代码中添加额外的信息。注解在...
Java注解与反射原理说明
08-26
Java注解（Annotation）是Java语言提供的一种元数据机制，允许程序员在代码中嵌入信息，这些信息可以被编译器、JVM或其他工具在编译时或运行时读取和处理。注解的主要用途包括代码的自我描述、编译器检查、运行时的...
JavaSE-注解与反射(框架底层实现机制)
12-21
JavaSE中的注解（Annotation）和反射（Reflection）是两种非常重要的编程特性，它们在现代Java框架和库的实现中起着至关重要的作用。自从JDK5.0引入注解以来，它已经成为编写更加优雅、可维护代码的一种手段。而反射...
java-如何反编译
此后如竟没有炬火我便是唯一的光
06-01 9636
java反编译
前端后端数据交换乱码问题
此后如竟没有炬火我便是唯一的光
05-22 3097
请求乱码 浏览器发送请求时使用的是什么编码呢？ 浏览器打开表单页面时使用的什么编码就会用什么编码发送数据，我们可以通过设置打开表单页面的编码来控制页面发送数据时的编码。假设表单页面是utf-8，则这个页面发送请求参数用的也是utf-8。 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> 而服务器是用什么编码解析的呢？ 以tomcat6为例，服务器默认用iso8859-1来解码，用utf-8编码，这就产生了乱
Java-MVC三层架构
此后如竟没有炬火我便是唯一的光
07-03 3016
MVC 三层架构
java-JDBC详解
此后如竟没有炬火我便是唯一的光
06-21 2221
1.准备数据库 2.导入驱动 3. 创建java 1和2 两种方式都可以，推荐使用下面一种，因为Driver这个类： 不明白反射的可以去 反射机制 事务已经提交了,提交了就不能回滚了 因为是先发生了错误，此时数据还没有被提交，所以事务进行了回滚 SQL注入问题 PreparedStatement (防止SQL注入） 报错： ResultSet 创建第一个JDBC–工具类版 JDBCUtil.java JdbcDemo.java 创建第一个JDBC–工具类版properties优化
在IntelliJ IDEA配置Tomcat
此后如竟没有炬火我便是唯一的光
02-23 2142
1、点击Run-Edit Configurations... 2、点击左侧“+”，选择Tomcat Server--Local， 3、在Tomcat Server -> Unnamed -> Server -> Application server项目下，点击 Configuration ，找到本地 Tomcat 服务器，再点击 OK按钮。 至此，IntelliJ IDEA配置Tomcat完成。 .........
JAVA学习之路遇到的报错信息以及解决方法(持续更新中)
此后如竟没有炬火我便是唯一的光
07-04 2099
当你在发布WEB项目的时候，出现了这个错误。此时你可以先去查看其他博主或者网上查询相关的解决方案，如果还是不能解决问题，那么就试试此方法；
Java注解与反射详解
"java注解和反射的个人学习笔记" 在Java编程中，注解（Annotation）和反射（Reflection）是两种强大的工具，它们为开发者提供了更高级别的抽象和动态操作能力。注解自JDK 5.0版本起引入，主要用于提供元数据，即...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

陈行恩

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值