二、底层注解

最新推荐文章于 2024-11-14 21:50:35 发布
最新推荐文章于 2024-11-14 21:50:35 发布
阅读量161 收藏
点赞数
分类专栏： spring-boot 2 文章标签： spring boot java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/J3332679908/article/details/120600025
版权
本文详细解读了Spring Boot中的关键注解如@Configuration、@Bean、@Conditional和@ConfigurationProperties，以及不同模式的使用示例。了解如何利用这些注解进行组件导入、条件依赖和配置绑定，提升应用配置管理效率。
摘要由CSDN通过智能技术生成

二、底层注解

目录

2.1 容器功能

2.1.1. @Configuration

2.2.1.1. 基本使用

User.java

package cn.com.springboot.demo.bean;

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;

/**
 * 用户信息.
 *
 * @author J
 */
@Setter
@Getter
@ToString
@NoArgsConstructor
public class User {

    /** 姓名 */
    private String name;

    /** 年龄 */
    private String age;

    public User(String name, String age) {
        this.name = name;
        this.age = age;
    }
}

Pet.java

package cn.com.springboot.demo.bean;

import lombok.*;

/**
 * 宠物信息.
 *
 * @author J
 */
@Setter
@Getter
@ToString
@NoArgsConstructor
public class Pet {

    /**
     * 品种
     */
    private String breed;

    /**
     * 昵称
     */
    private String petName;

    public Pet(String breed, String petName) {
        this.breed = breed;
        this.petName = petName;
    }
}

MyConfig01.java

package cn.com.springboot.demo.config;

import cn.com.springboot.demo.bean.Pet;
import cn.com.springboot.demo.bean.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 第一个配置类示例。
 *
 * @author J
 */
@Configuration
public class MyConfig01 {

    /**
     * 声明一个 ID 为 user01 的组件。
     */
    @Bean
    public User user01() {
        return new User("张三", "27");
    }

    /**
     * 声明一个 ID 为 myPet 的组件。
     */
    @Bean("myPet")
    public Pet pet01() {
        return new Pet("cat", "27");
    }
}
  • @Configuration：告诉 spring-boot 这是一个配置类，也就是配置文件
  • @Bean：将该方法注册为一个组件，添加到容器中
  • 组件 ID：方法名就是这个组件的组件 ID
  • 返回值：组件在容器中实例
  • @Bean(“myPet”)：定义 ID 为 myPet 的组件
  • 配置类本身也是一个组件
  • 注册的组件，默认是单实例的

MainApp.java

package cn.com.springboot.demo;

import cn.com.springboot.demo.bean.Pet;
import cn.com.springboot.demo.bean.User;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class MainApp {

    public static void main(String[] args) {

        ConfigurableApplicationContext run = SpringApplication.run(MainApp.class, args);

        User user01 = run.getBean("user01", User.class);
        Pet myPet = run.getBean("myPet", Pet.class);

        System.out.println(user01);
        System.out.println(myPet);
    }
}

运行结果

User(name=张三, age=27)
Pet(breed=cat, petName=27)
2.2.1.2. 全模式（Full Mode）和轻量级模式（Lite Mode）

@Configuration 注解在 spring-boot 2 中多了以下的属性：

...
boolean proxyBeanMethods() default true;
...

默认值是 true 。如果 @Configuration(proxyBeanMethods = true) ，那么则是使用代理对象调用方法。spring-boot 总会检查这个组件是否存在容器中，如果存在则返回该组件，以此保证组件的单实例。如果 @Configuration(proxyBeanMethods = false)，则会跳过上述检查，每次在调用组件时，都会返回新的组件。

  • Full Mode： proxyBeanMethods = true
    • 配置的组件如果有依赖关系，方法调用单实例组件
  • Lite Mode：proxyBeanMethods = false
    • 配置的组件如果没有依赖关系，跳过检查过程，加速容器启动

示例代码

proxyBeanMethods = true 的情况：

MyConfig01.java

package cn.com.springboot.demo.config;

import cn.com.springboot.demo.bean.Pet;
import cn.com.springboot.demo.bean.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 第一个配置类示例。
 *
 * @author J
 */
@Configuration(proxyBeanMethods = true)
public class MyConfig01 {

    /**
     * 声明一个 ID 为 user01 的组件。
     */
    @Bean
    public User user01() {
        return new User("张三", "27");
    }

    /**
     * 声明一个 ID 为 myPet 的组件。
     */
    @Bean("myPet")
    public Pet pet01() {
        return new Pet("cat", "27");
    }
}

MainApp.java

package cn.com.springboot.demo;

import cn.com.springboot.demo.bean.User;
import cn.com.springboot.demo.config.MyConfig01;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class MainApp {

    public static void main(String[] args) {

        ConfigurableApplicationContext run = SpringApplication.run(MainApp.class, args);

        // 测试 MyConfig01 的 Full Mode 和 Lite Mode
        MyConfig01 bean = run.getBean(MyConfig01.class);
        User user01 = bean.user01();
        User user02 = bean.user01();
        System.out.println("Full Mode：" + (user01 == user02));
    }
}

运行结果

Full Mode：true

proxyBeanMethods = false 的情况：

MyConfig01.java

package cn.com.springboot.demo.config;

import cn.com.springboot.demo.bean.Pet;
import cn.com.springboot.demo.bean.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 第一个配置类示例。
 *
 * @author J
 */
@Configuration(proxyBeanMethods = false)
public class MyConfig01 {

    /**
     * 声明一个 ID 为 user01 的组件。
     */
    @Bean
    public User user01() {
        return new User("张三", "27");
    }

    /**
     * 声明一个 ID 为 myPet 的组件。
     */
    @Bean("myPet")
    public Pet pet01() {
        return new Pet("cat", "27");
    }
}

MainApp.java

package cn.com.springboot.demo;

import cn.com.springboot.demo.bean.User;
import cn.com.springboot.demo.config.MyConfig01;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class MainApp {

    public static void main(String[] args) {

        ConfigurableApplicationContext run = SpringApplication.run(MainApp.class, args);

        // 测试 MyConfig01 的 Full Mode 和 Lite Mode
        MyConfig01 bean = run.getBean(MyConfig01.class);
        User user01 = bean.user01();
        User user02 = bean.user01();
//        System.out.println("Full Mode：" + (user01 == user02));
        System.out.println("Lite Mode：" + (user01 == user02));
    }
}

运行结果

Lite Mode：false
2.2.1.3. 其他同类型注解

以前用于注册组件的注解也是可以使用的，如：

@Component          // 泛指组件，将该组件交给 Spring 管理
@Controller         // 作用于 controller 上，将该组件交给 Spring 管理
@Service            // 作用于逻辑实现类上，将该实现类交给 Spring 管理
@Repository         // 作用于持久层的接口上，将该接口的实现类交给 Spring 管理
@ComponentScan      // 定义包扫描规则

2.1.2. @Import

2.2.1.1. 基本使用

通过调用指定类的无参构造，将指定类型的组件导入到容器中，可以使用数组传递多个。如：

示例

MyConfig01.java

package cn.com.springboot.demo.config;

/**
 * 第二个配置类示例。
 *
 * 演示 @Import
 * @author J
 */

import ch.qos.logback.core.db.DBHelper;
import cn.com.springboot.demo.bean.User;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Import({User.class, DBHelper.class})
@Configuration
public class MyConfig02 {}

MainApp.java

package cn.com.springboot.demo;

import ch.qos.logback.core.db.DBHelper;
import cn.com.springboot.demo.bean.User;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

import java.util.Arrays;

@SpringBootApplication
public class MainApp {

    public static void main(String[] args) {

        ConfigurableApplicationContext run = SpringApplication.run(MainApp.class, args);

        // 测试 MyConfig01 的 Full Mode 和 Lite Mode
//        MyConfig01 bean = run.getBean(MyConfig01.class);
//        User user01 = bean.user01();
//        User user02 = bean.user01();
//        System.out.println("Full Mode：" + (user01 == user02));
//        System.out.println("Lite Mode：" + (user01 == user02));
//        System.out.println("---------------------------------------");

        String[] beans = run.getBeanNamesForType(User.class);
        Arrays.asList(beans).forEach(System.out::println);

        String[] beans2 = run.getBeanNamesForType(DBHelper.class);
        Arrays.asList(beans2).forEach(System.out::println);
    }
}

运行结果

cn.com.springboot.demo.bean.User
ch.qos.logback.core.db.DBHelper
  • @Import 导入组件的默认名字：全类名
    • 例：ch.qos.logback.core.db.DBHelper

2.1.3. @Conditional

满足一定的条件时，才向容器中注入组件。@Conditional 存在很多派生注解，如：

派生注解名说明
ConditionalOnWebApplication当前项目是Web项目
ConditionalOnJava基于 Java 版本
ConditionalOnJndi基于 JNDI 存在
ConditionalOnWarDeployment当应用程序为传统 WAR 部署
ConditionalOnSingleCandidate当指定 Bean 在容器中只有一个，或者虽然有多个但是指定首选Bean
ConditionalOnProperty指定的属性是否有指定的值
Profile指定的 Profile 被激活
ConditionalOnMissingBean当容器里没有指定 Bean
ConditionalOnCloudPlatform当指定的云平台处于活动状态
ConditionalOnClass当类路径下有指定类
ConditionalOnMissingClass当类路径下没有指定类
ConditionalOnResource类路径是否有指定的值
ConditionalOnRepositoryType已启用的特定类型的 Spring 数据仓库
ConditionalOnNotWebApplication当前项目不是Web项目
ConditionalOnBean当容器里有指定 Bean
ConditionalOnDefaultWebSecurityWeb Security 可用并且用户没有自定义配置
ConditionalOnEnabledResourceChain检查Spring资源处理链是否启用。匹配WebProperties.Resources.Chain.getEnabled()是否为真，或者webjar -locator-core是否在类路径上
ConditionalOnExpression基于 SpEL 表达式

示例（ConditionalOnBean，当存在 pet03 时，才向容器中添加 user01）

MyConfig03.java

package cn.com.springboot.demo.config;

import cn.com.springboot.demo.bean.Pet;
import cn.com.springboot.demo.bean.User;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 第三个配置类示例。
 *
 * 演示 @Conditional
 * @author J
 */
@Configuration
public class MyConfig03 {

    /**
     * 声明一个 ID 为 user03 的组件。
     * 当存在 pet03 时，才向容器中添加 user01
     */
    @ConditionalOnBean(name = "pet01")
    @Bean
    public User user03() {
        return new User("张三", "27");
    }

    /**
     * 声明一个 ID 为 pet 的组件。
     */
    @Bean("pet")
    public Pet pet03() {
        return new Pet("cat", "coco");
    }
}

MainApp.java

package cn.com.springboot.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class MainApp {

    public static void main(String[] args) {

        ConfigurableApplicationContext run = SpringApplication.run(MainApp.class, args);

        // 测试 MyConfig03 的 @ConditionalOnBean
        System.out.println(run.containsBean("user03"));
    }
}

运行结果

false
  • @ConditionalOnBean(name = “pet01”) 可以加在方法上也可以加在类上
    • 方法上：当条件不满足时，只有当前方法不会注册
    • 类上：当条件不满足时，整个类中的组件都不会注册

2.1.4. @ImportResource

导入原生的配置文件。如果之前就存在使用 XML 配置组件的方式或者第三方使用 XML 配置的组件方式，需要向项目中导入此类配置时使用。如：

示例

beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user04" class="cn.com.springboot.demo.bean.User">
        <property name="name" value="张三" />
        <property name="age" value="21" />
    </bean>

    <bean id="pet04" class="cn.com.springboot.demo.bean.Pet">
        <property name="breed" value="cat" />
        <property name="petName" value="colina" />
    </bean>
</beans>

Myconfig04.java

package cn.com.springboot.demo.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;

/**
 * 第四个配置类示例。
 *
 * 演示 @ImportResource
 * @author J
 */
@Configuration
@ImportResource("classpath:beans.xml")
public class MyConfig04 {}

MainApp.java

package cn.com.springboot.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class MainApp {

    public static void main(String[] args) {

        ConfigurableApplicationContext run = SpringApplication.run(MainApp.class, args);
        
        // 测试 MyConfig04 的 @ImportResources
        System.out.println(run.containsBean("user04"));
        System.out.println(run.containsBean("pet04"));
    }
}

运行结果

true
true

2.1.5. @ConfigurationProperties

配置绑定。在开发中一般将一些变化的东西写在 properties 文件中。如，DB连接信息等。

2.1.5.1. @Component + @ConfigurationProperties

示例

Car.java

package cn.com.springboot.demo.bean;

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * 车辆信息.
 *
 * @author J
 */
@Setter
@Getter
@ToString
@NoArgsConstructor
@Component
@ConfigurationProperties("car01")
public class Car {

    /** 牌子 */
    private String brand;

    /** 价格 */
    private String price;

    public Car(String brand, String price) {
        this.brand = brand;
        this.price = price;
    }
}

application.properties

car01.brand=BMW
car01.price=1200000

CarController.java

package cn.com.springboot.demo.controller;

import cn.com.springboot.demo.bean.Car;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CarController {

    @Autowired
    private Car car;

    @RequestMapping("/car")
    public Car myCar() {
        return car;
    }
}

运行结果

在这里插入图片描述

  • @Component：将 Car 注册为一个组件，才能拥有 spring-boot 提供的功能
  • @ConfigurationProperties：指定配置文件的前缀
2.1.5.1. @ConfigurationProperties

示例

Car.java

package cn.com.springboot.demo.bean;

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * 车辆信息.
 *
 * @author J
 */
@Setter
@Getter
@ToString
@NoArgsConstructor
// @Component
@ConfigurationProperties("car02")
public class Car {

    /** 牌子 */
    private String brand;

    /** 价格 */
    private String price;

    public Car(String brand, String price) {
        this.brand = brand;
        this.price = price;
    }
}

application.properties

car02.brand=LEXUS
car02.price=1800000

CarController.java

package cn.com.springboot.demo.controller;

import cn.com.springboot.demo.bean.Car;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CarController {

    @Autowired
    private Car car;

    @RequestMapping("/car")
    public Car myCar() {
        return car;
    }
}

MyConfig05.java

package cn.com.springboot.demo.config;

import cn.com.springboot.demo.bean.Car;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Configuration;

/**
 * 第五个配置类示例。
 *
 * 演示 @EnableConfigurationProperties
 * @author J
 */
@Configuration
@EnableConfigurationProperties(Car.class)
public class MyConfig05 {}

运行结果

在这里插入图片描述

  • @ConfigurationProperties：指定配置文件的前缀
  • @EnableConfigurationProperties(${value})：
    • 开启指定 ${value} 的配置绑定功能
    • 将 ${value} 组件注册到容器中
    • 必须写在配置类上
Spring配置类之full和lite模式
诗人不写诗
06-13 4773
本文基于Spring 5.2.7 Spring配置类不仅仅是@Configuration注解修饰的类，只是@Configuration修饰的类更加正式，Spring对此也是进行了区分处理，Spring将配置类划分为了full模式和lite模式。lite模式包含：full模式包含：full模式使用特性：lite模式使用特性：lite测试用例 full测试用例 因为被Spring管理的类功能比较多，有一些是业务类，这些类解析起来比较简单和有规律，可归纳为lite模式一类，有一些类需要额外一
springboot中@bean的lite模式
m0_37811464的博客
09-19 1209
@Configuration&amp;amp;amp;@Bean @Bean可以出现在@Configurationor@Component，其中@Configuration类似于xml中的,而@Component类似于xml中的,@Component可以作为@Configuration的替代。 但是有一些问题：当我们使用@Bean注解在例如@Component作用的class里面时，将会发生一种称之为注解@Bea...
注解底层实现原理
Java持续实践
02-21 1442
文章目录注解获取属性值的底层实现注解的工作原理 注解获取属性值的底层实现 JVM会为注解生成代理对象. 这一节的文章中提到的获取注解信息的代码 https://javaweixin6.blog.csdn.net/article/details/113914653 注意注解的生命周期都要设置为runtime 程序运行时, 设置如下的jvm参数, 保存生成的代理对象成为文件 -Djdk.proxy.ProxyGenerator.saveGeneratedFiles=true 只获取成员属性的值. 运行上
【SpringBoot】| Spring Boot 常见的底层注解剖析
m0_61933976的博客
07-17 5248
【SpringBoot】| Spring Boot 常见的底层注解剖析
java注解的底层实现
qq_35939148的博客
06-02 750
原文链接:https://blog.csdn.net/feicongcong/article/details/78242358 总结：Java的annotation没有行为，只能有数据。让其实现某些行为必须有实例（代理对象），再用反射技术执行某些行为 https://www.zhihu.com/question/24401191 注解是什么，其实注解本质是一个接口interface 从反编...
SpringBoot条件注解底层原理
BaseLike的博客
11-04 478
springBoot条件注解
注解底层实现
十年饮冰，难凉热血
08-10 1467
package pannotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target(value={E
一文读懂注解的底层原理
riemann_的博客
03-24 2090
欢迎大家关注我的微信公众号【老周聊架构】，Java后端主流技术栈的原理、源码分析、架构以及各种互联网高并发、高性能、高可用的解决方案。 一、前言 上一篇我们说了注解、元注解以及自定义注解，请戳：一文读懂Annotation 注解的声明如下： {InterfaceModifier} @interface Identifier AnnotationTypeBody 接口修饰符 @interface 注解标识符 注解类型的内容 其中： 注解类型声明中的标识符指定了注解类型的名称。 如果注解类型与它的任何.
AOP底层原理与注解配置详解
itzhuzhu的博客
12-29 1419
基于XML格式使用注解格配置AOP
JavaSE-注解与反射(框架底层实现机制)
12-21
JavaSE中的注解（Annotation）和反射（Reflection）是两...总的来说，注解和反射是Java开发中两个强大的工具，它们提供了代码的元数据和运行时的动态性，对于理解和实现复杂系统，尤其是框架底层机制的理解，至关重要。
SpringBoot2的最佳实践 SpringBoot2基础入门+底层注解+自动配置+高级特性与原理解析
06-23
课程内容以时下最新的技术点为主线，逐步的进行展开，分别细化的讲解了SpringBoot2基础课程，SpringBoot2底层注解，SpringBoot2自动化配置，SpringBoot2请求处理，SpringBoot2高级特性和原理分析，是不可错过的...
第一节课-Spring源码分析之-常见底层核心注解-2 (2)1
08-03
本文将深入探讨Spring框架中的核心注解和核心模块，以便更好地理解和利用这一框架。 首先，Spring框架的核心部分由Core和Beans模块组成，它们是整个框架的基础。Core模块包含Spring框架的基本核心工具类，是其他...
JPA学习笔记（二）——JPA 注解
12-14
AUTO 是默认策略，由JPA根据底层数据库选择合适的策略。例如，SqlServer使用IDENTITY，MySQL使用AUTO_INCREMENT。其他的策略如 SEQUENCE 和 TABLE 可以手动指定生成主键的序列或表。 5. **@Basic** `@Basic` 注解...
spring boot 请求
weixin_42371812的博客
11-14 318
对于http请求，无外乎都是get、post、put、delete。常用的也就那么几个。但刚学java的我还是记下他们的写法吧。虽然在工作中经常会用上，但也给初学的兄弟们更快上手吧。put 和 delete 都是一个意思，这儿我就不写了。获取前端的数据，无非就是把数据拿过来。表单提交就是我们正常 form提交，而截何提交，则是 formdata的提交。其实，在post中，是有两种方式的，一种是表单提交，另一种是截荷提交。在前端的代码大概是如下这样的。
Spring Boot 中的全局异常处理器
最新发布
wenxuankeji的博客
11-14 959
全局异常处理器是一种集中处理应用程序中所有未被捕获异常的机制。在Spring Boot中，可以通过创建一个带有注解的类来实现全局异常处理器。这个注解使得类中的方法能够处理所有控制器（带有或注解的类）抛出的异常。首先，定义一些自定义异常类，以便于区分不同类型的异常。为了提供结构化的错误信息，可以定义一个错误响应类，包含错误码、错误消息等信息。在业务逻辑中，当遇到特定情况时，可以抛出自定义异常。
Spring Boot 应用程序中集成 Redis 并实现存储读取字符串或者复杂对象
wujian_csdn_csdn的博客
11-14 400
【代码】Spring Boot 应用程序中集成 Redis 并实现存储读取字符串或者复杂对象。
Spring Boot中集成Redis与MySQL
m0_73837751的博客
11-14 1601
用途：将键或简单的值序列化为字符串。适用场景：通常用于键的序列化，确保键在 Redis 中以字符串存储，以便于直接查看和管理。用途：将对象序列化为 JSON 格式的字符串，并支持 JSON 反序列化回对象。适用场景：通常用于值的序列化，尤其是需要存储复杂对象的情况。它可以确保数据的可读性，且 JSON 格式数据跨系统兼容性好。缓存穿透指的是请求的数据在缓存和数据库中都不存在，这种请求直接穿过缓存访问数据库。当恶意请求大量涌入时，缓存层无法拦截这些无效请求，导致数据库承受大量压力，从而影响性能。
RabbitMQ的工作队列在Spring Boot中实现（详解常⽤的⼯作模式）
chaodddddd的博客
11-14 2024
介绍RabbitMQ的工作队列在Spring Boot中实现
spring注解底层原理
09-08
Spring注解的底层原理是基于反射和动态代理技术实现的。在使用Spring注解时，需要在业务逻辑类和切面类上注入到容器中，并使用@Aspect注解标识切面类。这样一来，Spring就能够扫描并识别这些注解，并在运行时生成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值