4.Spring 基于注解的配置

最新推荐文章于 2023-06-26 12:15:00 发布
最新推荐文章于 2023-06-26 12:15:00 发布
阅读量346 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QAQ123666/article/details/89419402
版权

1.基于注解的配置

Spring的一个核心功能是IOC，就是将Bean初始化加载到容器中，Bean是如何加载到容器的，可以使用Spring注解方式或者Spring XML配置方式。

不会修改、极少修改的用注解，会修改的用xml配置，如AOP的配置我就用XML，因为这个的改成场景比较多:
1.spring mvc controller中全部注解完成
2.Autowired注解
其余的全部xml
如数据库、系统环境配置、实体映射关系、实体描述、aop等。。

在XML注入之前进行注解注入，因此后者的配置将通过两种方式的属性连线被前者重写。

使用注解的方式使我们无需在XML中配置一个Bean引用，更加简单和方便。

注解配置默认情况下在Spring中是关闭的，我们需要在配置文件中使用<context:annotation-config/>激活它。
如下spring-config.xml文件：

<?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: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-3.0.xsd">
	
	<!-- 启用对注解的支持 -->
    <context:annotation-config/>

</beans>
注解描述
@Required@Required 注解应用于 bean 属性的 setter 方法。
@Autowired@Autowired 注解可以应用到 bean 属性的 setter 方法，非 setter 方法，构造函数和属性。
@Qualifier通过指定确切的将被连线的 bean，@Autowired 和 @Qualifier 注解可以用来删除混乱。
JSR-250 AnnotationsSpring 支持 JSR-250 的基础的注解，其中包括了 @Resource，@PostConstruct 和 @PreDestroy 注解。

2. @Required

@Required 注释应用于 bean 属性的 setter 方法，它表明受影响的 bean 属性在配置时必须放在 XML 配置文件中，否则容器就会抛出一个 BeanInitializationException 异常。

@Required 注释表示在调用对应bean的初始化方法之后对应的属性不允许为空。该注解主要用来做一个标注检查作用，以防止我们在运行时使用对应的属性进行操作时出现空指针问题。

下面显示的是一个使用 @Required 注释的示例。

下面是 Student.java 文件的内容：我们在setAge和setName方法上添加了@Required注释

package com.tutorialspoint;
import org.springframework.beans.factory.annotation.Required;
public class Student {
   private Integer age;
   private String name;
   @Required
   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   @Required
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
}

下面是 MainApp.java 文件的内容：

package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      Student student = (Student) context.getBean("student");
      System.out.println("Name : " + student.getName() );
      System.out.println("Age : " + student.getAge() );
   }
}

下面是配置文件 Beans.xml: 文件的内容：

<?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:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>

   <!-- Definition for student bean -->
   <bean id="student" class="com.tutorialspoint.Student">
      <property name="name"  value="Zara" />

      <!-- try without passing age and check the result -->
      <!-- property name="age"  value="11"-->
   </bean>

</beans>

一旦你已经完成的创建了源文件和 bean 配置文件，让我们运行一下应用程序。如果你的应用程序一切都正常的话，这将引起 BeanInitializationException 异常，并且会输出一下错误信息和其他日志消息：

Property 'age' is required for bean 'student'

下一步，在你按照如下所示从 “age” 属性中删除了注释，你可以尝试运行上面的示例：

<?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:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>

   <!-- Definition for student bean -->
   <bean id="student" class="com.tutorialspoint.Student">
      <property name="name"  value="Zara" />
      <property name="age"  value="11"/>
   </bean>

</beans>

现在上面的示例将产生如下结果：

Name : Zara
Age : 11

在Bean文件中，如果把name、age注释掉就会报错 ,如果你把Java类中的@Requred注释掉，不会报错但是输出的name和age都是null，所以@Requred用来避免null

3.@Autowired 注释

@Autowired注解用来表示自动注入的，其可以定义在属性上，set方法上，构造方法上等。
使用其进行标注后Spring将自动注入对应的内容，默认是按照类型进行注入。
使用了@Autowired标注进行注入的内容，默认是就是@Required的，即在对应bean完全初始化后对应的属性不能为空，必须进行注入。
可以通过@Autowired的require属性指定进行指定，默认为true，即必须进行注入。

3.1 标注在属性上

在属性中使用 @Autowired 注释可以除去 setter 方法。
当时使用 为自动连接属性传递的时候，Spring 会将这些传递过来的值或者引用自动分配给那些属性。

package com.tutorialspoint;
import org.springframework.beans.factory.annotation.Autowired;
public class TextEditor 
{
   @Autowired
   private SpellChecker spellChecker;
   //没有setSpellChecker()方法了
   public TextEditor() {
      System.out.println("Inside TextEditor constructor." );
   }  
   public SpellChecker getSpellChecker( ){
      return spellChecker;
   }  
   public void spellCheck(){
      spellChecker.checkSpelling();
   }
}

下面是配置文件 Beans.xml：

<?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:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>

   <!-- Definition for textEditor bean -->
   <bean id="textEditor" class="com.tutorialspoint.TextEditor">
   </bean>

   <!-- Definition for spellChecker bean -->
   <bean id="spellChecker" class="com.tutorialspoint.SpellChecker">
   </bean>

</beans>

一旦你在源文件和 bean 配置文件中完成了上面两处改变，让我们运行一下应用程序。如果你的应用程序一切都正常的话，这将会输出以下消息：

Inside TextEditor constructor.
Inside SpellChecker constructor.
Inside checkSpelling.

3.2 设为非必须注入

默认情况下，@Autowired 注释意味着依赖是必须的，它类似于 @Required 注释，然而，你可以使用 @Autowired 的 （required=false） 选项关闭默认行为。

即使你不为 age 属性传递任何参数，下面的示例也会成功运行，但是对于 name 属性则需要一个参数。你可以自己尝试一下这个示例，因为除了只有 Student.java 文件被修改以外，它和 @Required 注释示例是相似的。

package com.tutorialspoint;
import org.springframework.beans.factory.annotation.Autowired;
public class Student 
{
   private Integer age;
   private String name;
   @Autowired(required=false)
   public void setAge(Integer age) {
      this.age = age;
   }  
   public Integer getAge() {
      return age;
   }
   @Autowired
   public void setName(String name) {
      this.name = name;
   }   
   public String getName() {
      return name;
   }
}

3.3 标注在set方法上

在 XML 文件中的 setter 方法中使用 @Autowired 注释可以除去元素。
当 Spring遇到一个在 setter 方法中使用的 @Autowired 注释，它会在方法中试图执行 byType 自动连接。

示例：

package com.tutorialspoint;
import org.springframework.beans.factory.annotation.Autowired;
public class TextEditor 
{
   private SpellChecker spellChecker;
   @Autowired
   public void setSpellChecker( SpellChecker spellChecker ){
      this.spellChecker = spellChecker;
   }
   public SpellChecker getSpellChecker( ) {
      return spellChecker;
   }
   public void spellCheck() {
      spellChecker.checkSpelling();
   }
}

下面是另一个依赖的类文件 SpellChecker.java 的内容：

package com.tutorialspoint;
public class SpellChecker {
   public SpellChecker(){
      System.out.println("Inside SpellChecker constructor." );
   }
   public void checkSpelling(){
      System.out.println("Inside checkSpelling." );
   }  
}

下面是 MainApp.java 文件的内容：

package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      TextEditor te = (TextEditor) context.getBean("textEditor");
      te.spellCheck();
   }
}

下面是配置文件 Beans.xml：

<?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:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>

   <!-- Definition for textEditor bean without constructor-arg  -->
   <bean id="textEditor" class="com.tutorialspoint.TextEditor">
   </bean>

   <!-- Definition for spellChecker bean -->
   <bean id="spellChecker" class="com.tutorialspoint.SpellChecker">
   </bean>

</beans>

一旦你已经完成的创建了源文件和 bean 配置文件，让我们运行一下应用程序。如果你的应用程序一切都正常的话，这将会输出以下消息：

Inside SpellChecker constructor.
Inside checkSpelling.

3.4 标注在普通方法上

Spring也支持通过普通方法进行自动注入，对应的普通方法可以接收一到多个参数。

public class Hello 
{
	private BeanA beanA;
	private World world;

	@Autowired
	public void inject(World world, BeanA beanA) {
		this.world = world;
		this.beanA = beanA;
	}
}

3.5 标注在构造方法上

@Autowired也可以标注在构造方法上，以完成对构造方法参数的自动注入。

一个构造函数 @Autowired 说明当创建 bean 时，即使在 XML 文件中没有使用 元素配置 bean ，构造函数也会被自动连接。让我们检查一下下面的示例。

这里是 TextEditor.java 文件的内容：

package com.tutorialspoint;
import org.springframework.beans.factory.annotation.Autowired;
public class TextEditor 
{
   private SpellChecker spellChecker;
   @Autowired
   public TextEditor(SpellChecker spellChecker)
   {
      System.out.println("Inside TextEditor constructor." );
      this.spellChecker = spellChecker;
   }
   public void spellCheck(){
      spellChecker.checkSpelling();
   }
}

下面是配置文件 Beans.xml：

<?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:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>

   <!-- Definition for textEditor bean without constructor-arg  -->
   <bean id="textEditor" class="com.tutorialspoint.TextEditor">
   </bean>

   <!-- Definition for spellChecker bean -->
   <bean id="spellChecker" class="com.tutorialspoint.SpellChecker">
   </bean>

</beans>

如果你的应用程序一切都正常的话，这将会输出以下消息：

Inside SpellChecker constructor.
Inside TextEditor constructor.
Inside checkSpelling.

4.@Qualifier 注释

可能会有这样一种情况，当你创建多个具有相同类型的 bean 时，并且想要用一个属性只为它们其中的一个进行装配，在这种情况下，你可以使用 @Qualifier 注释和 @Autowired 注释通过指定哪一个真正的 bean 将会被装配来消除混乱。

下面显示的是使用 @Qualifier 注释的一个示例:

这里是 Student.java 文件的内容：

package com.tutorialspoint;
public class Student 
{
   private Integer age;
   private String name;
   public void setAge(Integer age) {
      this.age = age;
   }   
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }  
   public String getName() {
      return name;
   }
}

这里是 Profile.java 文件的内容：

package com.tutorialspoint;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
public class Profile 
{
   @Autowired
   @Qualifier("student1")//指定id为student1的bean将会被装配
   private Student student;
   public Profile(){
      System.out.println("Inside Profile constructor." );
   }
   public void printAge() {
      System.out.println("Age : " + student.getAge() );
   }
   public void printName() {
      System.out.println("Name : " + student.getName() );
   }
}

下面是 MainApp.java 文件的内容：

package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp 
{
   public static void main(String[] args) 
   {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      Profile profile = (Profile) context.getBean("profile");
      profile.printAge();
      profile.printName();
   }
}

考虑下面配置文件 Beans.xml 的示例：

<?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:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>

   <!-- Definition for profile bean -->
   <bean id="profile" class="com.tutorialspoint.Profile">
   </bean>

   <!-- Definition for student1 bean -->
   <bean id="student1" class="com.tutorialspoint.Student">
      <property name="name"  value="Zara" />
      <property name="age"  value="11"/>
   </bean>

   <!-- Definition for student2 bean -->
   <bean id="student2" class="com.tutorialspoint.Student">
      <property name="name"  value="Nuha" />
      <property name="age"  value="2"/>
   </bean>

</beans>

一旦你在源文件和 bean 配置文件中完成了上面两处改变，让我们运行一下应用程序。如果你的应用程序一切都正常的话，这将会输出以下消息：

Inside Profile constructor.
Age : 11
Name : Zara

5.Spring JSR-250 注释

Spring还使用基于 JSR-250 注释，它包括 @PostConstruct， @PreDestroy和 @Resource注释。因为你已经有了其他的选择，尽管这些注释并不是真正所需要的，但是关于它们仍然让我给出一个简短的介绍。

5.1.@PostConstruct 和 @PreDestroy 注释：

为了定义一个 bean 的安装和卸载，我们使用 init-method 和/或 destroy-method 参数简单的声明一下 。
init-method 属性指定了一个方法，该方法在 bean 的实例化阶段会立即被调用。
同样地，destroy-method 指定了一个方法，该方法只在一个 bean 从容器中删除之前被调用。

你可以使用 @PostConstruct 注释作为初始化回调函数的一个替代，@PreDestroy 注释作为销毁回调函数的一个替代，(自定义初始化函数和销毁函数)其解释如下示例所示。

示例

package com.tutorialspoint;
import javax.annotation.*;
public class HelloWorld 
{
   private String message;
   public void setMessage(String message){
      this.message  = message;
   }
   public String getMessage(){
      System.out.println("Your Message : " + message);
      return message;
   }
   @PostConstruct
   public void init(){
      System.out.println("Bean is going through init.");
   }
   @PreDestroy
   public void destroy(){
      System.out.println("Bean will destroy now.");
   }
}

下面是 MainApp.java 文件的内容。这里你需要注册一个关闭钩 registerShutdownHook() 方法，该方法在 AbstractApplicationContext 类中被声明。这将确保一个完美的关闭并调用相关的销毁方法。

package com.tutorialspoint;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp 
{
   public static void main(String[] args) 
   {
      AbstractApplicationContext context = 
                          new ClassPathXmlApplicationContext("Beans.xml");
      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();
      context.registerShutdownHook();
   }
}

下面是配置文件 Beans.xml，该文件在初始化和销毁方法中需要使用。

<?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:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>

   <bean id="helloWorld" 
       class="com.tutorialspoint.HelloWorld"
       init-method="init" destroy-method="destroy">
       <property name="message" value="Hello World!"/>
   </bean>

</beans>

一旦你在源文件和 bean 配置文件中完成了上面两处改变，让我们运行一下应用程序。如果你的应用程序一切都正常的话，这将会输出以下消息：

Bean is going through init.
Your Message : Hello World!
Bean will destroy now.

5.2.@Resource 注释：

你可以在字段中或者 setter 方法中使用 @Resource 注释，它和在 Java EE 5 中的运作是一样的。@Resource 注释使用一个 ‘name’ 属性，该属性以一个 bean 名称的形式被注入。你可以说，它遵循 by-name 自动连接语义，如下面的示例所示：

package com.tutorialspoint;
import javax.annotation.Resource;
public class TextEditor 
{
   private SpellChecker spellChecker;
   @Resource(name= "spellChecker")
   public void setSpellChecker( SpellChecker spellChecker ){
      this.spellChecker = spellChecker;
   }
   public SpellChecker getSpellChecker(){
      return spellChecker;
   }
   public void spellCheck(){
      spellChecker.checkSpelling();
   }
}

如果没有明确地指定一个 ‘name’，默认名称源于字段名或者 setter 方法。在字段的情况下，它使用的是字段名；在一个 setter 方法情况下，它使用的是 bean 属性名称。

九州殊口二
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
@Resource与@Autowired
chenyi406的博客
03-11 306
@Autowired @Autowired 属于Spring中的注解，使用必须有spring的依赖 @Autowired 是根据类型进行装配(byType)，默认情况下装配的对象必须存在，如果允许为null的话需要设置 @Autowried(required=false) 如果想使用名称装配可以结合@Qualifier注解使用（@Autowried @Qualifier(“xxx”)） ...
SpringBoot注解篇之@Resource与@Autowired
最新发布
weixin_36808034的博客
10-12 3322
大家好，我是AK，最近在整理Java相关技术知识体系化；本篇主要介绍@Resource 注解和 @Autowired的区别以及使用，适合学习spring框架小伙伴了解学习。
java spring required,Spring @Resource 忽略 required
weixin_39875503的博客
03-13 208
在使用spring 自动注入对象通常会用到@Autowired (spring 自定义注解)、@Resource (JSR-250规范定义的注解) 两个注解，在使用中@Autowired 支持 required = false 的设置可以允许注入对象为null，而@Resource 不支持该特性 (王侯将相宁有种乎?), 手动扩展spring使其支持null对象注入。探究源码// @Resourc...
【Spring面试全家桶】@Resource注解你真的会用吗
Java程序员廖志伟
06-26 3079
Resource注解是Java EE规范中的一种注入方式，用于进行依赖注入（Dependency Injection）。
@Autowired与@Resource区别
代码小疯子
09-29 745
有多个实现类时,@Resource先按照byName匹配，此时的name是“testService”，没有匹配结果，只能按照byType进行配置，此时又匹配到了“testServiceImpl1”和“testServiceImpl2”，结果不唯一，只能抛出异常.@Resource和@Autowired都可以作为注入属性的修饰，在接口仅有单一实现类时，两个注解的修饰效果相同，可以互相替换，不影响使用。可以结合@Qualifier。
注解配置SpringAOP共4页.pdf.zip
10-29
本文件"注解配置SpringAOP共4页.pdf.zip"可能详细介绍了如何使用注解来配置Spring的AOP功能。以下是对这个主题的深入探讨： 首先，我们需要理解AOP的基本概念。AOP提供了一种方式，让我们可以在不改变业务代码的...
AOP基于注解配置.zip
08-17
本知识点主要围绕"AOP基于注解配置"展开，我们将深入探讨如何在Spring框架中使用注解来实现AOP。 1. **AOP基础概念**：AOP是一种编程范式，它通过预定义好的“切面”（Aspect）来封装横切关注点，使得业务代码更...
Spring的DI注解配置.zip
08-09
本资料包"Spring的DI注解配置.zip"专注于讲解如何使用注解来实现Spring的DI配置。 一、依赖注入简介 依赖注入是面向对象设计中的一个原则，它提倡组件之间通过接口而非硬编码的实例化来建立关联。在Spring框架中，...
spring famework 基于注解配置示例
08-05
通过以上介绍，我们已经了解了Spring框架中基于注解配置的基本用法。这种方式让我们的代码更易读、更少的XML配置，提高了开发效率。在实际项目中，我们还可以结合Spring Boot和其他Spring生态的注解，如Spring Data ...
Spring Aop之AspectJ注解配置实现日志管理的方法
08-28
Spring Aop之AspectJ注解配置实现日志管理的方法 Spring Aop是基于AspectJ实现的面向切面编程（AOP），它提供了一个灵活的方式来实现日志管理。通过使用AspectJ注解，可以轻松地实现日志记录、性能监控、安全检查...
【开发日记】Spring中@Autowired和@Resource
二饭的博客
07-12 398
1.1、@Autowired注解由Spring提供，所属包： 1.2、@Resource注解由JDK提供，所属包： 2- 导入方式不同 2.1、注解只能按照类型注入，如果需要使用此注解按名称注入的话则需要搭配@Qualifier来实现按名称注入。2.2、注解默认使用名称注入，但也可以使用类型注入。名称注入： 类型注入： 类型和名称同时指定： 当类型与名称同时指定时，会找到唯一符合的bean进行注入。默认情况下，会在应用启动时@Autowired和@Resource注解会在IOC容器中查找相对应的Bean，如
@Autowired和@Resource的区别
qq_41986693的博客
01-08 1952
@Autowired和@Resource的区别 相同之处,都是实现了对象的注入。两者都可以写在字段和setter方法上。 不同之处，@Autowired是spring提供的注解，它是根据类型进行注入的，如果一个类型有多个bean值的时候，就会无法选择哪一个bean来进行注入，要搭配@Qualifier来配合使用，例如@Qualifier(name=“userDao1”) public class UserService { @Autowired @Qualifier(name="userDa
注解 @Resource 【转】
u011188592的专栏
08-20 211
在java代码中使用@Autowired或@Resource注解方式进行装配，这两个注解的区别是：@Autowired默认按类型装配，@Resource默认按名称装配，当找不到与名称匹配的bean才会按类型装配。    @Autowired     privatePersonDao  personDao;//用于字段上    @Autowired     public voidsetOrd
spring-@Autowired、@Qualifier、@Primary、@Resource使用
promisessh的博客
01-20 584
1、@Autowired 自动注入： 、默认优先按照类型去容器中找对应的组件:applicationContext.getBean(BookDao.class);找到就赋值 如果找到多个相同类型的组件，再将属性的名称作为组件的id去容器中查找applicationContext.getBean(“bookDao”) @Qualifier(“bookDao”)：使用@Qualifier指定需要装配的组件的id，而不是使用属性名 自动装配默认一定要将属性赋值好，没有就会报错；可以使用@Autowired(r
@Resource注解无法使用或失败以及java.lang.NoSuchMethodError:javax.annotation.Resource.lookup()的问题
weixin_46990115的博客
03-02 9297
关于@Resource注解无法使用或失败的问题 这几天在使用Spring框架学习的时候，在使用基于注解形式注入属性的@Resource的时候发现了一些问题，今天来分享一下。 在使用的时候发现会冒红报错，也无法导入javax.annotation.Resource 经过不断尝试以及上网查阅，发现了几个解决的方法： 1、Resource是javax.annotation包中的一个api，如果无法使用，那么可能是jdk版本太低或者太高的问题，这里推荐是jdk1.8 ......
Spring学习之Bean的自动装配（非注解）
u014285979的博客
08-24 498
一、四种类型的自动装配 byName 把与Bean的属性具有相同名字（或者ID）的其他Bean自动装配到Bean的对应属性中。如果没有跟属性名字相匹配的Bean，则该属性不进行装配。 byType 把与Bean的属性具有相同类型的其他Bean自动装配到Bean的对应的属性中。如果没有跟属性的类型相匹配的Bean，则该属性不被装配。
学习Spring(3)Bean
阿友的专栏
07-07 238
Spring Bean Spring中的Bean xml配置文件中的bean元素其实相当于一个实例对象 bean默认是单例模式，也就是不管getBean()方法获取多少遍都是同一个实例对象，但是bean可以设置为多例，就是每次getBean()的创建不同的对象 <!-- 将scope设置为prototype，一般叫原型，就可以实现多例模式--> <bean id="testDaoImpl" class="dao.TestDaoImpl" scope="prototype"/> Be
@Resource注解用法
热门推荐
YoErose的博客
08-20 1万+
@Resource注解和@Autowired注解一样，都是为了装配Bean，但是两者在使用上又有少许区别 @Autowired是默认按照类型装配Bean，当需要用名称装配时，可以在@Autowired后面使用@Qualifier注解指定name属性，来告知容器加载哪个bean @Resource默认按照名字装配Bean，即会按照name属性的值来找到具有相同id的Bean Definition 并注入。如果@Resource没有指定name属性，则会根据这个将要被注入的属性的名字来进行Bean.
Spring @Resource 忽略 required
chuangyatu7269的博客
11-01 1668
在使用spring 自动注入对象通常会用到@Autowired (spring 自定义注解)、@Resource (JSR-250规范定义的注解) 两个注解，在使用中@Autowired 支持 required = false 的设置可以允许注入对象为null，而@Resource 不支持该...
Spring2.5详细注解.doc
09-19
此外，Spring2.5还支持基于注解的事务管理，例如`@Transactional`，这允许在方法级别声明事务边界，简化了事务管理的代码。 总结起来，Spring2.5的注解配置提供了更加直观、灵活和高效的方式来管理应用的配置，减少...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值