Spring框架学习 -- 读取和存储Bean对象

目录 🚀🚀

回顾

getBean()方法的使用 

根据name来获取对象

再谈getBean()

(1) 配置扫描路径

(2) 添加注解

① spring注解简介 

② 对类注解的使用

③ 注解Bean对象的命名问题

④ 方法加Bean注解

(3) @Bean 注解的重命名

(4) 获取Bean对象 -- 对象装配 

 属性注入

属性注入优缺点

setter注入 

 setter注入优缺点

构造方法注入 (官方推荐)

构造方法优缺点

(5) 另外一种注入关键字: @Resource

(6) 同一个变量多个@Bean注入报错

总结 

😍创作不易多多支持🫡 

回顾

        回忆一下我们之前是如何存储和使用Bean对象的, 首先我们需要在spring配置文件写入Bean对象, 或者说是spring容器中注入Bean对象:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="user1" class="org.example.User"></bean><bean id="user2" class="org.example.User"></bean>
</beans>

        然后在启动类中new出一个上下文对象, 要么使用BeanFactory, 要么使用ApplicationContext, 然后调用上下文对象中的getBean方法, 来获取到对应的Bean对象. 

        但是我每次使用都要去在spring配置文件中写入bean标签, 然后写上对应id和类. 这些步骤过于繁琐, 于是spring的作者就创造出了一种更简单的方式, 那就是直接在对应的类下面写上注解, 注解中填入id, 就省去了写路径的痛苦.

        我们现在就可以直接通过一行注解, 来代替我们之前要写一行配置的尴尬了,

        不过在写注解之前需要一点准备工作.

        首先在这之前我们应该去了解一下获取Bean对象的方法, 也就是getBean方法

getBean()方法的使用 

         spring容器提供了五种获取Bean的方法, 可以根据Bean的name来获取Bean, 也可以根据classType 来获取Bean对象, 所有的根据Bean的name来获取Bean的方法, 最后底层都会调用下面的doGetBean方法来获取Bean对象

根据name来获取对象

         spring 容器提供了三种根据Bean 的name来获取Bean的方法;

        BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("springConfig.xml"));User user = (User) beanFactory.getBean("user");User user1 = (User) beanFactory.getBean("user", User.class);User user2 = (User) beanFactory.getBean("user", new OrderUser());
  •  getBean("user") 是根据Bean的name 来获取Bean对象
  •  getBean("user", User.class) 是根据Bean的name来获取Bean, 然后判断Bean是否属于User类
  •   getBean("user", new OrderUser());则是使用自定义的方法来生成Bean对象

        上面三种方法都会调用doGetBean方法来生成Bean对象, 下面是doGetBean方法的原码:

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)throws BeansException {// name有可能是 &xxx 或者 xxx，如果name是&xxx，那么beanName就是xxx// name有可能传入进来的是别名，那么beanName就是idString beanName = transformedBeanName(name);Object beanInstance;// Eagerly check singleton cache for manually registered singletons.Object sharedInstance = getSingleton(beanName);if (sharedInstance != null && args == null) {// 如果sharedInstance是FactoryBean，那么就调用getObject()返回对象beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);}

        真正的BeanName来自这个transformedBeanName(name) 方法; 

        下面是这个方法的具体实现:

protected String transformedBeanName(String name) {return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}

         顺藤摸瓜. 先来看看BeanFactoryUtils.transformedBeanName(name) 的实现:

public static String transformedBeanName(String name) {Assert.notNull(name, "'name' must not be null");if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {return name;}return transformedBeanNameCache.computeIfAbsent(name, beanName -> {do {beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());}while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));return beanName;});
}

         什么是BeanFactory.FACTORY_BEAN_PREFIX?

        翻阅原码可以知道这个是一个字符串对象, 值为"&".

        我们再来看看String的subString方法:

         结合原码, 也就是说beanName的生成为:

beanName = beanName.subString(1);

        里层是一个do while循环, 也就是先去掉一个字符, 然后循环查看beanName的前面是否有"&"字符, 如果有就一直去掉这&字符. 

        如果传进来的name从一开始就不是&字符开头的字符串, 那么就直接返回当前的name. 

        总结来说就是 BeanFactoryUtils.transformedBeanName(name) 是去掉name前面的所有的&字符

        接下来回头看看这个canonicalName方法:

protected String transformedBeanName(String name) {return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}

         看看这个方法的具体实现:

public String canonicalName(String name) {String canonicalName = name;// Handle aliasing...String resolvedName;do {resolvedName = this.aliasMap.get(canonicalName);if (resolvedName != null) {canonicalName = resolvedName;}}while (resolvedName != null);return canonicalName;
}

 解析:

  • String name 为上面一层函数BeanFactoryUtils.transformedBeanName(name) 传过来的去掉开头的所有的&字符的字符串.
  • 此函数里面首先使用canonicalName字符串对象将这个去掉&的字符串给存起来了.
  • 创建了一个字符串变量: resolvedName
  • 随后进入dowhile循环, 首先是调用了this.aliasMap.get(canonicalName);
  • aliasMap是一个hashMap, 这里调用get方法拿到key = canonicalName, 如果对应value值不为空, 那么就将这个值赋值给canonicalName, 然后返回这个值canonicalName.

        Bean的别名存放在一个aliasMap中，其中KEY=别名，VALUE=beanName/别名，根据别名从aliasMap中拿到的可能是真正的beanName，也可能还是一个别名，所以用do-while循环，直到拿出来的名字从aliasMap再找不到对应的值，那么该名字就是真正的beanName了

        对bean 进行定义的时候，除了可以使用id 命名，为了提供多个别名，使用alias来指定，这些所有的名称都指向同一个bean:

<bean class="User1" name="user1"/>
<alias name="user1" alias="user2,user3"/>

再谈getBean()

        我们明明就可以根据一个String name来锁定一个Bean对象, 为什么后面还需要传入第二个参数 XXX.class??

        首先我们如果传入xxx.class, 我们在获取Bean对象的时候, 是返回一个Object类型的对象, 这个时候还需要我们进行强制类型转换成我们需要的类型, 但是这个时候可能会出错. 也就是说, 如果将其转换成了一个不是我们所需要的类, 那么在运行期间就会抛出异常.        

        我们第二个参数传入一个class, 此方法更安全，因为我们可以编译阶段就发现错误而不是在运行阶段。 

(1) 配置扫描路径

         想要将对象成功存储到容器中, 我们需要先配置一下存储对象的扫描路径, 只有被扫描到的包下的类, 添加注解才能被成功的识别到并被保存到容器中.

        首先我们拿下面这个这个目录结构为例:

 其中User类的代码如下:

package org.example;public class User {public void sayHi() {System.out.println("hello, how are you?");}
}

Student的代码如下:

package org.select;public class Student {public void sayHi() {System.out.println("hello student!! ");}
}

        下面我们首先添加扫描路径, 我们扫描select包下的所有的类, 于是就在spring配置文件中写入其扫描路径:

<content:component-scan base-package="org.select"></content:component-scan>

        将其访问spring配置文件的beans标签中:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:content="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 https://www.springframework.org/schema/context/spring-context.xsd"><content:component-scan base-package="org.select"></content:component-scan>
</beans>

        -- 其实添加这个扫描路径 就是为了更加精确的扫描出需要的类的所在的包, 为了更佳的性能

(2) 添加注解

        想要通过添加注解的方式来存储Bean对象, 那么首先就需要去了解一下spring的注解:

① spring注解简介 

Spring的注解是一种用于简化配置和开发的方式，它可以帮助开发人员更轻松地使用Spring框架。下面是几个常用的Spring注解的介绍：

  1. @Autowired：用于自动装配依赖关系。当Spring容器需要为一个属性注入一个bean时，它会查找与该属性类型匹配的bean，并将其自动注入到属性中。

  2. @Qualifier：用于指定要注入的bean的名称。当有多个与属性类型匹配的bean时，可以使用@Qualifier注解来指定要注入的bean的名称。

  3. @Component：用于将一个类标记为Spring容器的组件。被标记为@Component的类将被Spring自动扫描并注册为bean。

  4. @Controller：用于标记一个类作为Spring MVC的控制器。被标记为@Controller的类将处理HTTP请求并返回相应的视图。

  5. @Service：用于标记一个类作为业务逻辑层的组件。被标记为@Service的类通常包含业务逻辑，并被其他组件调用。

  6. @Repository：用于标记一个类作为数据访问层的组件。被标记为@Repository的类通常用于访问数据库或其他持久化存储。

  7. @Configuration：用于标记一个类作为Spring的配置类。被标记为@Configuration的类通常包含了一些用于配置Spring容器的bean定义。

  8. @Bean：用于在配置类中定义一个bean。被标记为@Bean的方法将返回一个对象，并将其注册为Spring容器的bean。

  9. @Value：用于注入属性值。可以将@Value注解应用于属性上，从而将属性值从配置文件中注入到属性中。

下面是一个使用@Autowired和@Qualifier注解的示例：

@Component
public class MyComponent {@Autowired@Qualifier("myBean")private MyBean myBean;// ...
}

        接下来我们仔细看看该如何使用...!!!

② 对类注解的使用

BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("springConfig.xml"));Student student = beanFactory.getBean("student", Student.class);student.sayHi();

 输出:

        使用spring容器手动添加Bean对象和扫描注解Bean对象是可以混用的.

③ 注解Bean对象的命名问题

        使用注解访问Bean对象, 那么getBean传入的第一个参数开头字母直接小写即可, 但是如果首字母和第二个字母都是大写, 那么开头一个字母小写是错误的, 这个时候直接使用原来的类名即可. 

其源码如下:

public static String decapitalize(String name) {if (name == null || name.length() == 0) {return name;}// 如果第⼀个字⺟和第⼆个字⺟都为⼤写的情况，是把 bean 的⾸字⺟也⼤写存储了if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) &&Character.isUpperCase(name.charAt(0))){return name;}// 否则就将⾸字⺟⼩写char chars[] = name.toCharArray();chars[0] = Character.toLowerCase(chars[0]);return new String(chars);
}

举个例子, 有三个类, 他们添加了注解, 然后使用getBean方法取出去Bean对象, 如下: 

        其中第二种就会找不到Bean对象.

④ 方法加Bean注解

        下面我们创建一个Test1类, 此类中有两个字段, 同时实现了其toString方法, 下面我们将通过添加Bean注解的方法来将这个类注入到容器:

package org.example2;/*** 普通的文章实体类*/
public class Test1 {private int age;private String name;@Overridepublic String toString() {return "Test1{" +"age=" + age +", name='" + name + '\'' +'}';}
}

        但是@Bean注解必须配合五大类注解一起使用

package org.select;/*** 普通的文章实体类*/
public class Test1 {private int age;private String name;@Overridepublic String toString() {return "Test1{" +"age=" + age +", name='" + name + '\'' +'}';}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

        添加Bean注解和五大类注解:

package org.example2;import org.select.Test1;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Controller;@Controller
public class RetTest1 {@Beanpublic Test1 returnTest() {Test1 test1 = new Test1();test1.setAge(18);test1.setName("张三");return test1;}
}

        文章目录结构:

        添加扫描路径:

<content:component-scan base-package="org.example2"></content:component-scan>

         配置上下文, 使用getBean获取Test1 的对象

ApplicationContext context = new ClassPathXmlApplicationContext("springConfig.xml");
//        BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("springConfig.xml"));RetTest1 retTest1 = context.getBean("retTest1", RetTest1.class);retTest1.sayHi();Test1 test1 = context.getBean("test1", Test1.class);System.out.println(test1.toString());

         -- 输出结果如下:

        可以发现, 一个类的方法添加了@Bean注解, 这个@Bean注解可以让被标记的方法返回的对象存储进入容器, 同时@Bean需要配合五大类注解进行, 所以被五大类注解标记的类对象同样也会被存入容器.

        需要注意的是, 使用@Bean注解的时候, 这里如果去使用BeanFactory去获取上下文的话, 就会找不到@Bean注解的方法返回的类.

        还有一点就是, 最后@Bean注解的方法, 在获取这个类的时候, getBean中的参数是@Bean注解的方法名, 而不是类名.

        如果将ApplicationContext 获取的上下文对象换成 BeanFactory, 就会显示如下:

        原因定位:
        使用`new XmlBeanFactory(new ClassPathResource("bean.xml"))`实例化出来的对象是无法读取Spring注解配置文件的，因为`XmlBeanFactory`只能解析XML格式的配置文件，而无法解析注解配置。而`ClassPathXmlApplicationContext`可以同时解析XML和注解配置文件，因此使用`new ClassPathXmlApplicationContext("bean.xml")`可以成功读取Spring注解配置文件。

        所以我们在IDEA中使用BeanFactory的时候可以看到一个删除线:

        此删除线的意思是 IDEA 不推荐使用这个方法, 而不是说不能用, 不推荐使用的原因是此方法已经过时, 有更好, 更安全的方法替代. 例如 ApplicationContext.

(3) @Bean 注解的重命名

         以下是@Bean注解的源码, 我们可以参考参考

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//package org.springframework.context.annotation;import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.beans.factory.annotation.Autowire;
import org.springframework.core.annotation.AliasFor;@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Bean {@AliasFor("name")String[] value() default {};@AliasFor("value")String[] name() default {};/** @deprecated */@DeprecatedAutowire autowire() default Autowire.NO;boolean autowireCandidate() default true;String initMethod() default "";String destroyMethod() default "(inferred)";
}

        在使用@Bean注解的时候, 可以通过name 属性来对Bean进行重新命名, 例如将下面一个名为myBean的Bean对象重新命名为newName:

@Bean(name = "newName")
public MyBean myBean() {return new MyBean();
}

        或者是直接在里面传入字符串, 即name = 此字符串

        此外，还可以使用@Bean注解的value属性来进行重命名，例如：

@Bean(name = "newName")
public MyBean myBean() {return new MyBean();
}

         我们总结一下这三种方式:

        @Bean支持指定多个别名 

         需要注意的是, 不管是value 还是 name 来命名这个Bean注解, 都不能再使用原来的方法名来获取这个Bean对象了.

        不管是value还是name. 它们都是一个字符串的数组, 可以传入多个别名:

 @Bean( value = {"newName","newName2","newName3"})public Test1 test1() {Test1 test1 = new Test1();test1.setAge(18);test1.setName("张三");return test1;}

        但是这几个名字newName, newName2,newName3都是指的同一个类. 

        需要注意的一个问题是, 如果我连续有三个方法或者是更多的方法都用的同一个Bean别名, 如下:

    @Bean("getTest1")public Test1 test1() {Test1 test1 = new Test1();test1.setAge(18);test1.setName("张三");return test1;}@Bean("getTest1")public Test1 test2() {Test1 test1 = new Test1();test1.setAge(17);test1.setName("李四");return test1;}@Bean("getTest1")public Test1 test3() {Test1 test1 = new Test1();test1.setAge(19);test1.setName("王五");return test1;}

         这个时候我再去访问这个getTest1这个Bean对象, 将会输出哪一个??

-- 输出:

        从结果上来看是输出的第一个,  其实这个是和它的加载的顺序时有关系的, 其中我们可以使用@Order注解来设定我们@Bean注解的加载顺序

        如果多个Bean的名称相同, 那么程序执行不会报错, 但是第一个Bean之后的对象不会被存放到容器中, 也就是只有在第一次创建Bean的时候, 会将对象和Bean名称关联起来, 后续再有相同名称的Bean存储的时候,  容器会自动忽略.

        同时如果我们的方法里面传入了参数, 那么在编译期间也会抛出异常:

    @Bean("getTest1")public Test1 test1(int age) {Test1 test1 = new Test1();test1.setAge(age);test1.setName("张三");return test1;}

         或者版本更高一点的编译器会在编译前就出现错误提示:

(4) 获取Bean对象 -- 对象装配 

        获取Bean对象, 也叫作对象装配, 是把对象取出来放到某个类中, 有时候页脚对象注入

        对象装配的实现方法有以下三种:

  1. 属性注入
  2. 构造方法注入
  3. Setter注入 

 属性注入

        属性注入是使用@Autowired实现的, 将Service类注入到Controller中, Service类中的代码实现如下:

首先创建User类:

package com.java.demo.User;public class User {private int age;private String name;public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "User{" +"age=" + age +", name='" + name + '\'' +'}';}
}

创建UserService类:

@Service
public class UserService {public User getUser(Integer id) {User user = new User();user.setAge(id);user.setName("my" + id);return user;}
}

创建UserController类:

@Controller
public class UserController {@Autowiredprivate UserService userService;public User getUser(Integer id) {return userService.getUser(id);}
}

 生成启动类:

public class Main {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("springConfig.xml");UserController userController = context.getBean(UserController.class);System.out.println(userController.getUser(1).toString());}
}

        解释: 我们首先配置好spring上下文对象之后, 就去获取这个userController的Bean对象, 然后调用其getUser方法 ,但是你可能会问, userController的getUser方法里面是UserService的getUser方法,但是这个对象里面的UserService字段userService未赋值, 怎么能调用其getUser方法啊, 这其实就是Autowired注解的作用, 他自动将UserService的Bean对象赋值给这个UserService字段, 然后调用.

        随后在userService的对象中调用getUser(1)

         最后返回User, 调用这个User的toString方法. 生成的结果如下:

属性注入优缺点

        属性注入使用非常简单, 但是也存在着一些问题:

(a) 无法注入被final修饰的变量

        图中显示, 变脸没有被初始化, 这个时候如果我们在这个类中加上这个变量的构造方法:

    @Autowiredprivate final UserService userService;public UserController() {userService = new UserService();}

        就不会出现编译前异常. 

(b) 通用性问题: 只是用与ioc容器

(c) 更容易违背单一性设计元素, 但是用起来更简单.

setter注入 

        创建类UserService:

public class UserService {public UserRepository userRepository;@Autowiredpublic void setUserRepository(UserRepository userRepository) {this.userRepository = userRepository;}public void sayHi() {System.out.println("UserService says hi");userRepository.add();}
}

         创建类UserRepository类:

@Repository
public class UserRepository {public int add() {System.out.println("userRepository add");return 1;}
}

        添加main方法:

public class Main {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("springConfig.xml");UserService userService = context.getBean("userService", UserService.class);userService.sayHi();}
}

 

        此时UserService类中的UserRepository字段会根据@Autowired修饰的setter方法自动注入Bean对象.

        结果输出--

 setter注入优缺点

(a) 无法注入被final修饰的变量 .

(b) setter中每一次都只设置一个属性, 遵守设置的单一性设计原则. 

(c) setter注入的对象可以被修改.

构造方法注入 (官方推荐)

         创建UserRepository类:

@Repository
public class UserRepository {public int add() {System.out.println("userRepository add");return 1;}
}

        创建UserService类:

@Service
public class UserService {private UserRepository userRepository;@Autowiredpublic UserService(UserRepository userRepository) {this.userRepository = userRepository;}public void sayHi() {System.out.println("sayHi in UserService: " + userRepository.add());}
}

        添加启动项:

public class Main {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("springConfig.xml");UserService userService = context.getBean("userService", UserService.class);userService.sayHi();}
}

         -- 输出

         此时此刻,我将UserService类中的构造方法上面的@Autowired注解给注释掉:

@Service
public class UserService {private UserRepository userRepository;// @Autowiredpublic UserService(UserRepository userRepository) {this.userRepository = userRepository;}public void sayHi() {System.out.println("sayHi in UserService: " + userRepository.add());}
}

        启动, 发现仍然可以输出结果:

        为什么? 其实这是官方推荐的注入方法,所以被spring官方特别照顾的注入方式,  标准的方法是要加的. 

        如果当前类中只存在一个构造方法时, @Autowired是可以省略的.

        如果有多个构造方法, 仍然注释掉@Autowired :

//    @Autowiredpublic UserService(UserRepository userRepository) {this.userRepository = userRepository;}public UserService(UserRepository userRepository, Integer i) {this.userRepository = userRepository;}

         此时启动的话是会报错的:

         释放掉这个 @Autowired :

@Service
public class UserService {private UserRepository userRepository;@Autowiredpublic UserService(UserRepository userRepository) {this.userRepository = userRepository;}public UserService(UserRepository userRepository, Integer i) {this.userRepository = userRepository;}public void sayHi() {System.out.println("sayHi in UserService: " + userRepository.add());}
}

        问题消失:

         使用构造方法去注入一个对象, 即使这个对象是被final修饰的, 仍然可以注入:

 

    private final UserRepository userRepository;@Autowiredpublic UserService(UserRepository userRepository) {this.userRepository = userRepository;}

构造方法优缺点

        优点

  •  可以注入一个被final修饰的变量
  • 注入的对象不会被修改, 因为构造方法只会加载一次
  • 构造方法注入可以保证注入对象完全初始化
  • 构造方法注入通用性更好

        缺点

  • 写法比属性注入复杂
  • 使用构造方法注入, 无法解决循环依赖问题.

(5) 另外一种注入关键字: @Resource

         在进行类注入的时候,除了可以使用@Autowired 注解之外, 还可以使用@Resource进行注入, 如下:

@Controller
public class UserController {@Resourceprivate UserService userService;public User getUser(Integer id) {return UserService.getUser(id);}
}

 @Autowired 和 @Resource 的区别

  • 出身不同, @Autowired 来自spring, 而@Resource来自JDK注解
  • 使用时设置的参数不同, 相比于@Autowired来说, @Resource支持更多的参数设置, 例如name, 根据名词获取Bean
  • @Autowired 可以用于setter注入, 构造方法注入, 属性注入, 但是@Resource只能用于setter注入, 和属性注入, 不能使用构造方法注入.
  • IDEA兼容性不同, 使用@Autowired 可能在idea专业版可能会出现误报的问题.

(6) 同一个变量多个@Bean注入报错

        对于同一个对象进行注入的时候, 但是找到了多个Bean对象, 此时spring就不知道注入哪一个,就会产生报错信息, 代码如下;

@Component
public class Users {@Beanpublic User user1() {User user = new User();user.setAge(18);user.setName("张三");return user;}@Beanpublic User user2() {User user = new User();user.setAge(20);user.setName("李四");return user;}
}

        在另外一个类中获取User对象, 如下:

public class UserController {@Resourceprivate User user;public User getUser() {return user;}
}

        main方法:

    public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("springConfig.xml");UserController userController = context.getBean("userController", UserController.class);}

         -- 输出

        找到了两个Bean对象. 抛出此异常. 

         分析: User类中有两个方法都是使用了@Bean注解, 在UserController类中使用@Resource进行属性注入, 此时就会根据@Bean来获取到这个User对象,但是这里有两个Bean对象, 到底赋值哪一个?

        原因: 非唯一的Bean对象

        解决方案:

  • @Resource的name值去定义, 例如 @Resource(name = "user1")
  • 使用@Qualifier注解定义其使用的Bean对象的名称

         解决方案的实例:

(a) 使用@Resource 的name注解:

@Controller
public class UserController {@Resource(name = "user1")private User user;public User getUser() {return user;}
}

(b) 使用@Qualifier注解:

@Controller
public class UserController {@Resource@Qualifier(value = "user1")private User user;public User getUser() {return user;}
}

总结 

  • 将对象存储到spring中的方法:
    • 使用类注解: @Controller, @Service, @Repository, @Configuration, @Component
    • 使用方法注解: @Bean, 必须配合上面的类注解来使用
  • Bean命名的规则, 首字母和第二个字母都非大写, 获取Bean的用首字母小写,如果首字母和第二个字母都是大写, 那么直接使用欧原来的Bean名获取Bean对象.
  • 从spring中获取对象
    • 属性注入
    • setter注入
    • 构造方法注入(官方推荐)
  • 注入的关键字还有
    • @Autowired
    • @Resource
    • @Resource和@Autowired的区别
  • 解决同一变量不同的Bean对象的问题
    • 使用@Resource(name = "xxx") 
    • 使用@Qualifier(value = "xxx")

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/163583.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

基于YOLO模型建筑工地个人防护设备目标检测

基于YOLO模型建筑工地个人防护设备目标检测

使用安全装备可以保护他们免受建筑工地的意外事故。据统计&#xff0c;每年有数以万计的工人在建筑工地受到严重伤害&#xff0c;造成终生困难。然而&#xff0c;通过自我监控来确保工人穿戴个人防护装备非常重要。在这方面&#xff0c;需要一个准确和快速的系统来检测工人是否…
阅读更多...
微信小程序其他环境都能显示在正式环境显示不出来

微信小程序其他环境都能显示在正式环境显示不出来

踩坑日记 用了uni.getImageInfo 用了uni.getImageInfo 本地开发环境&#xff0c;测试环境全都可以&#xff0c;就是更新到正式环境不显示。后面看代码百度了这个api发现图片所涉及的地址需要在小程序配置download域名白名单 https://uniapp.dcloud.net.cn/api/media/image.ht…
阅读更多...
地埋式积水监测仪厂家批发，实时监测路面积水

地埋式积水监测仪厂家批发，实时监测路面积水

地埋式积水监测仪是针对城市内涝推出的积水信息监测采集设备&#xff0c;采用超声波传感技术和超声波抗干扰功能&#xff0c;对路面的积水进行实时精准的监测。该设备能够在零下-5℃至高温70℃的严寒酷暑环境下可靠运行。它对城市道路积水进行实时监测并上报到监测系统之中&…
阅读更多...
线上问题排查实例分析｜关于 Redis 内存泄漏

线上问题排查实例分析｜关于 Redis 内存泄漏

Redis 作为高性能的 key-value 内存型数据库&#xff0c;普遍使用在对性能要求较高的系统中&#xff0c;同时也是滴滴内部的内存使用大户。本文从 KV 团队对线上 Redis 内存泄漏定位的时间线维度&#xff0c;简要介绍 Linux 上内存泄漏的问题定位思路和工具。 16:30 问题暴露 业…
阅读更多...
电动机保护方式

电动机保护方式

3.3.1、电动机温度保护 温度保护是利用安装在电动机内部的温度继电器或变换器来实现的。当电动机达到一定温度时继电器动作&#xff0c;通过控制电路断开电动机的主电路。对于单相小容量电动机&#xff0c;可以用继电器直接断开动力电路。 根据温度传感器的不同可以分为&…
阅读更多...
【Proteus仿真】【51单片机】篮球比赛计分器

【Proteus仿真】【51单片机】篮球比赛计分器

文章目录 一、功能简介二、软件设计三、实验现象联系作者 一、功能简介 本项目使用Proteus8仿真51单片机控制器&#xff0c;使用声光报警模块、动态数码管模块、按键模块等。 主要功能&#xff1a; 系统运行后&#xff0c;数码管显示比赛时间和AB队得分&#xff1b;系统还未开…
阅读更多...
数据中心运维管理：从人工到智能需要走几步？

数据中心运维管理：从人工到智能需要走几步？

一切的变化来自于数据中心规模、复杂度、设备多样性的挑战&#xff0c;将运维平台的重要性推向历史高点。 此外&#xff0c;基于业务连续性方面的考虑&#xff0c;分布式数据中心成为越来越多客户的选择。 一、数据中心面临的挑战 运维管理分散&#xff0c;缺乏统一的管理 I…
阅读更多...
Win11和NewBing浏览器100%开启Copilot的方法

Win11和NewBing浏览器100%开启Copilot的方法

严格按以下步骤来&#xff0c;100%开启免费的AI&#xff1a; 1.系统升级到Win11最新版&#xff08;不要用家庭版&#xff0c;推荐专业版&#xff09; 升级完成之后的系统信息&#xff08;时间截至2023.11.22&#xff09; 版本号&#xff1a;23H2 操作系统版本&#xff1a;226…
阅读更多...
MySQL数据库_01

MySQL数据库_01

Web后端开发_02 数据库介绍 什么是数据库&#xff1f; 数据库&#xff1a;DataBase&#xff08;DB&#xff09;&#xff0c;是存储和管理数据的仓库 数据库管理系统&#xff1a;DataBase Management System (DBMS)&#xff0c;操纵和管理数据库的大型软件。SQL&#xff1a;St…
阅读更多...
java学习part08权限

java学习part08权限

1.权限表格 外部类都是公有和缺省&#xff0c;因为其他两种对于外部类没有意义 一些内部成分都各种权限都可以 2.如何体现java封装性 答&#xff0c;通过权限控制&#xff0c;保证哪些可以给人看到&#xff0c;哪些不能
阅读更多...
手持式无线通信频谱分析仪 MS2713E

手持式无线通信频谱分析仪 MS2713E

MS2713E 手持式无线通信频谱分析仪 安立手持式无线通信频谱分析仪 MS2713E 旨在处理最恶劣的现场条件&#xff0c;使您能够监控、定位、识别和分析各种蜂窝、2G/3G/4G、陆地移动无线电、Wi-Fi 和广播信号。多功能 Spectrum Master 在定位和识别宽频率范围内的信号时&#xff0…
阅读更多...
3D人脸扫描设备助力企业家数字人复刻，打破商业边界

3D人脸扫描设备助力企业家数字人复刻，打破商业边界

京都薇薇推出数字人VN&#xff0c;以京都薇薇董事长为原型制作&#xff0c;赋能品牌直播、短片宣传、线上面诊等活动&#xff0c;进一步增强消费者对品牌的交互体验&#xff0c;把元宇宙与品牌相融合&#xff0c;推动品牌线上服务与线下服务实现数字一体化&#xff0c;打造一个…
阅读更多...
小白也看的懂的爬取视频操作

小白也看的懂的爬取视频操作

1.获取一段视频 可以直接从抖音下&#xff0c;也可以从b站上爬取&#xff08;注意法律谢谢&#xff09; 保护原创 b站的视频 直接复制网址链接到哔哩哔哩(bilibili)视频解析下载 - 保存B站视频到手机、电脑 去就好了&#xff0c;
阅读更多...
如何弱化市场大环境带来的影响？私域电商和裂变营销引来新趋势！

如何弱化市场大环境带来的影响？私域电商和裂变营销引来新趋势！

弱化市场大环境带来的影响需要从多个方面入手&#xff0c;包括深入了解市场和行业、建立品牌优势、多元化经营、优化供应链管理、加强客户关系管理、灵活应对市场变化等。同时需要注意不同领域和行业的市场变化和政策调整&#xff0c;及时调整经营策略和业务结构&#xff0c;保…
阅读更多...
获取ip属地（ip2region本地离线包-超简单）

获取ip属地（ip2region本地离线包-超简单）

背景 最近有涉及要显示ip属地&#xff0c;但我想白嫖&#xff0c;结果就是白嫖的api接口太慢了&#xff0c;要延迟3到4秒左右&#xff0c;很影响体验&#xff0c;而且不一定稳定。 结果突然看到了这个【ip2region】开源项目&#xff0c;离线识别ip属地&#xff0c;精度自己测…
阅读更多...
详解开源数据库审计平台Yearning

详解开源数据库审计平台Yearning

基本概念 数据库审计&#xff08;简称DBAudit&#xff09;能够实时记录网络上的数据库活动&#xff0c;对数据库操作进行细粒度审计的合规性管理&#xff0c;对数据库遭受到的风险行为进行告警&#xff0c;对攻击行为进行阻断。它通过对用户访问数据库行为的记录、分析和汇报&…
阅读更多...
无人智能货柜：提升购物体验

无人智能货柜：提升购物体验

无人智能货柜&#xff1a;提升购物体验 随着移动支付的普及&#xff0c;人们日常生活中的主要场景已经渗透了这一支付方式。同时&#xff0c;无人智能货柜作为购物的重要渠道&#xff0c;正在崭露头角。通过人工智能、图像识别和物联网技术的应用&#xff0c;无人智能货柜将使购…
阅读更多...
什么是复费率电表？

什么是复费率电表？

随着科技的不断进步和人们对能源管理的日益重视&#xff0c;复费率电表逐渐成为我国电力系统中不可或缺的一员。复费率电表是一种能够实现电能计量、峰谷电价划分以及负荷控制等多功能的智能电表&#xff0c;它采用先进的通信技术和计算机算法&#xff0c;对用户的用电行为进行…
阅读更多...
软件系统测试有哪些测试流程?系统测试报告编写注意事项

软件系统测试有哪些测试流程?系统测试报告编写注意事项

在软件开发的过程中&#xff0c;系统测试是至关重要的一环&#xff0c;它的目的是验证和评估软件产品是否符合预期的质量标准&#xff0c;以确保系统的稳定性、可靠性和安全性。 一、软件系统测试的测试流程 1、需求分析与测试计划制定&#xff1a;根据需求分析确定测试目标、…
阅读更多...
软件开发及交付的项目管理角色

软件开发及交付的项目管理角色

在软件开发及交付过程中&#xff0c;通常会涉及不同的角色和职责&#xff0c;包括业务角色、技术角色和管理角色。这些角色在项目管理中发挥着不同的作用&#xff0c;以确保项目的成功和交付高质量的产品。 业务角色&#xff1a;包括产品经理、业务分析师和业务运营人员等职位…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023