01.Spring Framework 之组件注册

最新推荐文章于 2023-11-02 13:14:27 发布
最新推荐文章于 2023-11-02 13:14:27 发布
阅读量2.8k 收藏 5
点赞数
分类专栏： Spring Framework 核心功能 文章标签： spring
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/masteryourself/article/details/96781515
版权

1. Spring 组件注入

Spring 组件注入有 4 种方式

  • 包扫描 + 组件标注注解（@Controller、@Service、@Repository、@Component），配合 @ComponentScan 注解使用，主要用于自己写的类

  • @Bean（导入第三方的组件）

  • @Import：给容器中导入一个组件

    • @Import：向容器中注册组件一个 class，id 默认是全类名

    • ImportSelector：返回需要导入的组件的全类名数组

    • ImportBeanDefinitionRegistrar：手动注册 bean 到容器中

  • FactoryBean（工厂 Bean）

1.1 @ComponentScan

代码已经上传至 https://github.com/masteryourself-tutorial/tutorial-spring ，详见 tutorial-spring-framework/tutorial-spring-framework-register/tutorial-spring-framework-register-componentscan 工程

1.1.1 使用方式

@ComponentScan：指定要扫描的包

  • excludeFilters=ComponentScan.Filter[]，按照规则排除某些组件

  • includeFilters=ComponentScan.Filter[]，按照规则包含某些组件，需要将 useDefaultFilters=false 才会生效

1.1.2 环境搭建
1. SpringConfig
/**
 * <p>description : SpringConfig
 * 第一个 {@link ComponentScan} 排除了 {@link Repository} 和 {@link Controller} 注解，即只扫描了 {@link PersonService}
 * 第二个 {@link ComponentScan} 扫描了 {@link Controller} 注解类型和 {@link PersonDao} 类型，注意这里要把 useDefaultFilters 属性设置为 false
 * 第三个 {@link ComponentScan} 根据 {@link CustomTypeFilter} 自定义加载 bean
 *
 * <p>
 * FilterType.ANNOTATION 按照注解匹配
 * FilterType.ASSIGNABLE_TYPE 按照指定的类型
 * FilterType.ASPECTJ 使用 ASPECTJ 表达式
 * FilterType.REGEX 使用正则表达式
 * FilterType.CUSTOM 使用自定义方式
 *
 * <p>blog : https://blog.csdn.net/masteryourself
 *
 * @author : masteryourself
 * @version : 1.0.0
 * @date : 2020/3/28 20:20
 */
@Configuration
@ComponentScan(
        value = "pers.masteryourself.tutorial.spring.framework.register",
        excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION, value = {Repository.class, Controller.class})}
)
@ComponentScan(
        value = "pers.masteryourself.tutorial.spring.framework.register",
        includeFilters = {
                @ComponentScan.Filter(type = FilterType.ANNOTATION, value = Controller.class),
                @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, value = PersonDao.class)
        }, useDefaultFilters = false
)
@ComponentScan(value = "pers.masteryourself.tutorial.spring.framework.register", includeFilters = {
        @ComponentScan.Filter(type = FilterType.CUSTOM, classes = CustomTypeFilter.class)
}, useDefaultFilters = false)
public class SpringConfig {
}
1.2 @Bean

代码已经上传至 https://github.com/masteryourself-tutorial/tutorial-spring ，详见 tutorial-spring-framework/tutorial-spring-framework-register/tutorial-spring-framework-register-bean 工程

1.2.1 使用方式

@Configuration：声明是一个配置类，相当于 xml 配置文件

@Bean：给容器注入一个 bean，类型为返回值的类型，id 默认是方法名作为 id，可以通过 name 修改

1.2.2 环境搭建
1. SpringConfig
@Configuration
public class SpringConfig {

	@Bean(name = "personXxx")
	public Person person() {
		return new Person();
	}

}
1.3 @Import

代码已经上传至 https://github.com/masteryourself-tutorial/tutorial-spring ，详见 tutorial-spring-framework/tutorial-spring-framework-register/tutorial-spring-framework-register-import 工程

1.3.1 使用方式

@Import：向容器中注册组件一个 class，id 默认是全类名

ImportSelector：返回需要导入的组件的全类名数组

ImportBeanDefinitionRegistrar：手工注册 bean 到容器中

1.3.2 环境搭建
1. ExtImportSelector
public class ExtImportSelector implements ImportSelector {

    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"pers.masteryourself.tutorial.spring.framework.register.bean.Dog"};
    }

}
2. ExtImportBeanDefinitionRegistrar
public class ExtImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry registry) {
        Map<String, Object> annotationAttributes = annotationMetadata.getAnnotationAttributes(Import.class.getName());
        // 获取注解元数据：
        // {value=[
        // class pers.masteryourself.tutorial.spring.framework.register.bean.Cat,
        // class pers.masteryourself.tutorial.spring.framework.register.config.ExtImportSelector,
        // class pers.masteryourself.tutorial.spring.framework.register.config.ExtImportBeanDefinitionRegistrar]
        // }
        System.out.println("获取注解元数据：" + annotationAttributes);
        // 指定 bean 定义信息
        BeanDefinition beanDefinition = new RootBeanDefinition(Mouse.class);
        // 手工注册
        registry.registerBeanDefinition("mouse", beanDefinition);
    }

}
3. SpringConfig
@Import({Cat.class, ExtImportSelector.class, ExtImportBeanDefinitionRegistrar.class})
public class SpringConfig {
}
1.4 FactoryBean

代码已经上传至 https://github.com/masteryourself-tutorial/tutorial-spring ，详见 tutorial-spring-framework/tutorial-spring-framework-register/tutorial-spring-framework-register-factorybean 工程

1.4.1 使用方式

FactoryBean：使用 spring 提供的 FactoryBean（工厂 bean）

默认获取到的是工厂 bean 调用 getObject() 方法创建的对象

要获取工厂 bean 本身，需要在 id 前面加一个 &

1.4.2 环境搭建
1. PersonFactoryBean
public class PersonFactoryBean implements FactoryBean<Person> {

    @Override
    public Person getObject() throws Exception {
        System.out.println("调用了 PersonFactoryBean.getObject() 方法");
        return new Person();
    }

    @Override
    public Class<?> getObjectType() {
        return Person.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }

}
2. SpringConfig
@Configuration
public class SpringConfig {

    @Bean(name = "person")
    public PersonFactoryBean personFactoryBean() {
        return new PersonFactoryBean();
    }

}
3. FactoryBeanTest
public class FactoryBeanApplication {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        // 调用了 PersonFactoryBean.getObject() 方法
        Person person1 = context.getBean("person", Person.class);
        Person person2 = context.getBean("person", Person.class);
        // true
        System.out.println(person1 == person2);
        // class pers.masteryourself.tutorial.spring.framework.register.bean.Person
        System.out.println(person1.getClass());
        PersonFactoryBean personFactoryBean1 = context.getBean(PersonFactoryBean.class);
        PersonFactoryBean personFactoryBean2 = context.getBean("&person", PersonFactoryBean.class);
        // true
        System.out.println(personFactoryBean1 == personFactoryBean2);
        // class pers.masteryourself.tutorial.spring.framework.register.config.PersonFactoryBean
        System.out.println(personFactoryBean1.getClass());
    }

}

2. 其他注解

2.1 @Scope

代码已经上传至 https://github.com/masteryourself-tutorial/tutorial-spring ，详见 tutorial-spring-framework/tutorial-spring-framework-register/tutorial-spring-framework-register-scope 工程

2.1.1 使用方式

@Scope：指定作用域范围

  • prototype：多实例，ioc 容器启动并不会去调用方法创建对象放在容器中，每次获取的时候才会调用方法创建对象

  • singleton：单实例（默认值），ioc 容器启动会调用方法创建对象放到 ioc 容器中，以后获取就是直接从容器中获取

  • request：同一个请求创建一个实例

  • session：同一个 session 创建一个实例

2.1.2 环境搭建
1. SpringConfig
@Configuration
public class SpringConfig {

    @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    @Bean(name = "person")
    public Person person() {
        return new Person("张三");
    }

    @Scope(value = ConfigurableBeanFactory.SCOPE_SINGLETON)
    @Bean(name = "person2")
    public Person person2() {
        return new Person("李四");
    }

}
2. ScopeTest
public class ScopeApplication {

    public static void main(String[] args) {
        // 【李四】 用户创建成功
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        // ioc 容器创建完成
        System.out.println("ioc 容器创建完成");
        // 【张三】 用户创建成功
        Person person1 = context.getBean("person", Person.class);
        // 【张三】 用户创建成功
        Person person2 = context.getBean("person", Person.class);
        // false
        System.out.println(person1 == person2);
        context.getBean("person2", Person.class);
    }
    
}
2.2 @Lazy

代码已经上传至 https://github.com/masteryourself-tutorial/tutorial-spring ，详见 tutorial-spring-framework/tutorial-spring-framework-register/tutorial-spring-framework-register-lazy 工程

2.2.1 使用方式

@Lazy：懒加载，只针对于单实例（因为单实例 bean 默认在容器启动时候加载），在第一次使用的时候创建对象

2.2.2 环境搭建
1. SpringConfig
@Configuration
public class SpringConfig {

    @Scope(value = ConfigurableBeanFactory.SCOPE_SINGLETON)
    @Bean(name = "person")
    @Lazy
    public Person person() {
        return new Person();
    }

}
2. LazyTest
public class LazyApplication {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        // ioc 容器创建完成
        System.out.println("ioc 容器创建完成");
        // 创建 peron 对象
        context.getBean("person", Person.class);
        context.getBean("person", Person.class);
    }

}
2.3 @Conditional

代码已经上传至 https://github.com/masteryourself-tutorial/tutorial-spring ，详见 tutorial-spring-framework/tutorial-spring-framework-register/tutorial-spring-framework-register-conditional 工程

2.3.1 使用方式

@Conditional：按照一定条件进行判断，满足条件给容器中注册 bean

2.3.2 环境搭建
1. BatCondition
public class BatCondition implements Condition {

	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		LocalDateTime now = LocalDateTime.now();
		int hour = now.getHour();
		return hour >= 18 || hour <= 6;
	}

}
2. DogCondition
public class DogCondition implements Condition {

	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		LocalDateTime now = LocalDateTime.now();
		int hour = now.getHour();
		return hour > 6 && hour < 18;
	}

}
3. SpringConfig
@Configuration
public class SpringConfig {

    @Bean
    @Conditional(value = DogCondition.class)
    public Animal dog() {
        return new Animal("小狗");
    }

    @Bean
    @Conditional(value = BatCondition.class)
    public Animal bat() {
        return new Animal("蝙蝠");
    }
}
4. ConditionalTest
public class ConditionalApplication {

    public static void main(String [] args){
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        Map<String, Animal> beansOfType = context.getBeansOfType(Animal.class);
        // Animal{name='蝙蝠'}
        beansOfType.forEach((name,animal) -> System.out.println(animal));
    }

}
masteryourself
关注
专栏目录
10. 注解开发Bean作用范围和生命周期管理
DiKeLuoNa
12-19 321
spring注解开发模式下的bean的作用范围与生命周期
org.springframework.web的jar包.zip
03-27
在本篇文章中，我们将深入探讨`org.springframework.web`包中的关键概念，特别是`ServerEndpointExporter`类在WebSocket服务器端点中的作用。 首先，让我们了解`org.springframework.web`包的基本构成。这个包主要...
十一、Spring 注解设置Bean的作用范围和生命周期
mChenys的博客
03-29 277
Bean的作用范围注解 注解为@Scope(value=“prototype”)，作用在类上。 singleton – 单例，默认值 prototype – 多例 Bean的生命周期回调注解 @PostConstruct – 相当于配置文件中<bean>标签的init-method属性，bean对象创建的时候回调 @PreDestroy – 相当于配置文件中<bean...
bean的作用范围
carpe_diem0的博客
07-29 1182
1 定义 在Spring中使用Scope来表示一个bean定义对应产生实例的类型，也可以说是对应实例的作用范围。Spring内置支持的scope严格来说默认是有五种，分别是： singleton：这是默认Scope，表示在整个bean容器中或者说是整个应用中只会有一个实例。 prototype：多例类型，表示每次从bean容器中都会获取到一个对应bean定义全新的实例。 request：仅适用于Web环境下的ApplicationContext，表示每一个HttpRequest生命周期内会有一个单独的实例，
@Bean 注解的作用
tfish的专栏
06-26 3765
被 @Bean 注解标注的方法会创建一个 bean 的实例，放在 spring IoC 容器中。等需要使用这个 bean 的时候，在类里用 @Autowired，@Resource 注入这个对象就行了。 @Bean public AccountDao accountDao() { return new AccountDao(); } ...
@Bean注解说明
最新发布
LSW1737554365的博客
11-02 727
在Spring框架中，@Bean注解扮演着至关重要的角色。它是一种方便的配置管理方式，允许开发者在Spring应用程序中声明和配置Bean。通过使用@Bean注解，我们可以将Java类实例化为Spring容器中的Bean，从而实现对Spring应用程序的灵活配置和管理。本文将详细介绍@Bean注解的作用、使用方法、示例以及注意事项，帮助读者更好地理解和应用该注解。
org.springframework.web.jar
01-22
在Java的Web开发领域，Spring框架是不可或缺的重要工具，其中`org.springframework.web.jar`文件是Spring框架的核心组成部分，主要用于处理Web应用程序的相关功能。这个JAR（Java Archive）文件包含了Spring Web模块...
org.springframework.core_3.1.1.RELEASE.jar
05-25
其中，`org.springframework.core`是Spring框架的核心模块，包含了Spring框架的基础组件和核心功能。本文将深入探讨`org.springframework.core_3.1.1.RELEASE.jar`这一版本的核心模块，以期帮助读者理解其背后的知识...
org.springframework.core.jar
10-12
6. **事件驱动**：`org.springframework.context.event`包实现了事件发布和监听机制，允许组件之间通过事件进行通信，提高了系统的松耦合度。 7. **版本兼容**：`org.springframework.core.env`包包含了环境属性...
org.springframework.test-3.0.2.RELEASE.jar
01-01
在Spring的众多模块中，`org.springframework.test`扮演着至关重要的角色，它是Spring框架用于单元测试和集成测试的核心组件。本文将深入探讨`org.springframework.test-3.0.2.RELEASE.jar`这一版本中的关键概念和...
@Bean注解详解
热门推荐
怪咖@的博客
10-20 3万+
@Bean属于spring当中的注解，@Bean用于将对象存入spring的ioc容器中，同`@controller、@Service、@Component、@Configuration`等几个注解是一样的，都是负责`将对象存入容器当中`。只不过方式不同，他们是用在类上面的，然后将当前类`通过无参构造函数创建对象`然后放入容器，而`@Bean`是用在方法上，将当前方法的`返回值对象`放到容器当中！可以理解为前者是由spring自动创建对象，而@Bean创建对象是交给我们自己来控制。
Spring注解--bean生命周期的相关方法
方新德的博客
09-19 365
bean对象的生命周期主要是：实例的创建→实例的初始化→实例的销毁，三个时刻，对应着类中三个方法： 构造器、类的初始化方法（无特殊情况，类实例化后立即执行此方法）、实例销毁时立即执行的方法。  1.通过@Bean指定init-method和destroy-method； 2.通过让Bean实现InitializingBean（定义初始化逻辑）， DisposableBean（定义销毁逻辑）；...
bean的作用范围？
weixin_41980692的博客
04-28 476
通过scope属性，可以设置bean的作用域，Spring支持5种作用域。 singleton单态模式 在整个容器内，使用singletion定义的Bean是单例的，默认是单态的。 prototype 原态模式 每次使用getBean方法获取的同一个实例都是一个新的实例。 request 对于每一次http请求，都会产生一个不同的Bean实例。仅用于HTTP Request。 session ...
java注解 bean的作用_使用注解的方式来定义bean的作用域 即实现单例或原型
weixin_29104059的博客
02-24 182
第一步：新建工程 SecondSpring文件目录结构如下：第二步：导入相应的spring jar包略...第三步： 新建类AnnotationTest.javapackage com.xuzhiwen.spring4;import org.springframework.context.annotation.Scope;import org.springframework.stereoty...
Bean的作用范围的配置（重点）
09-26 313
​​Bean的作用范围的配置 scope属性 ：Bean的作用范围 singleton ：默认的，Spring会采用单例模式创建这个对象。 prototype ：多例模式。（Struts2和Spring整合一定会用到） request ：web项目中，Spring创建这个类以后，将这个类存入到request范围中。 sessio...
@Bean注解到底有什么用？
weixin_39071823的博客
08-16 1219
https://blog.csdn.net/qq_28893679/article/details/53452872 优秀文章
springboot 中@Bean的注解作用
健康平安的活着的专栏
07-27 1万+
一.@bean的作用 Spring的@Bean注解用于告诉方法，产生一个Bean对象，然后这个Bean对象交给Spring管理。Spring只会调用一次，将这个Bean对象放在自己的IOC容器中。 通俗的将就是在服务启动时，在需要初始化的实例，方法，内容时使用。 https://www.cnblogs.com/cxuanBlog/p/11179439.html https://www.jianshu.com/p/93727fa9bf23 二.案例 1.定义一个配置文件： package co
@Bean使用场景
及时当勉励，岁月不待人
03-09 1476
@Bean使用场景
Spring-基于注解的配置[03Bean作用范围和生命周期方法]
小工匠
07-30 1万+
Bean的作用范围 实例 Bean的生命周期方法 实例Bean的作用范围通过注解配置的Bean和通过<bean>配置的Bean一样，默认的作用范围都是singleton。 Spring为注解配置提供了一个@Scope注解，可以通过它显示指定Bean的作用范围。 @Scope注解通过入参指定Bean的作用范围。 在使用<bean>进行配置可以通过init-method和destory属性指定Bean
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
05-26
- xmlns:context="http://www.springframework.org/schema/context"：定义了Spring上下文命名空间，用于定义Spring上下文相关的配置，如组件扫描等。 - xsi:schemaLocation=...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值