Spring 的存储和获取Bean

最新推荐文章于 2024-05-21 10:23:42 发布
最新推荐文章于 2024-05-21 10:23:42 发布
阅读量829 收藏 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 注入

CHJBL
关注
  • 16
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Spring Boot 集成 MinIO（分布式对象存储系统）
09-27
内容概要：首先带着读者安装MinIO，并帮助读者通过 Spring Boot 框架一步步完成 MinIO 集成，快速上手分布式对象存储系统。在手写MinIO 工具类的过程中会摘取整体框架中的核心逻辑，简化代码实现过程，保留核心功能...
【Spring】项目创建、存储和获取 Bean 的基本方式
yzhcjl_的博客
07-29 594
各位读者好, 我是小陈,这是我的个人主页, 希望我的专栏能够帮助到你:📕JavaSE基础: 基础语法, 类和对象, 封装继承多态, 接口, 综合小练习图书管理系统等📗Java数据结构: 顺序表, 链表, 堆, 二叉树, 二叉搜索树, 哈希表等📘JavaEE初阶: 多线程, 网络编程, TCP/IP协议, HTTP协议, Tomcat, Servlet, Linux, JVM等(正在持续更新)提示：是正在努力进步的小菜鸟一只，如有大佬发现文章欠佳之处欢迎批评指点~ 废话不多说，直接上干货！
Spring 中获取 Bean 对象的三种方式
威威的博客
01-30 882
获取 Bean 对象的几种方式
Spring框架（三）Spring注解和获取Bean对象详解
淡沫初夏zz的博客
08-11 1242
Spring框架（三）Spring注解和获取Bean对象详解
一文带你了解Spring中存入Bean和获取Bean的方式
hero_jy的博客
07-19 1911
上图中就是五大类注解对应的层，通过源码可以看到其他四个注解都基于@Conponent。
Spring的存储与获取Bean
m0_74365243的博客
06-14 1870
描述了如何利用Spring的注解进行更简单的存储与获取Bean~~(通俗易懂, 耐心看完会有收获)
spring security 参考手册中文版
02-01
使用Spring 4.0.x和Gradle 24 2.4.3项目模块 25 核心 - spring-security-core.jar 25 远程处理 - spring-security-remoting.jar 25 Web - spring-security-web.jar 25 配置 - spring-security-config.jar 26 LDAP - ...
springmybatis
09-05
MyBatis是支持普通SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis使用简单的XML或注解用于配置和原始映射，将接口和Java的POJOs（Plan ...
Spring面试题
05-06
Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如图 1 所示。 组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下： ☆...
Spring中文帮助文档
08-05
5.4.1. 设置和获取属性值以及嵌套属性 5.4.2. 内建的PropertyEditor实现 6. 使用Spring进行面向切面编程（AOP） 6.1. 简介 6.1.1. AOP概念 6.1.2. Spring AOP的功能和目标 6.1.3. AOP代理 6.2. @AspectJ支持 ...
通联支付API集成(适用于SpringBoot)
m0_55337678的博客
05-17 381
通联支付实现代码
Spring-Cloud 微服务
weixin_65127444的博客
05-15 903
先来思考一个问题*通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址（ip，端口）等硬编码到了代码中，这种做法存在许多问题：1.一旦服务提供者地址变化，就需要手工修改代码2. 一旦是多个服务提供者，无法实现负载均衡功能3.一旦服务变得越来越多，人工维护调用关系困难那么应该怎么解决呢，这时候就需要通过注册中心动态的实现。
(三)Spring教程——依赖注入与控制反转
05-14 561
Spring有两个重要的接口：BeanFactory和ApplicationContext，所谓的容器就是实现了BeanFactory接口或者是ApplicationContext接口的类的实例，BeanFactory是最顶层、最基本的接口，它描述了容器需要实现的最基本的功能，比如对象的注册、获取等。在编写传统的Java应用代码时，我们一般是直接在对象内部通过new来创建对象，让程序主动去创建依赖对象，这就是一个“谁使用，谁创建”的过程，创建依赖对象的主动权和创建时机都是由自己来把控。
SpringBoot Validation自定义注解之校验指定最小整数
最新发布
thinkers
05-21 34
1，引入核心关键依赖。
spring 循环依赖
weixin_45849726的博客
05-14 446
先创建ABean1.0. 记录正在创建ABean singletonCurrentlyInCreation<1.1.实例化ABean–>得到一个对象–>存入singletonFactories1.2. 填充BBean属性–>去单例池找BBean–>没有就创建1.3. 进行其他依赖注入1.4. 初始化前，初始化1.5. 初始化后1.6. 放入单例池创建BBean2.1. 实例化BBean–>得到一个对象。
【SpringBoot】93、SpringBoot中使用Jasypt实现配置文件中敏感数据加密
Asurplus
05-17 20
Jasypt(Java Simplified Encryption)是一个 Java 库，它允许开发人员以最小的努力为项目添加基本的加密功能，而无需深入了解密码学的工作原理
Spring: Spring自带的Http客户端RestTemplate
玉汝于成
05-17 265
RestTemplate 是 Spring 框架中用于发送 HTTP 请求的客户端工具类。它简化了与 REST 服务的交互，并提供了许多方法来发送 HTTP 请求，如 GET、POST、PUT、DELETE 等。
基于SpringBoot的在线视频教育平台源码数据库
s123456sj的博客
05-17 831
随着科学技术的飞速发展，各行各业都在努力与现代先进技术接轨，通过科技手段提高自身的优势；对于在线视频教育平台当然也不能排除在外，随着网络技术的不断成熟，带动了在线视频教育平台，它彻底改变了过去传统的管理方式，不仅使服务管理难度变低了，还提升了管理的灵活性。这种个性化的平台特别注重交互协调与管理的相互配合，激发了管理人员的创造性与主动性，对在线视频教育平台而言非常有利。
SpringBoot项目的项目部署全过程
泉涸的博客
05-14 800
cd /opt/nginx/sbin 此时进入nginx的sbin (里面是nginx的启动命令)./configure--prefix=/opt/nginx (尽量安装到/opt/nginx目录下)(部署之前记得将全部ip(localhost/127.0.0.1)改为你的云服务器ip)(ps -ef |grep nginx 如果有端口即为启动成功)1.将提前准备好的nginx的安装包上传到Linux中(我用的是Xftp)将dist目录下的所有文件都上传到 /opt/nginx/html 中。
spring 存储 bean 实例的代码
05-12
Spring 存储 Bean 实例的代码主要是通过 BeanFactory 和 ApplicationContext 接口来实现的。 BeanFactory 是 Spring 的基本容器，它提供了对工厂模式的经典实现，即通过配置文件来进行 bean 的定义和创建，然后在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

CHJBL

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

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

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

打赏作者

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

抵扣说明：

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

余额充值