SpringBoot Bean花式注解方法示例下篇

目录
  • 1.容器初始化完成后注入bean
  • 2.导入源的编程式处理
  • 3.bean裁定
    • 拓展
  • 4.最终裁定

1.容器初始化完成后注入bean

import lombok.Data;
import org.springframework.stereotype.Component;
@Component("miao")
@Data
public class Cat {
}

被注入的JavaBean

import org.springframework.context.annotation.Configuration;
@Configuration
public class Config5 {
}

被加载的配置类

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import yi.beans.Cat;
import yi.config.Config5;
public class App2 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(Config5.class);
        context.registerBean(Cat.class);
        String[] names = context.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
    }
}

在加载配置类的时候,普通的ApplicationContext不具备该功能。

可以看到其还具有扫描JavaBean注解的功能,直接把名字装配了,没有自定义名字的话就是类名首字母小写。

那么同一个实体类被加载多次会怎么样呢?

import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;
@Component("miao")
@Data
@NoArgsConstructor
public class Cat {
    String shout;
    public Cat(String shout) {
        this.shout = shout;
    }
}
import org.springframework.context.annotation.Configuration;
@Configuration
public class Config5 {
}
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import yi.beans.Cat;
import yi.config.Config5;
public class App2 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(Config5.class);
        context.registerBean(Cat.class,"1");
        context.registerBean(Cat.class,"2");
        context.registerBean(Cat.class,"3");
        Cat miao = context.getBean("miao",Cat.class);
        System.out.println(miao.getShout());
    }
}

可以看到如果被加载多次的话,后面会覆盖前面的。

这个和我们在配置yml文件属性时有异曲同工之妙,配置了就是你的配置,没有配置就是默认的,你的配置会覆盖默认的配置,其中那些配置背后就是一个一个的bean对象罢了。

2.导入源的编程式处理

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;
@Component("miao")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Cat {
    String shout;
}
import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;
public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{"yi.beans.Cat"};
    }
}
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import yi.beans.MyImportSelector;
@Configuration
@Import(MyImportSelector.class)
public class Config5 {
}
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import yi.config.Config5;
public class App2 {
    public static void main(String[] args) {
        ApplicationContext context=new AnnotationConfigApplicationContext(Config5.class);
        String[] names = context.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
    }
}

可以看到注册了bean,并且还识别到了注解的value值。

不过这种方式还仅不于此,还可以做很多判定。

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;
public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        boolean b = annotationMetadata.hasAnnotation("org.springframework.context.annotation.Configuration");
        if (b){     //判断是否包含这个注解
            return new String[]{"yi.beans.Cat"};
        }else {
            return new String[]{"yi.beans.Dog"};
        }
    }
}
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import yi.beans.MyImportSelector;
//@Configuration
@Import(MyImportSelector.class)
public class Config5 {
}
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import yi.beans.Cat;
import yi.config.Config5;
public class App2 {
    public static void main(String[] args) {
        ApplicationContext context=new AnnotationConfigApplicationContext(Config5.class);
        String[] names = context.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
    }
}

可以看到,我们通过API可以达到多种多样的效果,不仅有查看注解是否存在啊,还能获取注解的所有参数等等。

@Configuration注解如果不被@ComponentScan扫描的话,直接被容器加载。是可以省略的,所以后面我是用@Import也是可以的。

3.bean裁定

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;
@Component("miao")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Cat {
    String shout;
}

实体类我通过注解给它的bean赋了名字。

import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        BeanDefinition beanDefinition= BeanDefinitionBuilder.rootBeanDefinition(Cat.class).getBeanDefinition();
        registry.registerBeanDefinition("mao",beanDefinition);
    }
}

AnnotationMetadata这个属性我忽略了,因为这就是上一个定义bean的方式,可以通过元数据对其条件判断,你可以结合到一块。下面是定义了bean的名字,不过还有许多ApI你可以慢慢看有空的时候。

import org.springframework.context.annotation.Import;
import yi.beans.MyImportBeanDefinitionRegistrar;
@Import(MyImportBeanDefinitionRegistrar.class)
public class Config5 {
}
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import yi.config.Config5;
public class App2 {
    public static void main(String[] args) {
        ApplicationContext context=new AnnotationConfigApplicationContext(Config5.class);
        String[] names = context.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
    }
}

可以看到这里注解的value值被覆盖了,在之前的方法中,一直都获取的是注解的value值为bean的名字,由此说明,这种方式的权限也开放了不少。

拓展

那么如果我使用这种方式加载同一个bean加载了多次,是哪个生效呢?我来用接口模拟。可以发现是最后一个被加载的在生效。可能有人会疑问,为什么bean名字一样,编译时不报异常呢?

因为一个项目是分布式的情况下,一个配置bean可能会被多个人修改,需要确保这些bean能够覆盖达到刷新的效果,我猜的,不一定对。

public interface BookService {
    void check();
}
import yi.beans.BookService;
public class BookServiceImpl1 implements BookService {
    @Override
    public void check() {
        System.out.println("书籍是人类进步的阶梯");
    }
}
import yi.beans.BookService;
public class BookServiceImpl2 implements BookService {
    @Override
    public void check() {
        System.out.println("书籍是人类进步的阶梯");
    }
}
import yi.beans.BookService;
public class BookServiceImpl3 implements BookService {
    @Override
    public void check() {
        System.out.println("书籍是人类进步的阶梯");
    }
}
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;
import yi.beans.impl.BookServiceImpl1;
public class MyImportBeanDefinitionRegistrar1 implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        BeanDefinition beanDefinition= BeanDefinitionBuilder.rootBeanDefinition(BookServiceImpl1.class).getBeanDefinition();
        registry.registerBeanDefinition("bookService",beanDefinition);
    }
}
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;
import yi.beans.impl.BookServiceImpl2;
public class MyImportBeanDefinitionRegistrar2 implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        BeanDefinition beanDefinition= BeanDefinitionBuilder.rootBeanDefinition(BookServiceImpl2.class).getBeanDefinition();
        registry.registerBeanDefinition("bookService",beanDefinition);
    }
}
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;
import yi.beans.impl.BookServiceImpl3;
public class MyImportBeanDefinitionRegistrar3 implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        BeanDefinition beanDefinition= BeanDefinitionBuilder.rootBeanDefinition(BookServiceImpl3.class).getBeanDefinition();
        registry.registerBeanDefinition("bookService",beanDefinition);
    }
}
import org.springframework.context.annotation.Import;
import yi.beans.*;
@Import({MyImportBeanDefinitionRegistrar1.class, MyImportBeanDefinitionRegistrar2.class, MyImportBeanDefinitionRegistrar3.class})
public class Config5 {
}
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import yi.beans.BookService;
import yi.config.Config5;
public class App2 {
    public static void main(String[] args) {
        ApplicationContext context=new AnnotationConfigApplicationContext(Config5.class);
        String[] names = context.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
        BookService bookService = context.getBean("bookService", BookService.class);
        System.out.println(bookService.getClass());
    }
}

4.最终裁定

基于第七种方式,我们要是就是想要加载某个bean,又不想被其他人的覆盖该怎么办呢?也就是说我们这个类无论加载到哪个位置,都不会被覆盖。请看第八种方式。

在第七种拓展的基础上,我们再加如下:

import yi.beans.BookService;
public class BookServiceImpl4 implements BookService {
    @Override
    public void check() {
        System.out.println("书籍是人类进步的阶梯");
    }
}

再加一个实现类。

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import yi.beans.impl.BookServiceImpl4;
public class MyPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(BookServiceImpl4.class).getBeanDefinition();
        beanDefinitionRegistry.registerBeanDefinition("bookService",beanDefinition);
    }
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
    }
}

通过BeanDefinition的注册器实名bean,实现对bean的最终裁定。

import org.springframework.context.annotation.Import;
import yi.beans.*;
@Import({MyImportBeanDefinitionRegistrar1.class, MyImportBeanDefinitionRegistrar2.class, MyPostProcessor.class, MyImportBeanDefinitionRegistrar3.class,})
public class Config5 {
}

可以看到,我将该类没有放到最后。

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import yi.beans.BookService;
import yi.config.Config5;
public class App2 {
    public static void main(String[] args) {
        ApplicationContext context=new AnnotationConfigApplicationContext(Config5.class);
        String[] names = context.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
        BookService bookService = context.getBean("bookService", BookService.class);
        System.out.println(bookService.getClass());
    }
}

该类注册的bean没有被覆盖耶。权限是不是更开放了。bean的加载就到此为止。了解这些,springboot的源码你读起来就不会那么费劲了。

到此这篇关于SpringBoot Bean花式注解方法示例下篇的文章就介绍到这了,更多相关SpringBoot Bean注解方法内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • SpringBoot Bean花式注解方法示例上篇

    目录 1.XML方式声明 2.注解法@Component 3.完全注解式 4.简化注解@Import 1.XML方式声明 这里我举两个例子,一个是自定义的bean,另一个是第三方bean,这样会全面一些. 你还可以定义这个bean的模式,有单例模式和多例模式,prototype代表多例,singleton代表单例. <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://ww

  • Spring Boot在Web应用中基于JdbcRealm安全验证过程

    目录 正文 01-RBAC 基于角色的访问控制 02-Shiro 中基于 JdbcRealm 实现用户认证.授权 03-集成到 Spring Boot Web 应用中 04-总结 正文 在安全领域,Subject 用来指代与系统交互的实体,可以是用户.第三方应用等,它是安全认证框架(例如 Shiro)验证的主题. Principal 是 Subject 具有的属性,例如用户名.身份证号.电话号码.邮箱等任何安全验证过程中关心的要素. Primary principal 指能够唯一区分 Subje

  • Spring Boot Shiro在Web应用中的作用详解

    目录 01-Tomcat 中的 Filter 责任链 02-Shiro 中的 filter 链结构 03-shiro-filters 如何与 servlet 中的 filter 关联起来 04-总结 01-Tomcat 中的 Filter 责任链 在前面的文章中,我介绍了如何使用 Apache Shiro 进行安全认证. 其实 Shiro 在 Web 应用中出现的频率更高. 今天我将来分析下,Shiro 是如何应用到 Web 应用中的. Servlet 规范中定义了 Filter 和 Filte

  • Spring Boot Shiro auto-configure工作流程详解

    目录 01-Shiro 自动配置原理 02-自动配置类 03-Filter 相关的配置类 04-总结 01-Shiro 自动配置原理 Shiro 与 Spring Boot 集成可以通过 shiro-spring-boot-stater 实现,并能完成必要类自动装配. 实现方式是通过 Spring Boot 的自动配置机制,即 WEB-INF/spring.factories 中通过 EnableAutoConfiguration 指定了 6 个自动化配置类: org.springframewo

  • Springboot整合ActiveMQ实现消息队列的过程浅析

    目录 pom中导入坐标 书写yml配置 业务层代码 监听器代码 业务层代码 确保你启动了自己电脑的activemq. pom中导入坐标 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-activemq</artifactId> </dependency> 书写yml配置 spring:  activemq:

  • SpringBoot Bean花式注解方法示例下篇

    目录 1.容器初始化完成后注入bean 2.导入源的编程式处理 3.bean裁定 拓展 4.最终裁定 1.容器初始化完成后注入bean import lombok.Data; import org.springframework.stereotype.Component; @Component("miao") @Data public class Cat { } 被注入的JavaBean import org.springframework.context.annotation.Con

  • SpringBoot集成SpringMVC的方法示例

    Spring MVC是一款优秀的.基于MVC思想的应用框架,它是Spring的一个子框架.是当前最优秀的MVC框架. Spring Boot整合Spring MVC只需在pom.xml中引入 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>2.3.7.RE

  • SpringBoot整合Swagger的方法示例

    依赖 <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>2.7.0</version> </dependency> <dependency> <groupId>io.springfox</groupId> <artifactI

  • SpringBoot 集成 Memcached的方法示例

    Memcached 介绍 Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的速度.Memcached基于一个存储键/值对的hashmap.其守护进程(daemon )是用C写的,但是客户端可以用任何语言来编写,并通过memcached协议与守护进程通信. 因为 Spring Boot 没有针对 Memcached 提供对应的组建包,因此需要我们自己来集成.官方推出的 Ja

  • springboot集成@DS注解实现数据源切换的方法示例

    目录 启用@DS实现数据源切换 POM内添加核心jar包 yml配置 “核心”-使用@DS注解 最后 启用@DS实现数据源切换 POM内添加核心jar包         <dependency>             <groupId>com.baomidou</groupId>             <artifactId>dynamic-datasource-spring-boot-starter</artifactId>        

  • SpringBoot使用自定义注解实现权限拦截的示例

    本文介绍了SpringBoot使用自定义注解实现权限拦截的示例,分享给大家,具体如下: HandlerInterceptor(处理器拦截器) 常见使用场景 日志记录: 记录请求信息的日志, 以便进行信息监控, 信息统计, 计算PV(page View)等 性能监控: 权限检查: 通用行为: 使用自定义注解实现权限拦截 首先HandlerInterceptor了解 在HandlerInterceptor中有三个方法: public interface HandlerInterceptor { //

  • SpringBoot外部化配置使用Plus版的方法示例

    PS: 之前写过一篇关于 SpringBoo 中使用配置文件的一些姿势,不过嘛,有句话(我)说的好:曾见小桥流水,未睹观音坐莲!所以再写一篇增强版,以便记录. 序言 上一篇博客记录,主要集中在具体的配置内容,也就是使用 @ConfigurationProperties 这个注解来进行配置与结构化对象的绑定,虽然也顺带说了下 @Value 的使用以及其区别. 在这篇记录中,打算从总览,鸟瞰的俯视视角,来从整体上对 SpringBoot ,乃至 Spring Framework 对于外部化配置文件处

  • SpringBoot中整合MyBatis-Plus的方法示例

    MyBatis 框架相信大家都用过,虽然 MyBatis 可以直接在 xml 中通过 SQL 语句操作数据库,很是灵活.但正其操作都要通过 SQL 语句进行,就必须写大量的 xml 文件,很是麻烦.于是 MyBatis-Plus 应运而生,作为 MyBatis 的增强工具,更是为我们开发效率得到了质的飞跃. 一.简介 1.MyBatis MyBatis 是一款优秀的持久层框架,它支持自定义 SQL.存储过程以及高级映射.MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工

  • springboot返回html和jsp的方法示例

    一.返回html (1)添加maven依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency> (2)thymeleaf模板默认寻找resources下,templates文件夹放html页面,static文件夹放css及js (3)引入

  • 在SpringBoot项目中的使用Swagger的方法示例

    一. 首先Swagger是什么? Swagger 是一个规范和完整的框架,用于生成.描述.调用和可视化 RESTful 风格的 Web 服务.总体目标是使客户端和文件系统作为服务器以同样的速度来更新.文件的方法,参数和模型紧密集成到服务器端的代码,允许API来始终保持同步.Swagger官方API文档:https://swagger.io/ 作用:   1. 接口的文档在线自动生成.   2. 功能测试. Swagger的主见介绍:    Swagger Codegen: 通过Codegen 可

随机推荐