四、Spring 注解

已于 2023-06-27 17:30:23 修改
阅读量1.3k 收藏 1
点赞数
分类专栏： Spring 文章标签： spring java
于 2023-05-25 16:56:29 首次发布
骑士梦
本文链接：https://blog.csdn.net/qq_38667427/article/details/130871043
版权

一、Spring 组件注解

1. @CompentScan 包扫描

/**
 * @author wy
 * describe `@ComponentScan`注解，包扫描。
 */
@Configuration
// 1. 扫描当前类所在包，及其子包下。
//@ComponentScan
// 2. 扫描指定包下。
//@ComponentScan(basePackages = {"com.qs.springannotation.component_scan.controller"})
// 3. 排除、包含。
@ComponentScan(basePackages = {"com.qs.springannotation.component_scan"},
        // 排除（注意：排除优先级高于包含）。
        excludeFilters = {
                // 根据`注解`排除。
                @ComponentScan.Filter(type = FilterType.ANNOTATION, value = {Controller.class}),
                // 根据`类型`排除。
                @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, value = {UserService.class}),
                // 根据`自定义`排除。
                @ComponentScan.Filter(type = FilterType.CUSTOM, value = CustomTypeFilter.class),
        },
        // 包含（注意：`useDefaultFilters=false`表示只扫描包含的）。
        useDefaultFilters = false,
        includeFilters = {
                @ComponentScan.Filter(type = FilterType.ANNOTATION, value = Repository.class)
        })
public class ComponentScanConfig {

    public ComponentScanConfig() {
        System.out.printf("`%s`无参构造", this.getClass().getName()).println();
    }
}
  • TypeFilter 接口
/**
 * @author wy
 * describe `TypeFilter`接口，类型过滤器。
 */
public class CustomTypeFilter implements TypeFilter {

    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        // 获取当前类的`资源信息`。
        Resource resource = metadataReader.getResource();

        // 获取当前类的`Class源信息`。
        ClassMetadata classMetadata = metadataReader.getClassMetadata();

        // 获取当前类的`注解源信息`。
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();

        String className = classMetadata.getClassName();
        System.out.printf("类的路径：%s", className).println();
        return className.contains("dao");
    }
}

public enum FilterType {

	/**
	 * 注解
	 */
	ANNOTATION,

	/**
	 * 类型
	 */
	ASSIGNABLE_TYPE,

	/**
	 * AspectJ
	 */
	ASPECTJ,

	/**
	 * 正则
	 */
	REGEX,

	/**
	 * 自定义
	 */
	CUSTOM

}

2. @Scope 范围

/**
 * `@Scope` 范围
 * 1. `singleton`：单例（默认，饿汉式加载，容器启动实例就创建好了）。
 * 2. `prototype`：多例（懒汉式加载，（IOC容器启动的时候，并不会创建对象，而是在第一次使用的时候才会创建）。
 * 3. `request`：同一次请求。
 * 4. `session`：同一个会话级别。
 */
@Scope(scopeName = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Bean("personPrototype")
public Person personPrototype() {
    return new Person("personPrototype");
}

/**
 * `@Scope` 范围
 */
@Test
public void testScope() {
    System.out.println("------------------------------");
    // 1. 创建容器（传入`配置类`）。
    AnnotationConfigApplicationContext applicationContext =
            new AnnotationConfigApplicationContext(BeanConfig.class);
    System.out.println("------------------------------");
    // 2. 容器中获取`Bean`。
    Object bean = applicationContext.getBean("personPrototype");
    // 3. 打印`Bean`。
    System.out.println(bean);

    // 2. 容器中获取`Bean`。
    Object bean2 = applicationContext.getBean("personPrototype");
    // 3. 打印`Bean`。
    System.out.println(bean2);
    /*
    ------------------------------
    `com.qs.springannotation.beans.Person`有参构造，`name = personPrototype`
    Person{name='personPrototype'}
    `com.qs.springannotation.beans.Person`有参构造，`name = personPrototype`
    Person{name='personPrototype'}
     */
    applicationContext.close();
}

3. @Lazy 懒加载

/**
 * `@Lazy` 懒加载（默认：非懒加载，创建即加载）。
 * 主要针对`单例Bean`，容器启动的时候，不创建对象，在第一次使用的时候才会创建该对象。
 */
@Lazy
@Bean(name = "personLazy")
public Person personLazy() {
    return new Person("personLazy");
}

/**
 * `@Lazy` 懒加载
 */
@Test
public void testLazy() {
    System.out.println("------------------------------");
    // 1. 创建容器（传入`配置类`）。
    AnnotationConfigApplicationContext applicationContext =
            new AnnotationConfigApplicationContext(BeanConfig.class);
    System.out.println("------------------------------");
    // 2. 容器中获取`Bean`。
    Object bean = applicationContext.getBean("personLazy");
    // 3. 打印`Bean`。
    System.out.println(bean);
    /*
    ------------------------------
    ------------------------------
    `com.qs.springannotation.beans.Person`有参构造，`name = personLazy`
    Person{name='personLazy'}
     */
}

4. @Conditional 指定依赖的条件

/**
 * @author wy
 * describe 条件
 */
public class ConditionalConfig {

    @Bean
    public Qs qs() {
        return new Qs(1);
    }

    /**
     * `@Conditional` 指定依赖的条件。
     * 当前容器中必须存在`qs组件`，才会创建`qsHome组件`。
     */
    @Conditional(QsCondition.class)
    @Bean
    public QsHome qsHome(Qs qs) {
        return new QsHome(qs);
    }
}

/**
 * @author wy
 * describe `Condition`接口，条件。
 */
public class QsCondition implements Condition {

    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        // 判断容器中是否存在`qs组件`。
        return conditionContext.getBeanFactory().containsBean("qs");
    }
}

/**
 * `@Conditional` 指定依赖的条件
 */
@Test
public void testConditional() {
    System.out.println("------------------------------");
    // 1. 创建容器（传入`配置类`）。
    AnnotationConfigApplicationContext applicationContext =
            new AnnotationConfigApplicationContext(ConditionalConfig.class);
    System.out.println("------------------------------");
    // 2. 容器中获取`Bean`。
    Qs qs = applicationContext.getBean(Qs.class);
    // 3. 打印`Bean`。
    System.out.println(qs);

    // 2. 容器中获取`Bean`。
    QsHome qsHome = applicationContext.getBean(QsHome.class);
    // 3. 打印`Bean`。
    System.out.println(qsHome);
    /*
    ------------------------------
    `com.qs.springannotation.conditional.Qs`有参构造，`flag = 1`
    `com.qs.springannotation.conditional.QsHome`有参构造，`qs = Qs(flag=1)`
    ------------------------------
    Qs(flag=1)
    QsHome(qs=Qs(flag=1))
     */
}

5. @Import 导入组件

/**
 * @author wy
 * describe `@Import`注解，导入`Bean`。
 * 用于导入第三方组件。
 */
@Configuration
// 1. 导入一个`Bean`。
//@Import({com.qs.springannotation.import_bean.Qs.class})
// 2. 导入多个`Bean`。
//@Import({Qs.class, QsHome.class})
// 3. `ImportSelector`接口，自动装配。
//@Import({QsHome.class, MyImportSelector.class})
// 4. `ImportBeanDefinitionRegistrar`接口，注册`Bean定义`。
@Import({QsHome.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})
public class ImportConfig {
}
  • ImportSelector
/**
 * @author wy
 * describe `ImportSelector`自动装配
 */
public class MyImportSelector implements ImportSelector {

    /**
     * 可以获取导入类的注解信息。
     */
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        // 导入组件的id，为全类名路径。
        return new String[]{"com.qs.springannotation.import_bean.Qs"};
    }
}
  • ImportBeanDefinitionRegistrar 注册 Bean 定义。
/**
 * @author wy
 * describe `ImportBeanDefinitionRegistrar`接口，注册`Bean定义`。
 */
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(QsHome.class);
        // 导入组件，可以指定`Bean名称`。
        beanDefinitionRegistry.registerBeanDefinition("qsHome2", rootBeanDefinition);
    }
}

6. @AutoWired 自动装配

/**
 * @author wy
 * describe `@Autowired`注解，自动装配。
 */
@Data
@Service
public class AutowiredService {

    private int flag = 0;

    /**
     * `@Autowired`注解，自动装配。
     * 自动装配首先时按照`类型装配`，若在`IOC容器`中发现了多个相同类型的组件，那么就按照`属性名称`来进行装配。
     * <p>
     * 比如：容器中有二个`AutowiredDao`类型的组件，`autowiredDao`和`autowiredDao1`。
     * 1. 通过`@AutoWired`来修饰的`autowiredDao`属性名称时，那么就加载容器的`autowiredDao`组件。
     * 2. 若属性名称为`autowiredDao1`时，那么就加载`autowiredDao1`组件。
     */
    @Autowired
    private AutowiredDao autowiredDao;

    @Autowired
    private AutowiredDao autowiredDao1;

    /**
     * 假设容器中即没有`autowiredDao9`，那么在装配的时候就会抛出异常。
     * No qualifying bean of type 'com.qs.springannotation.autowired.dao.AutowiredDao' available:
     * expected single matching bean but found 3: autowiredDao,autowiredDao1,autowiredDao2
     * 若不想抛异常，需要指定`required=false`就可以了。
     */
    @Autowired(required = false)
    @Qualifier(value = "autowiredDao9")
    private AutowiredDao autowiredDao9;
}
6.1 @Autowired 方法注入
/**
 * 标注在`配置类上的入参`中（可以不写）。
 */
@Bean
public AutowiredMethodService autowiredMethodService2(@Autowired AutowiredDao autowiredDao) {
    AutowiredMethodService service = new AutowiredMethodService();
    service.setAutowiredDao(autowiredDao);
    return service;
}

@Data
@Primary
@Service
public class AutowiredMethodService {

    @Autowired
    private AutowiredDao autowiredDao;

    public AutowiredMethodService() {
        System.out.printf("`%s`无参构造", this.getClass().getName()).println();
    }

    /**
     * 标注在`构造方法`上。
     */
    @Autowired
    public AutowiredMethodService(AutowiredDao autowiredDao1) {
        System.out.printf("`%s`有参构造，`autowiredDao = %s`", this.getClass().getName(), autowiredDao).println();
        this.autowiredDao = autowiredDao1;
    }

    public AutowiredDao getAutowiredDao() {
        return autowiredDao;
    }

    /**
     * 标注在`setXX`上。
     */
    @Autowired
    public void setAutowiredDao(AutowiredDao autowiredDao2) {
        System.out.printf("`%s`.setAutowiredDao，`autowiredDao = %s`", this.getClass().getName(), autowiredDao).println();
        this.autowiredDao = autowiredDao2;
    }
}

7. @Qualifier 指定名称装配

/**
 * @author wy
 * describe `@Qualifier`指定名称装配
 */
@Data
@Service
public class QualifierService {

    private int flag = 1;

    /**
     * `@Qualifier`注解，指定名称装配。
     * <p>
     * `@AutoWired`默认使用`BY_NAME`。
     * 当发现多个`同类型的Bean`，就通过`BY_NAME`。
     * 需要通过名称装配，使用`@Qualifier`指定名称装配。
     */
    @Qualifier(value = "autowiredDao1")
    @Autowired
    private AutowiredDao autowiredDao;

    @Qualifier(value = "autowiredDao")
    @Autowired
    private AutowiredDao autowiredDao1;

}

8. @Primary 存在多个按类型装配时标记默认的

/**
 *`@Primary`注解，按类型（`BY_TYPE`）装配时优先。
 */
@Primary
@Bean
public AutowiredDao autowiredDao2() {
    AutowiredDao dao = new AutowiredDao();
    dao.setFlag(2);
    return dao;
}

/**
 * 默认通过类型（`BY_TYPE`），当发现多个`同类型的Bean`，就通过名称（`BY_NAME`）。
 */
@Primary
@Bean(autowire = Autowire.BY_TYPE)
//    @Bean(autowire = Autowire.BY_NAME)
public AutowiredService autowiredService3() {
    AutowiredService service = new AutowiredService();
    service.setFlag(3);
    return service;
}

/**
 * @author wy
 * describe `@Primary`注解，按类型（`BY_TYPE`）装配时优先。
 */
@Data
@Service
public class PrimaryService {

    private int flag = 2;

    /**
     * `@Autowired`失败问题。
     * 1. `Service`使用类型（`BY_TYPE`）注入时，`Dao`会注入`@Primary`修饰的。
     * 2. `Service`使用名称（`BY_NAME`）注入时，`Dao`只能使用名称注入。
     */
    @Autowired
    private AutowiredDao autowiredDao;

    @Qualifier(value = "autowiredDao1")
    @Autowired
    private AutowiredDao autowiredDao1;

    @Autowired
    private AutowiredDao autowiredDao2;
}

10. @Resource JSR250 规范

/**
 * @author wy
 * describe `@Resource`注解，`JSR250`规范。
 * 和`@AutoWired`的功能差不多一样，但是不支持`@Primary`和`@Qualifier`。
 */
@Data
@Service
public class ResourceService {

    @Resource
    private AutowiredDao resourceDao;
}

11. @InJect JSR330 规范

/**
 * @author wy
 * describe `@InJect`注解，`JSR330`规范。
 * 需要导入`jar`包`javax.inject`。
 * 和`@AutoWired`的功能差不多一样，支持`@Primary`和`@Qualifier`，但是没有`require=false`的功能。
 */
@Service
@Data
public class InjectService {

    @Inject
    private AutowiredDao injectDao;
}

二、Spring 配置注解

1. @Profile 环境注入

/**
 * @author wy
 * describe `@Profile`注解，环境注入，根据环境来激活标识不同的Bean。
 * 1. `@Profile`标识在类上，那么只有当前环境匹配，整个配置类才会生效。
 * 2. `@Profile`标识在`Bean`上 ，那么只有当前环境的Bean才会被激活。
 * 3. 没有标志为`@Profile`的`Bean`，不管在什么环境都可以被激活。
 * <p>
 * `EmbeddedValueResolverAware`接口，内嵌式值解析器。
 */
@Configuration
@PropertySource(value = {"classpath:ds.properties"})
public class ProfileConfig implements EmbeddedValueResolverAware {

    private String classDriver;

    private String jdbcUrl;

    @Value("${ds.username}")
    private String userName;

    @Value("${ds.password}")
    private String password;

    @Override
    public void setEmbeddedValueResolver(StringValueResolver stringValueResolver) {
        this.jdbcUrl = stringValueResolver.resolveStringValue("${ds.jdbcUrl}");
        this.classDriver = stringValueResolver.resolveStringValue("${ds.classDriver}");
    }

    /**
     * 标识为测试环境，才会被装配。
     */
    @Bean
    @Profile(value = "test")
    public DataSource testDS() {
        return buildDataSource(new DruidDataSource());
    }

    /**
     * 标识开发环境，才会被激活。
     */
    @Bean
    @Profile(value = "dev")
    public DataSource devDS() {
        return buildDataSource(new DruidDataSource());
    }

    /**
     * 标识生产环境，才会被激活。
     */
    @Bean
    @Profile(value = "prod")
    public DataSource prodDS() {
        return buildDataSource(new DruidDataSource());
    }

    private DataSource buildDataSource(DruidDataSource dataSource) {
        dataSource.setDriverClassName(classDriver);
        dataSource.setUrl(jdbcUrl);
        dataSource.setUsername(userName);
        dataSource.setPassword(password);
        return dataSource;
    }
}

AnnotationConfigApplicationContext applicationContext =
                new AnnotationConfigApplicationContext();
// 设置环境属性（或者JVM参数`-Dspring.profiles.active=test,dev,prod`）
applicationContext
	.getEnvironment()
	.setActiveProfiles("test", "dev");

2. @PropertySource + @Value 组件赋值

  • @PropertySource 导入属性配置文件
/**
 * @author wy
 * describe `@PropertySource`导入属性配置文件。
 */
@Configuration
@PropertySource(value = {"classpath:person.properties"})
public class ValueConfig {

    @Bean
    public Person person() {
        return new Person();
    }
}
  • @Value 注入属性
/**
 * @author wy
 * describe `@Value`注解，注入属性
 */
@Data
public class Person {

    @Value("骑士")
    private String firstName;

    /**
     * `SPEL`表达式。
     */
    @Value("#{28-8}")
    private Integer age;

	/**
     * 读取外部配置文件的值
     */
    @Value("${person.lastName}")
    private String lastName;
}

3. @ConditionalOnExpression 控制是否初始化 Bean

cache.service=redis

@ConditionalOnExpression("'${cache.service:default}'.equals('redis')")
@Service
public class CacheServiceRedisImpl implements CacheService {

    @Override
    public String getName() {
        return this.getClass().getName();
    }

}

@ConditionalOnExpression("'${cache.service:default}'.equals('default')")
@Service
public class CacheServiceDefaultImpl implements CacheService {

    @Override
    public String getName() {
        return this.getClass().getName();
    }

}
骑士梦
关注
专栏目录
Spring系列（五）：@Lazy懒加载注解用法介绍
IT技术分享社区
03-08 3384
今天给大家介绍@Lazy懒加载注解用法，希望对大家能有所帮助！
spring的懒加载和depends-on
Crazy Android
01-07 7166
①延迟初始化Bean(惰性初始化Bean)是指不提前初始化Bean，而是只有在真正使用时才创建及初始化Bean.  配置方式很简单只需在标签上指定 “lazy-init” 属性值为“true”即可延迟初始化Bean。 配置文件： HelloWorld.xml class="cn.javass.spring.chapter2.helloworld.HelloImpl"   lazy-in
java懒加载注解_spring学习之懒加载
weixin_42099116的博客
02-28 274
Lazy正常情况下，bean的加载是容器启动后就开始的，这样如果加载的过程中有错误，可以立马发现。由于一些特定的业务需求，需要某些bean在IoC容器在第一次请求时才创建，可以把这些bean标记为延时加载。XML在XML配置文件中，是通过bean标签的lazy-init属性来控制的，如果控制多个bean都是懒加载，那么可以把bean放入beans标签下面，通过beans标签的default-laz...
spring注解的懒加载 @Lazy
paohui001lqp的博客
07-24 3741
@Lazy注解的概念 用于标识bean是否需要延迟加载 即ioc容器启动的时候 是否会直接加载这个bean 如果添加了@Lazy 则容器启动的时候不创建对象，仅当第一次使用（获取）bean的时候才创建被初始化 源码如下 @Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRU...
Spring（10）：注解实现懒加载
小蚯蚓的博客
10-27 1559
一、懒加载 Spring的懒加载功能，通过spring上下文请求Bean的时候，该bean才被初始化。 二、环境 1.Pom <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spr...
通俗易懂的Spring注解驱动开发教程（含配套资料）
06-14
《Spring注解驱动开发》是一套帮助我们深入了解Spring原理机制的教程。现今SpringBoot.SpringCloud技术非常火热，作为Spring之上的框架，他们大量使用到了Spring的一些底层注解.原理，比如@Conditional.@Import.@...
Spring注解大全_spring应用层_spring注解大全_控制层注解_
09-29
应用在MVC层（控制层）DispatcherServlet会自动扫描注解了此注解的类，然后将web请求映射到注解了RequestMapping的方法上。Service 组合注解（组合了@Component注解），应用在service层（业务逻辑层）
spring注解笔记
10-20
### Spring注解知识点详解 #### 1. Spring注解基础 在Spring框架中，注解是一种轻量级的依赖注入方式，能够简化配置并提高开发效率。在本节中，我们主要介绍几个Spring中常用的注解，它们分别是@Component、@...
关于Spring注解@Async引发其他注解失效的解决
08-27
Spring @Async 注解引发其他注解失效的解决 Spring 框架提供了多种注解来帮助开发者简化代码，例如 @Async 用于异步执行方法、@Transaction 用于事务管理等。但是，在使用这些注解时，可能会遇到一些问题，例如 @...
一文总结Spring 注解及作用详解
12-22
Spring框架的注解是其核心特性之一，极大地简化了配置并增强了代码的可读性。以下是对文中提到的几个关键注解的详细说明： 1. **开启注解扫描配置** 在Spring应用上下文中，使用`@ComponentScan`注解可以开启注解...
Spring：通过注解懒加载及初始化与销毁
Wangjalong的博客
06-05 469
通过注解懒加载： 在Bean上加上@Lazy 在@Configuration下加入@Lazy，则所有Bean都开启懒加载模式 通过注解编写Bean初始化及销毁： 1.将Bean的类实现DisposableBean接口 与 InitializingBean接口 在destroy()方法 //销毁 与afterPropertiesSet()方法//初始化 下进行操作 2.在自己写的销毁或者初始化方法上加上 @PostConstruct //初始化 @PreDestroy //销毁 3.在@Bean中加ini
java懒加载注解_spring注解开发：bean的作用域与懒加载
weixin_35944650的博客
02-28 153
1、bean的作用域1、新建一个maven工程，添加如下依赖org.springframeworkspring-context5.0.5.RELEASE2，新建一个实体Person类packagecom.yefengyu.annotation.bean;public classPerson{privateString name;privateInteger age;publicPerson(){}...
spring提前加载，懒加载，bean的作用域和注入注解讲解
心比天高，仗剑走天涯，保持热爱，奔赴向梦想！
12-23 1577
sping知识随笔笔记；spring提前加载，懒加载，bean的作用域和注入注解讲解。
【Spring注解】3.@Scope作用域&4.@Lazy懒加载
ouYang的博客
10-31 622
微信公众号：程序yuan 关注可了解更多的资源。问题或建议，请公众号留言; 3.@Scope作用域 1.@Scope的源码 @Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Scope {     @Alia...
懒得一起加载：@Lazy注解的秘密
最新发布
todoitbo的博客
10-09 886
@Lazy
@CompentScan 使用详解
pengweismile的专栏
07-06 2077
在配置类上写@ComponentScan，控制哪些包可以被spring ioc扫描。 1，basePackages 配置哪些包下的类可以被扫描到。 @Configuration @ComponentScan(basePackages = {"com.tuling.testcompentscan.controller","com.tuling.testcompentscan.dao"}) ...
Spring注解@Lazy
大树
12-20 3902
Spring注解@Lazy 一、@Lazy注解 1、@Lazy注解作用 lazy 翻译过来是"懒惰的" @Lazy（懒加载）：该注解用于惰性加载初始化标注的类、方法和参数。 在Spring中常用于单实例Bean对象的创建和使用； 单实例Bean懒加载：容器启动后不创建对象，而是在第一次获取Bean创建对象时，初始化。 2、@Lazy 可标注在类、方法、构造方法、参数、字段上 @Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTR
Spring框架之@CompentScan注解使用讲解，超详细
技术分享、唠嗑水文、如有不周、还望海涵
10-02 2444
j3_liuliang 以前学的注解式Spring开发，现在开始复习并写Spring注解系列，如果觉得有用，可以关注后续会持续发表！ 一、@CompentScan 组件注册-@ComponentScan-自动扫描组件&指定扫描规则 1）在xml文件配置的方式，我们可以这样来进行配置： <!-- 包扫描、只要标注了@Controller、@Service、@Repository，@Component --> <context:component-scan base-packa..
在配置类上写@CompentScan注解来进行包扫描
Leon_Jinhai_Sun的博客
09-23 343
@Configuration @ComponentScan(basePackages = {"com.leon.testcompentscan"}) public class MainConfig { }
Spring注解开发详解
4. **Spring注解学习手札（四）持久层浅析**：这里会讲解Spring整合数据库的相关注解，如JPA或Hibernate。 - `@Entity` 定义数据库表对应的实体类。 - `@Table`, `@Id`, `@GeneratedValue` 等用于定义表结构和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

骑士梦

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

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

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

打赏作者

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

抵扣说明：

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

余额充值