Spring注入Bean

2023-11-12 09:26:22

主要总结@Autowired和@Resource

1.项目结构：

Spring注入Bean

​

编辑

添加图片注释，不超过 140 字（可选）

2.pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.zyq</groupId>
  <artifactId>2_setBeans</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>2_setBeans Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>4.3.8.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <version>RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.0.1</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.2</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>

  <build>
    <finalName>2_setBeans</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

3.Student和ClassRoom(ClassRoom中要注入Student)

package com.zyq.entity;

import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.beans.ConstructorProperties;

@Data
//@AllArgsConstructor
@NoArgsConstructor
@Component
@Lazy
@Scope("singleton")//单实例 IOC容器启动的时候就会调用方法创建对象，以后每次获取都是从容器当中拿同一个对象（map当中）。
//@Scope("prototype")//多实例，IOC容器启动创建的时候，并不会创建对象放在容器在容器当中，每次当你需要的时候，需要从容器当中取该对象的时候，就会创建。
//@Scope("request")//同一个请求创建一个实例(一个request对应一个Student对象)
//@Scope("session")//同一个session创建一个实例(一个session对应一个Student对象)
public class Student {
    @Value("zs")
    private String name;
    private int age;
    public String toString(){
        return name;
    }

    @ConstructorProperties({"张三","20"})//构造函数上的注释，显示该构造函数的参数如何对应于构造对象的 getter 方法。例如：
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @PostConstruct
    public void postConstruct(){
        System.out.println("Student对象初始化后执行PostConstruct");
    }

    @PreDestroy
    public void preDestroy(){
        System.out.println("Student对象销毁前执行preDestroy");
    }

}



package com.zyq.entity;

import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
//import javax.inject.Inject;

@Component("cr")
//@Data
public class ClassRoom {

    //1.调用Student的set方法给属性注入
    //@Resource(name = "student",type = Student.class)//@Resource默认byName(根据bean的id查找对象)自动装配。
    //如果根据id没找到bean对象，再按照类型找，如果找到多个或没找到就抛异常，找到则自动注入(也可以叫自动装配)。
    //@Resource如果指定了name，则只用byName自动装配，如果指定了type，则只用byType自动装配。
    //如果name和type两个都指定了，则两个都要符合
    //可以用在：类、成员变量和方法上(方法参数上不能用，构造方法上不能用)

    //@Inject//此jdk环境不能用此注解不知道为啥
    //@Autowired//Spring 2.5 增加的注解，如果项目更换了其他框架则此注解会失效的(而@Resource不会)
    //1.用在何处：@Autowired是Spring 2.5 增加的注解，用在属性上或者set方法上注入对象，
    //2.装配方式：A.该注解默认按类型byType自动装配Bean的方式(从spring容器找到此类型的对象然后注入到成员变量中)。
    //(使用该注解时，类中无需setter方法)。如果没找到则抛异常。
    //B.如果找到两个类型都符合要求的对象(此时可以用@Primary指定某个类为主要的可解决问题)，则会再根据对象的id查找(以成员变量名字作为id查找bean对象)
    //C.如果没找到则报异常NoUniqueBeanDefinitionException，如果找到则自动注入(也可以叫自动装配)，如果没找到则抛异常。
    //D.另外还可以指定@Autowired按照id查找bean对象(有时也叫按名称查找bean对象)byType： 在@Autowired下边再用@Qualifier("id")指定id
    //@Autowired功能虽说非常强大，但是也有些不足之处。比如：比如它跟spring强耦合了，如果换成了JFinal等其他框架，功能就会失效。
    //而@Resource是JSR-250提供的，它是Java标准，绝大部分框架都支持。
    //@Autowired(required = true) true表示开启自动注入
    private Student s;

//    @Autowired//这是@Autowired自动将多个对象注入到集合中(只要符合集合的泛型要求即可)
//    private List<Student> userList;
//    @Autowired
//    private Set<Student> userSet;
//    @Autowired
//    private Map<String, Student> userMap;

    public void read(){
        System.out.println(s+" read english");
    }

//    @Autowired(required = true)//这是@Autowired和@Qualifier用在普通方法上的方式//spring会在项目启动的过程中，会自动调用一次加了@Autowired注解的方法，
//    public void read2(@Qualifier("student")Student s1){//我们可以在该方法做一些初始化的工作。
//        System.out.println(s1+" read english2");//注意：@Autowired也可以用在非静态方法的参数前@Autowired Student s1
//    }

//  @Autowired//这是@Autowired和@Qualifier用在构造方法上的方式
//  public ClassRoom(@Qualifier("student") Student s) {
//      this.s = s;//注意：@Autowired也可以用在构造方法的参数前 @Autowired Student s1
//  }


    public Student getS() {
        return s;
    }

//  @Autowired//这是@Autowired和@Qualifier用在set方法上的方式
//  public void setS(@Qualifier("student")Student s) {
//      this.s = s;
//  }

    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ClassRoom classRoom = (ClassRoom) o;
        return Objects.equals(s, classRoom.s);
    }

    public int hashCode() {
        return Objects.hash(s);
    }

    public String toString() {
        return "ClassRoom{" +
                "s=" + s +
                '}';
    }
}

//参考文章： https://www.zhihu.com/question/39356740


4.测试类：


package tests;

import com.zyq.entity.ClassRoom;
import com.zyq.entity.Student;
import org.junit.Test;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;

public class TestCase1 {

    @Test
    public void test1(){
        AbstractApplicationContext ac=new ClassPathXmlApplicationContext("spring-beans.xml");
        ClassRoom cr=ac.getBean(ClassRoom.class);
        Student s=cr.getS();
        s.setAge(1);
        s.setName("张三");

        cr.read();

        ac.close();
    }//https://www.w3cschool.cn/wkspring/t7n41mm7.html

    @Test
    public void test2(){//XmlBeanFactory已经不建议使用了
        XmlBeanFactory ac = new XmlBeanFactory(new ClassPathResource("spring-beans.xml"));
        ClassRoom cr=ac.getBean(ClassRoom.class);
        System.out.println(cr);
    }//ClassRoom对象中没有注入Student不知道原因，等待已经探究XmlBeanFactory

    @Test
    public void test3(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("spring-beans.xml");
        ClassRoom cr=ac.getBean(ClassRoom.class);
        Student s=cr.getS();
        s.setAge(1);
        s.setName("张三");

        cr.read();
        //ApplicationContext接口：是 BeanFactory 的子接口，也被称为 Spring 上下文。
        //FileSystemXmlApplicationContext：需要提供给构造器 XML 文件的完整路径。
        //ClassPathXmlApplicationContext：会从CLASSPATH 中搜索 xml bean 配置文件。
        //除了ClassPathXmlApplicationContext，还有WebXmlApplicationContext：该容器会在一个 web 应用程序的范围内加载在 XML 文件中已被定义的 bean。
    }


    @Test
    public void test4() {
        ApplicationContext ac = new FileSystemXmlApplicationContext("D:\\Program Files\\JetBrains_workspace\\zyq_test\\2_setBeans\\src\\main\\resources\\spring-beans.xml");
        ClassRoom cr=ac.getBean(ClassRoom.class);
        Student s=cr.getS();
        s.setAge(1);
        s.setName("张三");
        cr.read();
    }



    @Test
    public void test5() {
        ApplicationContext ac = new FileSystemXmlApplicationContext("D:\\Program Files\\JetBrains_workspace\\zyq_test\\2_setBeans\\src\\main\\resources\\spring-beans.xml");
        ClassRoom cr=(ClassRoom)ac.getBean("cr");
        cr.read();
    }


}





5.spring主配置文件spring-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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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-4.1.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd">

    <!-- scan the package and the sub package -->
    <context:component-scan base-package="com"/>

    <!-- don't handle the static resource: 不拦截静态资源 -->
    <mvc:default-servlet-handler/>

    <!-- if you use annotation you must configure following setting -->
    <mvc:annotation-driven/>

    <!-- configure the InternalResourceViewResolver
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/"/>
        <property name="suffix" value=".jsp"/>
    </bean> -->
</beans>


参考文章：https://www.zhihu.com/question/39356740


参考文字内容如下：


作者：苏三说技术 链接：https://www.zhihu.com/question/39356740/answer/1907479772 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 前言 最近review别人代码的时候，看到了一些@Autowired不一样的用法，觉得有些意思，特定花时间研究了一下，收获了不少东西，现在分享给大家。 也许@Autowired比你想象中更强大。


Spring注入Bean


​


编辑切换为居中


添加图片注释，不超过 140 字（可选）


最近无意间获得一份BAT大厂大佬写的刷题笔记，一下子打通了我的任督二脉，越来越觉得算法没有想象中那么难了。 [BAT大佬写的刷题笔记，让我offer拿到手软](这位BAT大佬写的Leetcode刷题笔记，让我offer拿到手软) 1. @Autowired的默认装配 我们都知道在spring中@Autowired注解，是用来自动装配对象的。通常，我们在项目中是这样用的： package com.sue.cache.service; import org.springframework.stereotype.Service; @Service public class TestService1 { public void test1() { } } package com.sue.cache.service; import org.springframework.stereotype.Service; @Service public class TestService2 { @Autowired private TestService1 testService1; public void test2() { } } 没错，这样是能够装配成功的，因为默认情况下spring是按照类型装配的，也就是我们所说的byType方式。 此外，@Autowired注解的required参数默认是true，表示开启自动装配，有些时候我们不想使用自动装配功能，可以将该参数设置成false。 2. 相同类型的对象不只一个时 上面byType方式主要针对相同类型的对象只有一个的情况，此时对象类型是唯一的，可以找到正确的对象。 但如果相同类型的对象不只一个时，会发生什么？ 在项目的test目录下，建了一个同名的类TestService1： package com.sue.cache.service.test; import org.springframework.stereotype.Service; @Service public class TestService1 { public void test1() { } } 重新启动项目时： Caused by: org.springframework.context.annotation.ConflictingBeanDefinitionException: Annotation-specified bean name 'testService1' for bean class [com.sue.cache.service.test.TestService1] conflicts with existing, non-compatible bean definition of same name and class [com.sue.cache.service.TestService1] 结果报错了，报类类名称有冲突，直接导致项目启动不来。 注意，这种情况不是相同类型的对象在Autowired时有两个导致的，非常容易产生混淆。这种情况是因为spring的@Service方法不允许出现相同的类名，因为spring会将类名的第一个字母转换成小写，作为bean的名称，比如：testService1，而默认情况下bean名称必须是唯一的。 下面看看如何产生两个相同的类型bean： public class TestService1 { public void test1() { } } @Service public class TestService2 { @Autowired private TestService1 testService1; public void test2() { } } @Configuration public class TestConfig { @Bean("test1") public TestService1 test1() { return new TestService1(); } @Bean("test2") public TestService1 test2() { return new TestService1(); } } 在TestConfig类中手动创建TestService1实例，并且去掉TestService1类上原有的@Service注解。 重新启动项目：


Spring注入Bean


​


编辑切换为居中


添加图片注释，不超过 140 字（可选）


果然报错了，提示testService1是单例的，却找到两个对象。 其实还有一个情况会产生两个相同的类型bean： public interface IUser { void say(); } @Service public class User1 implements IUser{ @Override public void say() { } } @Service public class User2 implements IUser{ @Override public void say() { } } @Service public class UserService { @Autowired private IUser user; } 项目重新启动时：


Spring注入Bean


​


编辑切换为居中


添加图片注释，不超过 140 字（可选）


报错了，提示跟上面一样，testService1是单例的，却找到两个对象。 第二种情况在实际的项目中出现得更多一些，后面的例子，我们主要针对第二种情况。 3. @Qualifier和@Primary 显然在spring中，按照Autowired默认的装配方式：byType，是无法解决上面的问题的，这时可以改用按名称装配：byName。 只需在代码上加上@Qualifier注解即可： @Service public class UserService { @Autowired @Qualifier("user1") private IUser user; } 只需这样调整之后，项目就能正常启动了。 Qualifier意思是合格者，一般跟Autowired配合使用，需要指定一个bean的名称，通过bean名称就能找到需要装配的bean。 除了上面的@Qualifier注解之外，还能使用@Primary注解解决上面的问题。在User1上面加上@Primary注解： @Primary @Service public class User1 implements IUser{ @Override public void say() { } } 去掉UserService上的@Qualifier注解： @Service public class UserService { @Autowired private IUser user; } 重新启动项目，一样能正常运行。 当我们使用自动配置的方式装配Bean时，如果这个Bean有多个候选者，假如其中一个候选者具有@Primary注解修饰，该候选者会被选中，作为自动配置的值。 4. @Autowired的使用范围 上面的实例中@Autowired注解，都是使用在成员变量上，但@Autowired的强大之处，远非如此。 先看看@Autowired注解的定义：


Spring注入Bean


​


编辑切换为居中


添加图片注释，不超过 140 字（可选）


从图中可以看出该注解能够使用在5种目标类型上，下面用一张图总结一下：


Spring注入Bean


​


编辑切换为居中


添加图片注释，不超过 140 字（可选）


该注解我们平常使用最多的地方可能是在成员变量上。 接下来，我们重点看看在其他地方该怎么用？ 4.1 成员变量 在成员变量上使用Autowired注解： @Service public class UserService { @Autowired private IUser user; } 这种方式可能是平时用得最多的。 4.2 构造器 在构造器上使用Autowired注解： @Service public class UserService { private IUser user; @Autowired public UserService(IUser user) { this.user = user; System.out.println("user:" + user); } } 注意，在构造器上加Autowired注解，实际上还是使用了Autowired装配方式，并非构造器装配。 4.3 方法 在普通方法上加Autowired注解： @Service public class UserService { @Autowired public void test(IUser user) { user.say(); } } spring会在项目启动的过程中，自动调用一次加了@Autowired注解的方法，我们可以在该方法做一些初始化的工作。 也可以在setter方法上Autowired注解： @Service public class UserService { private IUser user; @Autowired public void setUser(IUser user) { this.user = user; } } 4.4 参数 可以在构造器的入参上加Autowired注解： @Service public class UserService { private IUser user; public UserService(@Autowired IUser user) { this.user = user; System.out.println("user:" + user); } } 也可以在非静态方法的入参上加Autowired注解： @Service public class UserService { public void test(@Autowired IUser user) { user.say(); } } 4.5 注解 这种方式其实用得不多，我就不过多介绍了。 5. @Autowired的高端玩法 其实上面举的例子都是通过@Autowired自动装配单个实例，但这里我会告诉你，它也能自动装配多个实例，怎么回事呢？ 将UserService方法调整一下，用一个List集合接收IUser类型的参数： @Service public class UserService { @Autowired private List<IUser> userList; @Autowired private Set<IUser> userSet; @Autowired private Map<String, IUser> userMap; public void test() { System.out.println("userList:" + userList); System.out.println("userSet:" + userSet); System.out.println("userMap:" + userMap); } } 增加一个controller： @RequestMapping("/u") @RestController public class UController { @Autowired private UserService userService; @RequestMapping("/test") public String test() { userService.test(); return "success"; } } 调用该接口后：


Spring注入Bean


​


编辑切换为居中


添加图片注释，不超过 140 字（可选）


从上图中看出：userList、userSet和userMap都打印出了两个元素，说明@Autowired会自动把相同类型的IUser对象收集到集合中。 意不意外，惊不惊喜？ 6. @Autowired一定能装配成功？ 前面介绍了@Autowired注解这么多牛逼之处，其实有些情况下，即使使用了@Autowired装配的对象还是null，到底是什么原因呢？ 6.1 没有加@Service注解 在类上面忘了加@Controller、@Service、@Component、@Repository等注解，spring就无法完成自动装配的功能，例如： public class UserService { @Autowired private IUser user; public void test() { user.say(); } } 这种情况应该是最常见的错误了，不会因为你长得帅，就不会犯这种低级的错误。 6.2 注入Filter或Listener web应用启动的顺序是：listener->filter->servlet。


Spring注入Bean


​


编辑


添加图片注释，不超过 140 字（可选）


接下来看看这个案例： public class UserFilter implements Filter { @Autowired private IUser user; @Override public void init(FilterConfig filterConfig) throws ServletException { user.say(); } @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { } @Override public void destroy() { } } @Configuration public class FilterConfig { @Bean public FilterRegistrationBean filterRegistrationBean() { FilterRegistrationBean bean = new FilterRegistrationBean(); bean.setFilter(new UserFilter()); bean.addUrlPatterns("/*"); return bean; } } 程序启动会报错：


Spring注入Bean


​


编辑切换为居中


添加图片注释，不超过 140 字（可选）


tomcat无法正常启动。 什么原因呢？ 众所周知，springmvc的启动是在DisptachServlet里面做的，而它是在listener和filter之后执行。如果我们想在listener和filter里面@Autowired某个bean，肯定是不行的，因为filter初始化的时候，此时bean还没有初始化，无法自动装配。 如果工作当中真的需要这样做，我们该如何解决这个问题呢？ public class UserFilter implements Filter { private IUser user; @Override public void init(FilterConfig filterConfig) throws ServletException { ApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(filterConfig.getServletContext()); this.user = ((IUser)(applicationContext.getBean("user1"))); user.say(); } @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { } @Override public void destroy() { } } 答案是使用WebApplicationContextUtils.getWebApplicationContext获取当前的ApplicationContext，再通过它获取到bean实例。 6.3 注解未被@ComponentScan扫描 通常情况下，@Controller、@Service、@Component、@Repository、@Configuration等注解，是需要通过@ComponentScan注解扫描，收集元数据的。 但是，如果没有加@ComponentScan注解，或者@ComponentScan注解扫描的路径不对，或者路径范围太小，会导致有些注解无法收集，到后面无法使用@Autowired完成自动装配的功能。 有个好消息是，在springboot项目中，如果使用了@SpringBootApplication注解，它里面内置了@ComponentScan注解的功能。 6.4 循环依赖问题 如果A依赖于B，B依赖于C，C又依赖于A，这样就形成了一个死循环。


Spring注入Bean


​


编辑切换为居中


添加图片注释，不超过 140 字（可选）


spring的bean默认是单例的，如果单例bean使用@Autowired自动装配，大多数情况，能解决循环依赖问题。 但是如果bean是多例的，会出现循环依赖问题，导致bean自动装配不了。 还有有些情况下，如果创建了代理对象，即使bean是单例的，依然会出现循环依赖问题。 如果你对循环依赖问题比较感兴趣，也可以看一下我的另一篇专题《》，里面介绍的非常详细。 7. @Autowired和@Resouce的区别 @Autowired功能虽说非常强大，但是也有些不足之处。比如：比如它跟spring强耦合了，如果换成了JFinal等其他框架，功能就会失效。而@Resource是JSR-250提供的，它是Java标准，绝大部分框架都支持。 除此之外，有些场景使用@Autowired无法满足的要求，改成@Resource却能解决问题。接下来，我们重点看看@Autowired和@Resource的区别。


    

  •  
    @Autowired默认按byType自动装配，而@Resource默认byName自动装配。
     
    • 

  •  
    @Autowired只包含一个参数：required，表示是否开启自动准入，默认是true。而@Resource包含七个参数，其中最重要的两个参数是：name 和 type。
     
    • 

  •  
    @Autowired如果要使用byName，需要使用@Qualifier一起配合。而@Resource如果指定了name，则用byName自动装配，如果指定了type，则用byType自动装配。
     
    • 

  •  
    @Autowired能够用在：构造器、方法、参数、成员变量和注解上，而@Resource能用在：类、成员变量和方法上。
     
    • 

  •  
    @Autowired是spring定义的注解，而@Resource是JSR-250定义的注解。
     
    • 



此外，它们的装配顺序不同。 @Autowired的装配顺序如下：


Spring注入Bean


​


编辑切换为居中


添加图片注释，不超过 140 字（可选）


@Resource的装配顺序如下：


  1.  
    如果同时指定了name和type：
     


Spring注入Bean


​


编辑切换为居中


添加图片注释，不超过 140 字（可选）




  1.  
    如果指定了name：
     


Spring注入Bean


​


编辑切换为居中


添加图片注释，不超过 140 字（可选）




  1.  
    如果指定了type：
     


Spring注入Bean


​


编辑切换为居中


添加图片注释，不超过 140 字（可选）




  1.  
    如果既没有指定name，也没有指定type：
     


Spring注入Bean


​


编辑切换为居中


添加图片注释，不超过 140 字（可选）









 

上一篇：Spring学习笔记——Spring原始注解

下一篇：spring-Bean的自动装配