Spring 的存储和获取Bean

于 2024-01-26 18:29:15 发布
阅读量907 收藏 28
点赞数 16
分类专栏： SSM 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CHJBL/article/details/135872582
版权

文章目录

获取 Spring 上下文对象的方式

首先获取 Bean 对象之前都需要先获取 Spring 的上下文对象，那么获取这个对象可以有以下方式

ApplicationContext context =
		new ClassPathXmlApplicationContext("spring-config.xml");

BeanFactory factory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));

那么这两者之间有什么区别呢，现在新建两个 Bean 类运行起来后看结果：

1、ApplicationContext

image-20240125172346756

2、BeanFactory

image-20240125172539215

两者的运行结果是不一样的，通过 BeanFactory 实例出来的并不会将 Teacher 对象放入 Spring

ApplicationContext 和 BeanFeactory：

  1. ApplicationContext 会将 xml文件中所声明需要注册到Spring中的 Bean 一次性全部注册完成，而BeanFactory 则是在首次去获取某一个Bean 对象时才会去注册该对象
  2. ApplicationContext 比较废内存但是之后的读取会很快
  3. BeanFeactory 比较省内存但是效率较低
  4. ApplicationContext 是 BeanFeactory 的子类，ApplicationContext 还拥有独特的特性， 添加了对国际化支持、资源访问支持、以及事件传播等方面的支持

存储 Bean 对象的方式

基本的存储方式需要在 spring-config.xml 文件中去添加指定的 Bean 注册内容才行，这样就很麻烦。

类注解

配置扫描路径（必须）

首先在进行注解前需要先配置好路径，在 spring-config.xml 中添加下面的代码

<content:component-scan base-package="spring.demo"></content:component-scan>

base-package中添加的是一串路径，也就是声明这个路径下的包中的 Bean 是有可能需要存入到 Spring 中的。注意只是有可能，开始的时候并没有立即注册存放到 Spring 中。

@Controller（控制器存储）

验证用户请求的数据正确性，相当于“安保系统”

Student类

import org.springframework.stereotype.Controller;

@Controller // 将当前类存储到 Spring 中
public class Student {
    public Student(){
        System.out.println("Student init");
    }

    public void print(String str){
        System.out.println(str);
    }
}

启动类

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import spring.demo.Student;

public class Start {
    public static void main(String[] args) {
        // 获取 Spring 的上下文对象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        // 获取 Bean 对象
        Student student = (Student) context.getBean("student", Student.class);
        // 使用 Bean 对象
        student.print("hello world");
    }
}

因为使用了注解后并没有指定id属性，这时需要将id属性写为类名的小驼峰形式，这是一个“约定”。

但是也有特例：

​ 原类名如果首字母和第二个字母都是大写的话，id属性的名称就和原类名相同

@Service（服务）

编排和调度具体执行方法，相当于“客服中心”

Student类

@Service // 将当前类存储到 Spring 中
public class Student {
    public Student(){
        System.out.println("Student init");
    }

    public void print(String str){
        System.out.println(str);
    }
}

这样也同样可以执行程序

@Repository（持久层）

和数据库进行交互，是一个“执行者”（DAO）

Student类

@Repository // 将当前类存储到 Spring 中
public class Student {
    public Student(){
        System.out.println("Student init");
    }

    public void print(String str){
        System.out.println(str);
    }
}

这样也同样可以执行程序

@Component（工具）

主要是注解工具类

Student类

@Component // 将当前类存储到 Spring 中
public class Student {
    public Student(){
        System.out.println("Student init");
    }

    public void print(String str){
        System.out.println(str);
    }
}

这样也同样可以执行程序

@Configuration（项目中的一些配置）

Student类

@Configuration // 将当前类存储到 Spring 中
public class Student {
    public Student(){
        System.out.println("Student init");
    }

    public void print(String str){
        System.out.println(str);
    }
}

这样也同样可以执行程序

关于五大类注解

  1. 如果遇到同一个包中有 同名的类 那么可以在使用注解时使用例如 @Controller(value = “XXX”) 这种方式去分别，但是建议一个包中尽量不要有同名类
  2. 五大注解的关系：事实上五大注解都是基于 Component 实现的，也就是它们都是 Component 的“子类”，是对于 Component 的扩展。那么需要分出这么多类注解的原因就是让程序员看到类注解之后，就能直接了解当前类的用途

方法注解

方法注解就是在一个有返回值的方法上加上 @Bean 注解的方式，也就是说 Spring 会将有着 @Bean 注解的方法的返回值的对象存入

需要注意：

  1. @Bean 注解需要配合五大类注解使用
  2. 使用了@Bean 注解后，默认的 Bean 对象ID属性为该具有 @Bean 注解的方法名
  3. 可以使用 @Bean(name = {“XXX”})的形式去设置这个 Bean 对象的ID属性。并且这个重命名的 name 其实是⼀个数组，一个 Bean 可以有多个名字，例如 @Bean(name = {“XXX”， “XXX”})。并且 name= 是可以去掉的，例如 @Bean({“XXX”, “XXX”})
@Component
public class UserBeans {
    @Bean({"user"})
    public User getUser(){
        User user = new User();
        user.setId(1);
        user.setName("张三");
        return user;
    }
}

public class Start {
    public static void main(String[] args) {
        // 获取 Spring 的上下文对象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        // 获取 Bean 对象
        User user = context.getBean("user", User.class);
        // 使用 Bean 对象
        System.out.println(user.getName());
    }
}

image-20240126175928869

获取指定的 Bean 对象的方式

获取到上下文对象之后就可以通过调用该对象的 getBean方法去获取 Bean 对象

普通方式

首先常规的就是使用加载时设置的 id 属性去获取

Student student = (Student) context.getBean("student");

需要注意这种方式的返回值是 Object 类的，因此需要强转为 Bean 对象的类

第二种方式可以通过 Bean类的.class 加上 id 属性去获取

Student student = context.getBean("student", Student.class);

这样写法就比较优美

第三种方式可以直接通过 .class去获取，但是存在隐患

Student student = context.getBean(Student.class);

存在什么隐患呢，首先一个 Bean类是可以存放多个对象到 Spring 中的，也就是可以这样

<bean id="student" class="spring.demo.Student"></bean>
<bean id="student2" class="spring.demo.Student"></bean>

那么如果还使用第三种方式就会出现，编译器不知道具体是要获取哪一个对象，就会报错

image-20240125174238394

因此不建议使用这种方式

对象注入

在 Spring 中实现依赖注入的常见方式有以下 3 种：

  1. 属性注入（Field Injection）；
  2. 构造方法注入（Constructor Injection）；
  3. Setter 注入（Setter Injection）。

属性注入

属性注⼊是使⽤ @Autowired 实现的，例如下列代码

// UserService

@Service
public class UserService {
    public void print(){
        System.out.println("hello");
    }
}

// UserController

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    public void print(){
        userService.print();
    }
}

// Start

public class Start {
    public static void main(String[] args) {
        // 获取 Spring 的上下文对象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        // 获取 Bean 对象
        UserController user = context.getBean("userController", UserController.class);
        // 使用 Bean 对象
        user.print();
    }
}

image-20240126180319147

首先可以看到 UserService 和 UserController 这两个类都是加了类注解的，因此在程序运行后，这两个 Bean 都是会被存放到 Spring 中。因为在 UserController 类包含了一个 UserService 对象，并且加了 @Autowired 注解，所以这个 UserService 对象就不需要 new 出来，而是会自动从 Spring 中直接获取。这就是属性注入

属性注入的优点：

​ 属性注入最大的优点就是实现和使用简单，只需要给变量上添加一个 @Autowired 注解，就可以在不 new 对象的情况下直接获得注入的对象

属性注入的缺点：

  1. 无法注入一个不可变的对象，也就是final 修饰的对象
  2. 只能适应于 IoC 容器
  3. 更容易违背单一设计原则

构造方法注入

构造方法注入是在类的构造方法中实现注入

// UserService

@Service
public class UserService {
    public void print(){
        System.out.println("hello");
    }
}

// UserController

@Controller
public class UserController {
   private UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    public void print(){
        userService.print();
    }
}

// Start

public class Start {
    public static void main(String[] args) {
        // 获取 Spring 的上下文对象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        // 获取 Bean 对象
        UserController user = context.getBean("userController", UserController.class);
        // 使用 Bean 对象
        user.print();
    }
}

image-20240126180319147

当该类中只有一个构造方法的时候，可以省略 @Autowired 注解，但是有多个构造方法时就需要在需要注入的方法上加上 @Autowired 注解

构造方法注入的优点：

  1. 可注入不可变对象；
  2. 注入对象不会被修改；（构造方法在对象创建时只会执行一次，因此它不存在注入对象被随时（调用）修改的情况）
  3. 注入对象会被完全初始化；（注入的对象在使用之前会被完全初始化）
  4. 通用性更好。（可适用于任何环境，无论是 IoC 框架还是非 IoC 框架）

Setter 注入

Setter 注入和属性的 Setter 方法实现类似，只不过在设置 set 方法的时候需要加上 @Autowired 注解

// UserService

@Service
public class UserService {
    public void print(){
        System.out.println("hello");
    }
}

// UserController

@Controller
public class UserController {
   	private UserService userService;

    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public void print(){
        userService.print();
    }
}

// Start

public class Start {
    public static void main(String[] args) {
        // 获取 Spring 的上下文对象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        // 获取 Bean 对象
        UserController user = context.getBean("userController", UserController.class);
        // 使用 Bean 对象
        user.print();
    }
}

image-20240126180319147

Setter注入的优点：

  1. 完全符合单一职责的设计原则，一个set方法只针对一个对象

Setter注入的缺点：

  1. 不能注入不可变对象；（final 修饰的对象）
  2. 注入的对象可被修改。（因为set方法的缘故，因此对象可以被随时随地修改）

@Resource：另⼀种注入关键字

@Controller
public class UserController {
    @Resource
    private UserService userService;

    public void print(){
        userService.print();
    }
}

@Autowired 和 @Resource 的区别：

  1. @Autowired 来自于 Spring，而 @Resource 来自于 JDK 的注解
  2. 相比于 @Autowired 来说，@Resource 支持更多的参数设置，例如 name 设置，根据名称获取 Bean，可以使用@Resource(name=“XXX”) 指定获取。而 @Autowired 需要配合 @Qualifier(value = “XXX”)
  3. @Resource 只能用于 Setter 注入和属性注入，不能用于构造函数注入

总结

属性注入的写法最简单，所以日常项目中使用的频率最高，但它的通用性不好；

而 Spring 官方推荐的是构造方法注入，它可以注入不可变对象，其通用性也更好。

如果是注入可变对象，那么可以考虑使用 Setter 注入

Spring框架——Spring注解和获取Bean对象详解
m0_73256420的博客
08-12 2240
基于Java的配置，允许你在少量的Java注解的帮助下，进行你的大部分Spring配置而非通过XML文件。以@Configuration 注解为例，它用来标记类可以当做一个bean的定义，被Spring IOC容器使用。另一个例子是@Bean注解，它表示此方法将要返回一个对象，作为一个bean注册进Spring应用上下文。@Bean}}...
Spring更简单保存和获取bean对象的方法(注解)
weixin_62877993的博客
11-14 1448
原因：不管@Resource注解和 @Autowired注解在注入对象的时候，都会有按照bean对象的id名来匹配，而我们写的变量名就是用来作比较的bean对象的id名。我们在使用@Bean方法注解或者使用xml配置的方法来将对象保存到Spring容器中的时候，很有可以会出现有比较多类型相同，但是bean对象的id名称不同 的情况。@Qualifier注解的作用：用来指定查找id名称是多少的bean对象，@Qualifier注解里面只有一个参数，用来设置用来指定查找id名称。
Spring在代码中获取bean的几种方式详解
08-25
主要介绍了Spring在代码中获取bean的几种方式详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
获取Spring-Bean的工具类
の博客
05-07 131
原文链接：https://blog.csdn.net/qq_43542296/article/details/123683461。版权声明：本文为CSDN博主「非情剑」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。System.out.println(“【步骤13】关闭spring bean容器contetx.close()”);
02-Spring中Bean的8种获取方式
最新发布
欢迎阅读我的博客
11-12 1467
基于XML,注解,实现ImportSelector, ImportBeanDefinitionRegistrar,BeanDefinitionRegistryPostProcessor接口获取Bean的区别
java普通类在任意位置得到spring 中的bean
洋洋的专栏
07-12 4071
方法一：在初始化时保存ApplicationContext对象 代码： ApplicationContext ac = new FileSystemXmlApplicationContex("applicationContext.xml");     ac.getBean("beanId");     说明：     这种方式适用于采用Spring框架的独立应用程序，需要程序通过配置文件
Spring获取Bean的9种方式
BASK2311的博客
01-13 2167
随着SpringBoot的普及，Spring的使用也越来越广，在某些场景下，我们无法通过注解或配置的形式直接获取到某个Bean。比如，在某一些工具类、设计模式实现中需要使用到Spring容器管理的Bean，此时就需要直接获取到对应的Bean。本文为大家整理汇总了常见的获取Bean的方式，并提供一些优劣分析，方便大家在使用到时有更好的选择。同时，也会为大家适当的普及和拓展一些相关知识。
Web项目中获取SpringBean与在非Spring组件中获取SpringBean.pdf
12-17
总的来说，获取非Spring管理组件中的SpringBean主要有两种方式：一是通过实现`ApplicationContextAware`接口并存储ApplicationContext，二是使用注解和静态内部类来注入BeanFactory。这两种方法都是Spring框架提供的...
Spring如何获取Bean
03-22
Spring 中获取 Bean 的多种方式 在 Spring 框架中，获取 Bean 是一个非常重要的步骤，因为它是使用 Spring 框架的基础。Spring 提供了多种方式来获取 Bean，这些方式可以根据不同的应用场景选择使用。 通过 XML ...
Spring手动获取指定Bean
Hello World
06-16 7566
起因由于项目需要把一个项目的某个功能移植到另一个项目中，但是两个项目结构不同，新写的接口不是被Spring容器管理的，没办法在接口中使用@Autowired注解自动注入Serivice（Ps.我这里说的接口是对外接口，不是Java中的interface，实际上是一个类），只能尝试手动注入。在网上查了查最终尝试了三种方式，最终有效的只有方法三，先列出方法，问题分析在后面。方法方法一：使用BeanFac
【Spring】普通类获取Spring容器的bean的方法
像风走过八千里
12-04 3325
我们通常在项目中获取Spring容器里bean的方式，一般是使用注解的方式（@Autowired、@Resource）直接注入就可以直接使用了，那么如果在一个普通的类里（别人使用它的实例是以new的方式使用的），此时再用注解的方式注入的将会是null，那这种情况下，我们该如何使用Spring容器里的bean呢？本篇博客讲解五种方法，接下来就依次详细讲一下使用方式
Spring 类路径下 Bean 扫描实现分析
大鹏的博客
08-31 2127
要获取类的信息，我们第一反应一般是通过反射获取，因为类加载器将类加载到虚拟机中，会读取 class 文件，而 class 文件中包含着完整的类的信息。那么 Spring 是怎么做的呢？是否还有其他更高效的方式？跟随源码，让我们一探究竟。
Spring根据包名获取包路径下的所有类
aipiannian6725的博客
08-04 722
参考mybatisMapperScannerConfigurer.java 最终找到 Spring的一个类 ClassPathBeanDefinitionScanner.java 参考ClassPathBeanDefinitionScanner 和它的父类ClassPathScanningCandidateComponentProvider，将一些代码进行抽取，得到如...
Spring中获取bean的两种方法
qq_35939864的博客
08-25 1304
第一种采用注解方法 注解的方法比较简单，不在进行详细介绍，这边主要将的是另外一种方法，当通过注解获取不到bean时，可以采用根据上下文获取。 第二种上下文获取bean @Component public class SpringBeanUtil implements ApplicationContextAware { private static Logger logger = Logg...
Spring通过全类名（反射）配置Bean以及三种依赖注入
qq_38409944的博客
09-12 5201
Spring通过全类名（反射）配置Bean特点： 1. 基于xml文件的方式， 2. 通过全类名反射， 3. 依靠IOC容器， 4. 依赖注入的方式：属性注入，构造器注入 Bean类： package hello; public class Hello { String name; int numberInt; double numberDouble; ...
获取bean的工具类
flysun的博客
07-28 844
工具类，用于获取spring中管理的bean import org.springframework.beans.BeansException; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.BeanFactoryAware; public cl
可以随时拿取spring容器中Bean的工具类
独行侠梦的博客
01-11 2492
在Spring帮我们管理bean后，编写一些工具类的时候需要从容器中拿到一些对象来做一些操作，比如字典缓存工具类，在没有找到字典缓存时，需要dao对象从数据库load一次，再次存入缓存中。此时需要在util工具类中拿到ioc容器中的dao对象。
Spring获取bean工具类
点击抽奖
07-21 292
Spring获取bean工具类 spring获取bean方法封装. 通用工具类 package com.sample.service.client.serviceclient.util; import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAw
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

CHJBL

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

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

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

打赏作者

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

抵扣说明：

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

余额充值