反射与注解

最新推荐文章于 2023-08-08 22:15:40 发布

转机器学习去

最新推荐文章于 2023-08-08 22:15:40 发布

阅读量212

点赞数

文章标签： java spring boot

本文链接：https://blog.csdn.net/zhangshuai66/article/details/125836858

版权

本文深入探讨Java反射机制，包括其概念、优缺点、应用场景及常用API，展示了如何通过反射创建对象、调用方法和设置属性。此外，还介绍了注解的基本概念、元注解以及注解的生效原理，并通过一个自定义限流注解的示例阐述了注解在实际项目中的应用。

摘要由CSDN通过智能技术生成

反射和自定义注解

每特学习笔记 viaBeau

大纲：

1、什么是反射、反射的优缺点

2、反射的用途/反射应用场景

3、反射调用方法/给属性赋值

4、反射如何越过泛型检查

5、什么是注解/注解生效的原理

6、自定义注解实现API接口限流框架

1、反射机制

什么是反射

通过反射，我们可以在运行时获得程序或程序集中每一个类型的成员和成员的信息。程序中一般的对象的类型都是在编译期就确定下来，而Java反射机制可以动态地创建对象并调用其属性，这样的对象的类型在编译器是未知的

Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象后，再通过class对象进行反编译，从而获取对象的各种信息。
Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态创建对象并调用其属性，不需要提前在编译期知道运行的对象是哪个类型。

使用反射机制可以动态获取当前class的信息，比如方法的信息、注解信息、方法的参数、属性等

第三方框架–创建对象不是直接new 而是通过反射机制创建

反射的目的：提供开发者能够更好地封装框架实现扩展功能

1.1反射的优缺点

优点：提供开发者能够更好地封装框架实现扩展功能

在运行时获得类的各种内容，进行反编译，对于Java这种先编译在运行的语言，能够让我们很方便的创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代码的链接，更加容易实现面向对象
缺点：
- （1）反射会消耗一定的系统资源，所以如果不需要动态创建一个对象，就不必要用反射
- （2）反射调用方法时可以忽略权限检查，因此可能会破坏封装性而导致安全问题
  - 一个类中，定义的私有属性或方法，反射机制可以越过权限破解私有属性

1.2反射的用途/应用场景

通过反射机制访问java对象的属性、方法、构造方法等
JDBC加载驱动链接 class.forName
Spring容器框架IOC实例化对象
自定义注解生效（反射+AOP）
第三方核心框架（Mybatis的ORM思想）

1.3反射技术的使用

Class类代表类的实体，在运行的Java应用程序中表示类和接口

Field类代表类的成员变量（成员变量也称为类的属性）

Method类代表类的方法

Constructor类代表类的构造方法

1.getField、getMethod和getCostructor方法可以获得指定名字的域、方法和构造器。

2.getFields、getMethods和getCostructors方法可以获得类提供的public域、方法和构造器数组，其中包括超类的共有成员。

3.getDeclaredFields、getDeclaredMethods和getDeclaredConstructors方法可以获得类中声明的全部域、方法和构造器，其中包括私有和受保护的成员，但不包括超类的成员。

1.4反射技术常用API

1.4.1获取class
- 任何数据类型（包括基本数据类型）都有一个“静态”的class属性
- 运行期间，一个类只有一个Class对象产生

        //1、获取class的方法
        /*
        ①直接通过类名获取 User.class
        ②Class.forName("类的完整路径名")  类的完整路径名=包名+类名
        ③实体对象.getClass()
        * */
        //第一种
        Class<User> userClass1 = User.class;
        //第二种
        Class<User> userClass2 = (Class<User>) Class.forName("反射.User");
        //第三种
        User user=new User();
        Class<User> userClass3= (Class<User>) user.getClass();
		//2、 userClass1==userClass2==userClass3

1.4.2反射执行构造函数

执行无参构造函数(通过 Class.newInstance() )

//2、默认执行无参构造函数
User user1 = (User) userClass1.newInstance();

执行有参构造函数 (借助Constructor对象)

//3、执行有参构造函数
Constructor<User> con=userClass1.getConstructor(String.class,Integer.class);
User user2=con.newInstance("Beau",23);

1.4.3反射执行给属性赋值

反射执行给公有属性赋值不加Declared（同时也可以获取超类的属性）

Field nameField = userClass1.getField("name");
User user2 = userClass1.newInstance();
nameField.set(user2,"Beau");

反射执行给私有属性赋值

Field ageField=userClass1.getDeclaredField("age");
User user3 = userClass1.newInstance();
// 设置允许访问私有属性
ageField.setAccessible(true);
ageField.set(user3,23);

1.4.4反射执行调用方法

//类中声明的公有方法
public void SayHello(String name){
   System.out.println("你好,"+name);
}
//类中声明的私有方法
private void SayBye(){
   System.out.println("byebye了");
}

反射调用公用方法

//        反射调用公有方法
Method sayHello = userClass1.getMethod("SayHello", String.class);
User user4 = userClass1.newInstance();
sayHello.invoke(user4,"SSR");

反射调用私有方法

//        反射调用私有方法
Method sayBye = userClass1.getDeclaredMethod("SayBye");
// 设置允许访问私有属性
sayBye.setAccessible(true);
sayBye.invoke(user4);

1.4.5通过反射越过泛型检查

泛型用在编译期，编译过后泛型擦除（消失掉），所以是可以通过反射越过泛型检查的

//前面的代码例子
Method sayBye = userClass1.getDeclaredMethod("SayBye");
// 设置允许访问私有属性
sayBye.setAccessible(true);

Field ageField=userClass1.getDeclaredField("age");
// 设置允许访问私有属性
ageField.setAccessible(true);

2、注解

2.1、什么是注解

注解用来给类声明附加额外信息，可以标注在类、字段、方法等上面，编译器、JVM以及开发人员都可以通过反射拿到注解信息，进而做一些相关处理

SpringBoot全部为注解化

2.2 元注解

元注解用来在声明新注解时指定新注解的一些特性
三个元注解：@Target、@Retention、@Inherited
- @Target 指定新注解标注的位置，比如类、字段、方法等，
  - TYPE：类、接口（包括注解类型）和枚举的声明
    
    FIELD：字段声明（包括枚举常量）
    
    METHOD：方法声明
    
    PARAMETER：参数声明
    
    CONSTRUCTOR：构造函数声明
    
    LOCAL_VARIABLE：本地变量声明
    
    ANNOTATION_TYPE：注解类型声明
    
    PACKAGE：包声明
    
    TYPE_PARAMETER：类型参数声明，JavaSE8引进，可以应用于类的泛型声明之处
    
    TYPE_USE：JavaSE8引进，此类型包括类型声明和类型参数声明
- @Retention 指定新注解的信息保留到什么时候，

请添加图片描述

@Inherited 指定新注解标注在父类上时可被子类继承

2.3 获取注解信息

获取类上的注解（借助Class对象的getDeclaredAnnotation（annotaion.class)获取

Class<Test> clazz = Test.class;
MyAnno myAnno = clazz.getDeclaredAnnotation(MyAnno.class);

获取当前方法上的注解

Method method = clazz.getDeclaredMethod("method", String.class);
MyAnno myAnno1 = method.getDeclaredAnnotation(MyAnno.class);

获取字段上的注解

Field test = clazz.getDeclaredField("test");
MyAnno myAnno2 = test.getAnnotation(MyAnno.class);

获得构造方法注解

Constructor<Test> con=clazz.getConstructor();
MyAnno myAnno3 = con.getAnnotation(MyAnno.class);

2.4 注解如何生效

实际项目中，注解生效通过反射 + AOP机制
注解实现案例之自定义限流注解

构建Maven项目 使用Spring框架实现
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.1.RELEASE</version>
</parent>
<dependencies>
    <!--  springboot 整合web组件-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>18.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.12.0</version>
    </dependency>

</dependencies>

//注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CurrentLimit {
    /***
     * name为限流的名称
     * @return
     */
    String name() default "";

    /***
     * 每s能够允许访问的次数为 20
     * 令牌桶进行限流
     * @return
     */
    double token() default 20;
}

//AOP 拦截
@Aspect
@Component
public class CurrentLimitAop {
    /***
     * 每秒生成1个令牌
     */
    private ConcurrentHashMap<String, RateLimiter> rateLimiters=new ConcurrentHashMap<>();

    @Around(value = "@annotation(top.beau.annotation.CurrentLimit)")
    public Object around(ProceedingJoinPoint joinPoint){
        //走环绕通知
        try{
            //获取拦截的方法名
            Signature sig = joinPoint.getSignature();
            MethodSignature methodSignature = (MethodSignature) sig;
            CurrentLimit anno = methodSignature.getMethod().getDeclaredAnnotation(CurrentLimit.class);
            //获取该注解的 参数（name和token）
            String name = anno.name();
            double token = anno.token();
            //判断该名称是否创建rateLimiter
            RateLimiter rateLimiter = rateLimiters.get(name);
            if(rateLimiter==null){
                //每s可以访问 token次
                rateLimiter = RateLimiter.create(token);
                rateLimiters.put(name,rateLimiter);
            }

            //判断是否被限流
            boolean res = rateLimiter.tryAcquire();
            if(!res){
                return "当前访问人数过多，请稍后重试";
            }
            //执行目标方法 进行访问
            Object proceed = joinPoint.proceed();
            return proceed;
        }catch (Throwable throwable){
            return "系统错误";
        }
    }

}

@RestController
public class VisitController {
    private String userName;
    @GetMapping("/get")
    //限制每s访问1次
    @CurrentLimit(name = "get",token = 1)
    public String get(){
        return "my is get";
    }
}

);
return proceed;
}catch (Throwable throwable){
return “系统错误”;
}
}

}


```java
@RestController
public class VisitController {
    private String userName;
    @GetMapping("/get")
    //限制每s访问1次
    @CurrentLimit(name = "get",token = 1)
    public String get(){
        return "my is get";
    }
}