Spring@Autowired注解与自动装配
获取bean 的方法
获取bean 的方法在软件开发中,bean通常是指那些被Spring框架管理的对象。
它们通过依赖注入(DI)的方式,使得开发者可以更加便捷地在应用程序中获取和使用。
本文将详细介绍几种获取bean的方法。
### 获取Bean的方法#### 1.使用@Autowired注解Spring框架提供了`@Autowired`注解,这是一个自动装配的注解,可以用于字段、构造函数、方法或配置器(setter)方法上。
当你在某个字段上标注`@Autowired`时,Spring会自动寻找匹配的bean并注入。
```javaimport org.springframework.beans.factory.annotation.Autowired;import ponent;@Componentpublic class MyService {@Autowiredprivate OtherService otherService; // 自动注入OtherService的bean}```#### 2.使用@Inject注解除了`@Autowired`,Java CDI(Contexts and DependencyInjection)规范还提供了`@Inject`注解,该注解功能与`@Autowired`相似,可以在JSR-330兼容的容器中使用。
```javaimport javax.inject.Inject;public class MyService {@Injectprivate OtherService otherService; // 使用@Inject进行注入}```#### 3.使用BeanFactory通过`BeanFactory`获取bean是一种更原始的方式,它提供了更细粒度的控制,但需要更多的手动操作。
```javaBeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));MyService myService = (MyService) factory.getBean("myService");```#### 4.使用ApplicationContext`ApplicationContext`是Spring中更高级的容器接口,它提供了更多的高级特性,如事件发布、国际化支持等。
SpringBoot常用注解:@Resource@Component与@Autowired。。。
SpringBoot常⽤注解:@Resource@Component与@Autowired。
⼀、@Resource与@Component SR-250标准注解,推荐使⽤它来代替Spring专有的@Autowired注解。
@Resource的作⽤相当于@Autowired,只不过 @Autowired按byType⾃动注⼊,⽽@Resource默认按byName⾃动注⼊罢了。
@Resource有两个属性是⽐较重要的,分别是 name 和 type,Spring将 @Resource注解的name属性解析为bean的名字,⽽type属性则解析为bean的类型。
所以如果使⽤name属性,则使⽤byName的⾃动注⼊策略,⽽使⽤type属性时则使⽤byType⾃动注⼊策略。
如果既不指定name也不指定type属性,这时将通过反射机制使⽤byName⾃动注⼊策略。
1、@Resource装配顺序:(1)如果同时指定了name和type,则从Spring上下⽂中找到唯⼀匹配的bean进⾏装配,找不到则抛出异常(2)如果指定了name,则从上下⽂中查找名称(id)匹配的bean进⾏装配,找不到则抛出异常(3)如果指定了type,则从上下⽂中找到类型匹配的唯⼀bean进⾏装配,找不到或者找到多个,都会抛出异常(4)如果既没有指定name,⼜没有指定type,则⾃动按照byName⽅式进⾏装配(见2)。
如果没有匹配,则回退为⼀个原始类型(UserDao)进⾏匹配,如果匹配则⾃动装配。
⼆、@Autowired 在java代码中使⽤@Autowired或@Resource注解⽅式进⾏装配,这两个注解的区别是:@Autowired 默认按类型装配,@Resource默认按名称装配,当找不到与名称匹配的bean才会按类型装配。
@Autowired注解是按类型装配依赖对象,默认情况下它要求依赖对象必须存在,如果允许null值,可以设置它required属性为false。
完成自动装配和注解开发的理解描述
自动装配和注解开发的理解描述一、什么是自动装配和注解开发自动装配和注解开发是现代Java编程中非常重要的概念和技术。
它们为开发者提供了一种更简洁、高效的方式来实现代码的管理和优化。
自动装配是指Spring框架中的一种特性,它通过在配置文件中设置规则和参数,让Spring容器自动地将相互依赖的Bean关联在一起。
而注解开发则是JavaSE5.0引入的新特性,它允许开发者在代码中使用注解来进行配置和管理。
二、完成自动装配的基本原理1. 依赖注入在进行自动装配时,最基本的原理就是依赖注入。
依赖注入就是指通过某种机制,让一个对象得以获取其他对象的引用。
Spring框架通过构造函数注入、Setter方法注入和接口注入等方式来实现依赖注入,从而完成自动装配。
2. 基于类型的自动装配Spring框架可以根据Bean的类型来自动装配相应的依赖对象。
在配置文件中,开发者只需要声明Bean的类型和id,Spring容器就能够自动将相应的依赖对象注入到Bean中。
3. 基于名称的自动装配除了根据类型进行自动装配外,Spring框架还可以根据Bean的名称来进行自动装配。
在配置文件中,开发者可以通过指定关联Bean的id,让Spring容器自动将依赖对象注入到Bean中。
三、理解注解开发的核心概念1. 注解的定义注解是一种以@符号开头的特殊标记,在代码中使用注解可以为程序的元素(类、方法、变量等)打上标记,并在后续的程序中读取和利用这些标记。
2. 常用的注解在Java中,有一些常用的注解可以帮助开发者更加便捷地进行配置和管理。
比较常见的注解有:@Autowired、@Component、@Service、@Repository等。
这些注解可以让Spring框架更好地理解和管理Bean之间的依赖关系。
3. 注解的工作原理注解是在编译期或运行时通过反射机制来实现的,它可以帮助开发者在不修改原有代码的情况下实现配置的管理和优化。
Spring注解之@Autowired:装配构造函数和属性
Spring注解之@Autowired:装配构造函数和属性在User类中创建⼀个构造函数,传⼊参数student:import org.springframework.beans.factory.annotation.Autowired;import ponent;import java.io.Serializable;/*** @author Wiener*/@Componentpublic class User implements Serializable {private static final long serialVersionUID = 6089103683553156328L;private Long id;private Student student;public Long getId() {return id;}public void setId(Long id) {this.id = id;}@Autowired // 构造函数注⼊参数的⽅式User(Student student) {this.student = student;System.out.println("------ 为构造器装配Bean成功 ---------");}public void isStu() {student.studentStudy();System.out.println("------ 装配Bean成功 ---------");}}其中,Student类如下:import lombok.Getter;import lombok.Setter;import ponent;import java.io.Serializable;import java.util.Date;/*** @author Wiener*/@Getter@Setter@Componentpublic class Student implements Serializable {private static final long serialVersionUID = -5246589941647210011L;//姓名private String name;public Student() {System.out.println("A default student constructor." );}public void studentStudy() {System.out.println("A student is studying." );}}改造Spring Boot项⽬启动类:import er;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.context.ApplicationContext;/*** @author Wiener*/@SpringBootApplicationpublic class East7Application {public static void main(String[] args) {ApplicationContext act = SpringApplication.run(East7Application.class, args);User user = (User) act.getBean("user");user.isStu();}}执⾏测试函数后,控制台打印信息如下:A default student constructor.------ 为构造器装配Bean成功 ---------A student is studying.------ 装配Bean成功 ---------说明成员变量已经注⼊。
Spring自动装配及其注解
Spring⾃动装配及其注解⼀.属性⾃动装配 ⾸先,准备三个类,分别是User,Cat,Dog。
其中User属性拥有Cat和Dog对象。
1package com.hdu.autowire;23public class User {4private Cat cat;5private Dog dog;6private String str;78public Cat getCat() {9return cat;10 }11public void setCat(Cat cat) {12this.cat = cat;13 }14public Dog getDog() {15return dog;16 }17public void setDog(Dog dog) {18this.dog = dog;19 }20public String getStr() {21return str;22 }23public void setStr(String str) {24this.str = str;25 }26 }Class User1package com.hdu.autowire;23public class Cat {4public void shout() {5 System.out.println("miao~");6 }7 }Class Cat1package com.hdu.autowire;23public class Dog {4public void shout() {5 System.out.println("wang~");6 }7 }Class Dog测试代码:1package com.hdu.test;23import org.junit.Test;4import org.springframework.context.ApplicationContext;5import org.springframework.context.support.ClassPathXmlApplicationContext;67public class TestIOCDI {8 @Test9public void testMethodAutowire() {10 ApplicationContext context = new ClassPathXmlApplicationContext("resources/spring_autowire.xml");11 er user = context.getBean("user", er.class);12 user.getCat().shout();13 user.getDog().shout();14 }15 }Test<bean id="cat" class="com.hdu.autowire.Cat"></bean><bean id="dog" class="com.hdu.autowire.Dog"></bean><bean id="user"class="er"><property name="cat" ref="cat"></property><property name="dog" ref="dog"></property><property name="str" value="haha"></property></bean>1.2 autowire byName (按名称⾃动装配)由于在⼿动配置xml过程中,常常发⽣字母缺漏和⼤⼩写等错误,⽽⽆法对其进⾏检查,使得开发效率降低。
autowired注解使用
autowired注解使用
@Autowired注解是Spring框架中常用的注解之一,用于实现自动装配。
通过@Autowired注解,开发者可以在Spring容器中实现对象之间的依赖注入,从而提高代码的可维护性和可扩展性。
使用@Autowired注解,需要注意以下几点:
1. 通过@Autowired注解,可以将一个需要被注入的对象自动装配到目标对象中。
被注入的对象可以是一个实例对象,也可以是一个接口。
2. 如果在Spring容器中存在多个符合要求的对象,可以通过@Qualifier注解指定需要注入的对象。
3. 在使用@Autowired注解时,需要确保被注入的对象已经在Spring容器中被实例化,否则会出现注入失败的情况。
4. 通过@Autowired注解实现自动装配时,需要注意循环依赖的问题,避免出现死循环的情况。
总之,@Autowired注解是Spring框架中使用广泛的注解之一,掌握其使用方法可以提高代码的开发效率和可维护性。
- 1 -。
autowired和resource注解原理
autowired和resource注解原理一、概述在Java的Spring框架中,Autowired和Resource注解是两个非常重要的注解,它们在自动装配和资源加载方面发挥着重要的作用。
Autowired注解用于自动装配bean的属性,而Resource注解则用于加载资源文件。
本文将详细介绍这两个注解的原理和使用方法。
二、Autowired注解原理Autowired注解是Spring框架中用于自动装配bean属性的一个注解。
它的工作原理是基于Java的反射机制,在运行时扫描类路径下的所有bean,并根据Autowired注解自动为相应的属性赋值。
Autowired注解的使用非常简单,只需要在相应的属性上标注该注解即可。
Autowired注解的工作流程可以分为以下几个步骤:1.扫描类路径下的所有bean:Spring框架会在启动时扫描类路径下的所有类,并注册为bean。
2.匹配属性:Spring会根据Autowired注解的类路径匹配相应的属性,并尝试为其赋值。
3.自动装配:如果找到了匹配的bean,Spring会自动将其值注入到相应的属性中。
如果没有找到匹配的bean,则不会进行自动装配。
Autowired注解支持多种类型的自动装配,包括field、setter、constructor和class等。
其中,field类型的自动装配是最常用的一种方式,它可以直接为属性赋值。
Autowired注解还支持多个属性的自动装配,可以通过使用"&&"运算符来同时匹配多个属性。
三、Resource注解原理Resource注解是Spring框架中用于加载资源文件的注解。
它允许开发者通过标注在资源文件上,让Spring框架自动加载和加载这些资源文件。
Resource注解的使用也非常简单,只需要在相应的类或方法上标注该注解即可。
Resource注解的工作流程可以分为以下几个步骤:1.解析资源路径:Spring会解析Resource注解中指定的资源路径,确定要加载的资源文件的位置。
autowired的底层原理
autowired的底层原理Autowired是Spring框架中一个非常重要的注解,它的底层原理是通过自动装配的方式来实现依赖注入。
依赖注入是指通过注解或者配置文件的方式将一个对象所依赖的其他对象注入进来。
在Spring框架中,有多种方式可以实现依赖注入,而Autowired是其中的一种方式。
它的原理是通过扫描指定包下的所有类,识别被@Autowired注解标注的字段、方法或构造函数,并将其自动装配到对应的属性中。
具体来说,Autowired的底层原理可以分为以下几个步骤:1. 扫描指定包下的所有类:Spring容器会通过配置文件或者注解来指定需要扫描的包路径。
然后,它会利用反射机制扫描指定包下的所有类,并将这些类的信息保存起来。
2. 标记被@Autowired注解的字段、方法或构造函数:扫描到类的信息后,Spring容器会继续扫描这些类中的字段、方法或构造函数。
如果发现有被@Autowired注解标记的字段、方法或构造函数,就会将其标记为需要被自动装配的依赖。
3. 解析依赖关系:在识别出需要被自动装配的依赖后,Spring容器会解析这些依赖的类型和名称。
它会根据这些信息去查找容器中已经创建的对象,如果找到了匹配的对象,就将其注入到对应的属性中。
4. 创建并注册对象:如果容器中没有找到匹配的对象,那么Spring容器会自动创建这个对象,并将其注册到容器中。
这样,下次再遇到相同类型和名称的依赖时,就可以直接从容器中获取已经创建的对象。
5. 解决循环依赖:在解析依赖关系的过程中,有可能会遇到循环依赖的情况。
为了解决这个问题,Spring容器会采取一些额外的策略,例如使用代理对象或者提前暴露半成品等方式来处理循环依赖。
总结起来,Autowired的底层原理就是通过扫描指定包下的类,识别被@Autowired注解标注的字段、方法或构造函数,并将其自动装配到对应的属性中。
它是Spring框架中实现依赖注入的一种方式,可以大大简化开发过程,提高代码的可维护性和可测试性。
Spring自动装配和相关注解说明
Spring⾃动装配和相关注解说明0.⾃动装配原理:1.⾃动装配:将类在spring容器中注册,并⾃动注⼊后使⽤。
2.注册的两个注解: (1)@Component和@Bean,都可以注册, @Component作⽤于类上,@Bean作⽤于⽅法(⽅法返回值为需要注册的对象) (2)@Component配合@ComponentScan(“扫描的路径"),配置中(XMl或者Java配置类)加⼊扫描注解(@ComponentScan)且类中加⼊@Component,这样被扫描的类就被托管到Spring容器中,获取 Bean时默认取类名⼩写。
(3)@Bean⼀般配合@Configuration(Java配置类注解),作⽤于⽅法(⽅法返回值为需要注册的对象)。
3.注⼊的两个注解:@Resource(不常⽤)和@Autowired 区别: 1.都是⽤来注⼊,都可以放到属性字段或setter⽅法上。
2.@Autowired通过bytype的⽅式⾃动装配,也可以配合@Qualifier(name=" XXX")⽤byname的⽅式。
3.@Resource默认通过byname⽅式,如果name没有找到,则通过bytype(类型要和Spring配置⽂件中Bean类型⼀致)实现,@Resource(name=" XXX"),参数name类别名,要和bean中id⼀致。
4.@Component 的⼀些衍⽣注解,作⽤都是注册:(1)dao层注册类的注解@Repository(2)service层 @service (3)Controller层 @Contriller ,⽤法都⼀样,都是代表类在Spring容器中注册。
2.@Value(“属性值”)放在属性上,说明这个属性被Spring管理且注⼊ 3.@Scope 作⽤域(单例、原型等)。
Spring的注解详解
Spring的注解一、 spring注解1、@Autowired注入注解@Autowired可以对成员变量、方法和构造函数进行标注,来完成自动装工作。
@Autowired的标注位置不同,它们都会在Spring在初始化这个bean时,自动装配这个属性。
@Autowired是根据类型进行自动装配的。
例如,如果当Spring上下文中存在不止一个UserDao类型的bean时,就会抛出BeanCreationException异常。
如果Spring上下文中不存在UserDao类型的bean,也会抛出BeanCreationException异常。
我们可以使用@Qualifier配合@Autowired来解决这些问题。
1.public class TestController {2.3.@Autowired4.@Qualifier(“u serDao”)5.Private UserService userService;6.7.@RequestMapping("/showView")8.public ModelAndView showView(){9.ModelAndView modelAndView = new ModelAndView();10.modelAndView.setViewName("viewName");11.modelAndView.addObject("属性名称","属性值");12.return modelAndView;13.}14.}2、@Resource注入注解JSR-250标准注解,推荐使用它来代替Spring专有的@Autowired注解。
@Resource的作用相当于@Autowired,只不过@Autowired按byType自动注入,而@Resource 默认按byName自动注入罢了。
autowire原理
autowire原理autowire原理是Spring框架中的一个重要概念,它可以自动装配依赖关系,简化了开发过程,提高了代码的可维护性和可读性。
本文将详细介绍autowire原理及其使用方法。
一、autowire原理简介在传统的Java开发中,我们需要手动创建对象并将其注入到其他对象中使用。
而在Spring框架中,我们可以使用autowire来实现自动装配。
简单来说,autowire可以将一个对象注入到另一个对象中,而无需显式地在配置文件中进行配置。
二、autowire的使用方法在Spring框架中,我们可以通过以下几种方式来使用autowire:1. byName方式:根据属性的名称进行自动装配。
例如,如果一个属性的名称为“userService”,Spring会自动查找名称为“userService”的bean,并将其注入到该属性中。
2. byType方式:根据属性的类型进行自动装配。
例如,如果一个属性的类型为“UserService”,Spring会自动查找类型为“UserService”的bean,并将其注入到该属性中。
如果存在多个符合条件的bean,则会抛出异常。
3. constructor方式:根据构造函数的参数类型进行自动装配。
例如,如果一个构造函数的参数类型为“UserService”,Spring会自动查找类型为“UserService”的bean,并将其注入到该构造函数中。
如果存在多个符合条件的bean,则会抛出异常。
三、autowire的原理解析autowire的原理主要涉及到两个方面:bean的定义和bean的装配。
1. bean的定义:在Spring框架中,我们可以通过XML配置文件或注解的方式来定义bean。
当定义一个bean时,可以使用<bean>标签的autowire属性来指定autowire的方式。
例如,<bean autowire="byName">表示使用byName方式进行自动装配。
详解Springbean的注解注入之@Autowired的原理及使用
详解Springbean的注解注⼊之@Autowired的原理及使⽤⼀、@Autowired概念:@Autowired 注释,它可以对类成员变量、⽅法及构造函数进⾏标注,完成⾃动装配的⼯作。
通过 @Autowired的使⽤来消除set ,get⽅法。
在使⽤@Autowired之前,我们对⼀个bean配置起属性时,⽤的是<property name="属性名" value=" 属性值"/>使⽤@Autowired之后,我们只需要在需要使⽤的地⽅使⽤⼀个@Autowired 就可以了。
代码使⽤:public interface StudentService {public boolean login(String username,String password);}@Servicepublic class StudentServiceImpl implements StudentService {@Overridepublic boolean login(String username,String password) {if("crush".equals(username)&&"123456".equals(password)){System.out.println("登录成功");return true;}return false;}}@Controllerpublic class StudentController {@Autowiredprivate StudentService studentService;public void login(){boolean crush = studentService.login("crush", "123456");if(crush){System.out.println("crush"+"登录成功");}else{System.out.println("登录失败");}}}测试:@Testpublic void login(){ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");StudentController student = applicationContext.getBean("studentController", StudentController.class);student.login();}我们在使⽤@Autowired 之后不⽤再去xml⽂件中继续配置了。
Spring中的注解@Autowired实现过程全解(@Autowired背后的故事)
Spring中的注解@Autowired实现过程全解(@Autowired背后的故事)现在⾯试,基本上都是⾯试造⽕箭 ,⼯作拧螺丝 。
⽽且是喜欢问⼀些 Spring 相关的知识点,⽐如之间的区别。
魔⾼⼀丈,道⾼⼀尺。
很快不少程序员学会了背诵⾯试题,那我反过来问“Spring 中的注解 @Autowired是如何实现的?”,“说说 @Autowired 的实现原理?”等等,背诵⾯试题的就露馅了。
基于此,今天我们来说⼀说 @Autowired 背后的故事!前⾔使⽤ Spring 开发时,进⾏配置主要有两种⽅式,⼀是 xml 的⽅式,⼆是 Java config 的⽅式。
Spring 技术⾃⾝也在不断的发展和改变,从当前的⽕热程度来看,Java config 的应⽤是越来越⼴泛了,在使⽤ Java config 的过程当中,我们不可避免的会有各种各样的注解打交道,其中,我们使⽤最多的注解应该就是 @Autowired 注解了。
这个注解的功能就是为我们注⼊⼀个定义好的 bean。
那么,这个注解除了我们常⽤的属性注⼊⽅式之外还有哪些使⽤⽅式呢?它在代码层⾯⼜是怎么实现的呢?这是本篇⽂章着重想讨论的问题。
@Autowired 注解⽤法在分析这个注解的实现原理之前,我们不妨先来回顾⼀下 @Autowired 注解的⽤法。
将 @Autowired 注解应⽤于构造函数,如以下⽰例所⽰`public class MovieRecommender {``private final CustomerPreferenceDao customerPreferenceDao;``@Autowired``public MovieRecommender(CustomerPreferenceDao customerPreferenceDao) {``this.customerPreferenceDao = customerPreferenceDao;``}``// ...``}`将 @Autowired 注释应⽤于 setter ⽅法`public class SimpleMovieLister {``private MovieFinder movieFinder;``@Autowired``public void setMovieFinder(MovieFinder movieFinder) {``this.movieFinder = movieFinder;``}``// ...``}`将 @Autowired 注释应⽤于具有任意名称和多个参数的⽅法`public class MovieRecommender {``private MovieCatalog movieCatalog;``private CustomerPreferenceDao customerPreferenceDao;``@Autowired``public void prepare(MovieCatalog movieCatalog,``CustomerPreferenceDao customerPreferenceDao) {``this.movieCatalog = movieCatalog;``this.customerPreferenceDao = customerPreferenceDao;``}``// ...``}`您也可以将 @Autowired 应⽤于字段,或者将其与构造函数混合,如以下⽰例所⽰`public class MovieRecommender {``private final CustomerPreferenceDao customerPreferenceDao;``@Autowired``private MovieCatalog movieCatalog;``@Autowired``public MovieRecommender(CustomerPreferenceDao customerPreferenceDao) {``this.customerPreferenceDao = customerPreferenceDao;``}``// ...``}`直接应⽤于字段是我们使⽤的最多的⼀种⽅式,但是使⽤构造⽅法注⼊从代码层⾯却是更加好的,具体原因我就不细说了,有不懂的可以留⾔区评论。
Spring5:@Autowired注解、@Resource注解和@Service注解
Spring5:@Autowired注解、@Resource注解和@Service注解什么是注解传统的Spring做法是使⽤.xml⽂件来对bean进⾏注⼊或者是配置aop、事物,这么做有两个缺点:1、如果所有的内容都配置在.xml⽂件中,那么.xml⽂件将会⼗分庞⼤;如果按需求分开.xml⽂件,那么.xml⽂件⼜会⾮常多。
总之这将导致配置⽂件的可读性与可维护性变得很低2、在开发中在.java⽂件和.xml⽂件之间不断切换,是⼀件⿇烦的事,同时这种思维上的不连贯也会降低开发的效率为了解决这两个问题,Spring引⼊了注解,通过"@XXX"的⽅式,让注解与Java Bean紧密结合,既⼤⼤减少了配置⽂件的体积,⼜增加了Java Bean的可读性与内聚性。
本篇⽂章,讲讲最重要的三个Spring注解,也就是@Autowired、@Resource和@Service,希望能通过有限的篇幅说清楚这三个注解的⽤法。
不使⽤注解先看⼀个不使⽤注解的Spring⽰例,在这个⽰例的基础上,改成注解版本的,这样也能看出使⽤与不使⽤注解之间的区别,先定义⼀个⽼虎:public class Tiger{private String tigerName = "TigerKing";public String toString(){return "TigerName:" + tigerName;}}再定义⼀个猴⼦:public class Monkey{private String monkeyName = "MonkeyKing";public String toString(){return "MonkeyName:" + monkeyName;}}定义⼀个动物园:public class Zoo{private Tiger tiger;private Monkey monkey;public void setTiger(Tiger tiger){this.tiger = tiger;}public void setMonkey(Monkey monkey){this.monkey = monkey;}public Tiger getTiger(){return tiger;}public Monkey getMonkey(){return monkey;}public String toString(){return tiger + "\n" + monkey;}}spring的配置⽂件这么写:<?xml version="1.0" encoding="UTF-8"?><beans xmlns:xsi="/2001/XMLSchema-instance"xmlns="/schema/beans"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-4.2.xsd/schema/context/schema/context/spring-context-4.2.xsd"default-autowire="byType"><bean id="zoo" class="com.xrq.bean.Zoo"><property name="tiger" ref="tiger"/><property name="monkey" ref="monkey"/></bean><bean id="tiger" class="com.xrq.domain.Tiger"/><bean id="monkey" class="com.xrq.domain.Monkey"/></beans>都很熟悉,权当复习⼀遍了。
Spring之自动装配及注解(三)
Spring之⾃动装配及注解(三)Spring 之⾃动装配及注解(三)⼀、DI依赖注⼊构造器注⼊Set注⼊依赖注⼊!Set注⼊⽅式依赖:bean对象依赖Spring容器注⼊:bean对象的所有属性,由容器来注⼊!【环境配置】导⼊Spring官⽅配置<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beanshttps:///schema/beans/spring-beans.xsd"></beans>1、【简单类型注⼊】eg:Stringpublic class Address {private String address;//getter and setter ⽅法。
//toString()⽅法}public class Student {private String name;//getter and setter ⽅法。
//toString()⽅法}Test测试类public class MyTest {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");//Student student = (Student) context.getBean("student");/*应⽤反射则不⽤强制转换*/Student student = context.getBean("student", Student.class);System.out.println(student.toString());}}beans.xml<bean id="student" class="com.study.dao.Student"><!--第⼀种普通值注⼊--><property name="name" value="yyb"></property></bean>输出:yyb2、【复杂类型的注⼊】在原有的Student类上添加其他类型的属性public class Student {private String name;private Address address;private String[] books;private List<String> hobbys;private Map<String,String> card;private Set<String> games;private String wife;private Properties info;//getter and setter ⽅法。
Spring@Autowired注解与自动装配
@Autowired可以对成员变量、方法和构造函数进行标注,来完成自动装配的工作,这里必须明确:@Autowired是根据类型进行自动装配的,如果需要按名称进行装配,则需要配合@Qualifier使用;@Autowired可以对成员变量进行标注1.package com.baobaotao;2.import org.springframework.beans.factory.annotation.Autowired;3.public class Boss {4.@Autowired5.private Car car;6.@Autowired7.private Office office;8.…9.}在applicationContext.xml中把原来引用的<property >标签也去掉。
1.<?xml version="1.0" encoding="UTF-8" ?>2.<beans xmlns="/schema/beans"3.xmlns:xsi="/2001/XMLSchema-instance"4.xsi:schemaLocation="/schema/beans5./schema/beans/spring-beans-2.5.xsd">6.<!-- 该 BeanPostProcessor 将自动起作用,对标注 @Autowired 的Bean 进行自动注入 -->7.<bean class="org.springframework.beans.factory.annotation.8.AutowiredAnnotationBeanPostProcessor"/>9.<!-- 移除 boss Bean 的属性注入配置的信息 -->10.<bean id="boss" class="com.baobaotao.Boss"/>11.<bean id="office" class="com.baobaotao.Office">12.<property name="officeNo" value="001"/>13.</bean>14.<bean id="car" class="com.baobaotao.Car" scope="singleton">15.<property name="brand" value=" 红旗 CA72"/>16.<property name="price" value="2000"/>17.</bean>18.</beans>这样,当 Spring 容器启动时,AutowiredAnnotationBeanPostProcessor 将扫描 Spring 容器中所有 Bean,当发现 Bean 中拥有 @Autowired 注释时就找到和其匹配(默认按类型匹配)的 Bean,并注入到对应的地方中去。
autowired和resource注解的使用场景
autowired和resource注解的使用场景全文共四篇示例,供读者参考第一篇示例:在Spring框架中,Autowired和Resource注解是两个常用的注解,用于实现依赖注入,帮助我们更方便地管理对象之间的依赖关系。
在实际开发中,我们经常会遇到需要使用这两个注解的情况,下面我们就来一起探讨它们的使用场景。
1. Autowired注解的使用场景Autowired注解是Spring框架中最常用的注解之一,它可以自动装配bean对象,省去了手动配置bean的繁琐工作。
Autowired注解主要有以下几种使用场景:(1)自动装配依赖关系Autowired注解可以在构造器、属性、方法、方法参数上使用,Spring会自动根据类型来查找对应的bean进行注入。
这样可以减少手动装配bean的操作,提高代码的简洁性和可维护性。
(2)解决循环依赖问题在某些情况下,两个或多个bean之间存在循环依赖关系,无法直接注入。
Autowired注解可以解决这个问题,Spring会创建一个代理对象来解决循环依赖的情况,确保bean之间的依赖关系正确注入。
(3)指定特定的实现类在一个接口有多个实现类的情况下,可以使用Autowired注解结合Qualifier注解来指定要注入的具体实现类。
这样可以避免由于自动装配而造成的歧义。
(4)注入内部beanAutowired注解还可以用于注入内部bean,即在XML配置文件中定义的bean作为其他bean的属性注入。
2. Resource注解的使用场景Resource注解也是实现依赖注入的一种方式,与Autowired注解不同的是,Resource注解是按照名称来自动注入依赖对象。
Resource注解的使用场景如下:(1)按名称自动注入Resource注解可以根据bean的名称来自动注入依赖对象。
在XML配置文件或Java类中指定bean的名称,Resource注解会根据名称来匹配对应的bean进行注入。
autowired注解的使用
autowired注解的使用(最新版)目录1.Autowired 注解的概述2.Autowired 注解的使用方法3.Autowired 注解的优点与局限性正文【Autowired 注解的概述】Autowired 注解是 Spring 框架中的一种注解,用于实现自动装配(Dependency Injection,简称 DI)功能。
通过 Autowired 注解,可以实现类与类之间的依赖关系,使得 Spring 容器能够自动地为类的属性注入合适的值。
在 Spring 中,Autowired 注解主要用于自动装配 bean,使得开发者无需手动实例化 bean,从而降低了开发难度。
【Autowired 注解的使用方法】Autowired 注解可以用于以下三种情况:1.构造函数注入在构造函数上添加 Autowired 注解,并传入需要注入的 bean 名称。
例如:```java@Servicepublic class UserService {@Autowiredprivate UserDao userDao;```2.属性注入在类的属性上添加 Autowired 注解,并传入需要注入的 bean 名称。
例如:```java@Servicepublic class UserService {@Autowiredprivate UserDao userDao;}```3.构造函数参数注入在构造函数参数上添加 Autowired 注解,并传入需要注入的 bean 名称。
例如:```java@Servicepublic class UserService {private final UserDao userDao;@Autowiredpublic UserService(UserDao userDao) {erDao = userDao;}```【Autowired 注解的优点与局限性】Autowired 注解的优点:1.简化了开发过程,无需手动实例化 bean。
Spring的自动装配→骚话@Autowired的底层工作原理
Spring的⾃动装配→骚话@Autowired的底层⼯作原理开⼼⼀刻 ⼗年前,我:我交⼥票了,⽐我⼤两岁 妈:不⾏!赶紧分! ⼋年前,我:我交⼥票了,⽐我⼩两岁,外地的 妈:你就不能让我省点⼼? 五年前,我:我交⼥票了,市长的⼥⼉ 妈:别⼈还能看上你?分了吧! 今年,我挺着⼤肚⼦踏进家门 妈:闺⼥啊,你终于开窍了 !前情回顾 中讲到了 Spring 对 BeanPostProcessor 的底层⽀持 并且知道了 BeanPostProcessor 的两个⽅法:postProcessBeforeInitialization、postProcessAfterInitialization 的执⾏时机 没看的⼩伙伴赶紧先去看看 本来 Spring 的⾃动装配是打算放到上⼀篇博⽂中详细讲解的,可后来觉得篇幅可能太⼤了你们:信了你个⿁,除了⼏幅图,有啥内容? 既然你们都感觉出来了,那我也就明⼈不说暗话了,之所以没放到上篇讲解,确实是因为篇幅太⼤了楼主:哈哈哈,是不是很想打我?你过来啊! 好了,我们⾔归正传,之所以没放到上篇来讲,篇幅只是原因之⼀,最主要的原因是发现我犯错了!犯什么错了呢楼主:不是黄赌毒啊,那是犯罪,我是正⼈君⼦! 我想当然了!理所当然的认为⾃动装配是在 AutowiredAnnotationBeanPostProcessor 的 postProcessBeforeInitialization 或 postProcessAfterInitialization 中实现的 我们来看下 AutowiredAnnotationBeanPostProcessor 类继承图 它间接实现了 BeanPostProcessor,我们再去看下那两个⽅法(在⽗类 InstantiationAwareBeanPostProcessorAdapter 中)@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {return bean;}@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {return bean;}View Code Oh My God ,竟然啥也没⼲,只是简单的 return bean楼主:我⼼态崩了 当⾃⼰深以为然的认知被推翻时,那感觉真是毙了狗了萨摩耶:关我什么事 所以⾃动装配不能和 BeanPostProcessor 放⼀块讲,不得不开两篇来分开讲,我们都知道:强扭的⽠不甜!⾃动装配简单⽰例 我们先来看⼀个简单的⾃动装配的⽰例,完整实例代码: AnimalConfigpackage com.lee.app.configuration;import com.lee.app.entity.Cat;import com.lee.app.entity.Dog;import com.lee.app.entity.Pig;import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configurationpublic class AnimalConfig {public AnimalConfig() {System.out.println("AnimalConfig 实例化");}@Beanpublic Dog dog() {return new Dog("⼩七");}@Beanpublic Cat cat() {return new Cat("Tom");}@Beanpublic Pig pig() {return new Pig("佩奇");}}View Code AnimalServiceImpl@Servicepublic class AnimalServiceImpl implements IAnimalService { @Autowiredprivate Dog dog;@Resourceprivate Cat cat;@Injectprivate Pig pig;@Overridepublic void printName() {System.out.println(dog.getName());System.out.println(cat.getName());System.out.println(pig.getName());}}View Code AnimalTest@RunWith(SpringRunner.class)@SpringBootTest(classes={Application.class})public class AnimalTest {@Autowiredprivate IAnimalService animalService;@Testpublic void test() {animalService.printName();}}View Code 运⾏结果 我们在 AnimalConfig 中只是将 Dog、Cat、Pig 的实例注册到了 Spring 容器,那为什么 AnimalServiceImpl 实例能够直接应⽤这些实例了,我们并没有⼿动的将这些实例赋值到 AnimalServiceImpl 实例呀? 这其实就是Spring 提供的⾃动装配功能,虽然我们没有⼿动的将这些实例赋值到AnimalServiceImpl 实例,但是我们发现AnimalServiceImpl 的属性上多了⼀些注解:@Autowired、@Resource、@Inject Spring 通过这些注解⾃动完成了属性的注⼊,⽽不需要我们⼿动的去赋值了 那么 Spring 是如何实现⾃动装配的呢?我们慢慢往下看(注意:后⽂主要以 @Autowired 为例来讲解)⾃动装配源码解析 不管怎么说,AutowiredAnnotationBeanPostProcessor 终归还是⼀个 BeanPostProcessor,那么它的实例化与注册(注册到 Spring 的 beanFactory)过程与⼀样 在spring的启动过程中,刷新上下⽂(refresh)的时候,会调⽤ registerBeanPostProcessors(beanFactory)⽅法完成 BeanPostProcessor 的实例化与注册 后续再调⽤ finishBeanFactoryInitialization(beanFactory)实例化⾮延迟加载的单例 bean 时,会⽤到上述注册的 BeanPostProcessor AutowiredAnnotationBeanPostProcessor 的构造⽅法值得我们看看public AutowiredAnnotationBeanPostProcessor() {this.autowiredAnnotationTypes.add(Autowired.class);this.autowiredAnnotationTypes.add(Value.class);try {this.autowiredAnnotationTypes.add((Class<? extends Annotation>)ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");}catch (ClassNotFoundException ex) {// JSR-330 API not available - simply skip.}}View Code 默认情况下,AutowiredAnnotationBeanPostProcessor ⽀持@Autowired 和@Value,如果类路径下有java.inject.Inject (也就是引⼊了javax.inject.jar),那么也⽀持@Inject 注解,是不是与我们最初的认知有些不⼀样? 将⽀持的注解放到了autowiredAnnotationTypes 属性中,后续会⽤到该属性 默认情况下,Spring 会把 Spring 容器中的 bean 当成 non-lazy-init singleton 来处理(有些特殊的 bean 除外) 也就是说会在Spring 的启动过程中就会逐个实例化这些 bean,并对这些 bean 进⾏依赖注⼊ 当我们真正⽤到这些 bean 的时候,直接⽤就⾏,不⽤再去实例化,也不⽤再去注⼊ bean 的相关依赖,Spring是不是很厉害? 具体是不是说的这样,⼤家准备好花⽣、⽠⼦和啤酒,好戏即将开始 我们先找到正确的⼊⼝,然后省略掉⽆聊的前戏,直接进⼊⾼潮 ⼤家先把思想收⼀收,该醒醒了 应该是 doCreateBean doCreateBean 内容如下protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)throws BeanCreationException {// Instantiate the bean.BeanWrapper instanceWrapper = null;if (mbd.isSingleton()) {instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);}}if (instanceWrapper == null) {// 创建bean实例instanceWrapper = createBeanInstance(beanName, mbd, args);}final Object bean = instanceWrapper.getWrappedInstance();Class<?> beanType = instanceWrapper.getWrappedClass();if (beanType != NullBean.class) {mbd.resolvedTargetType = beanType;}// Allow post-processors to modify the merged bean definition.// 允许后置处理器来修改bean定义synchronized (mbd.postProcessingLock) {if (!mbd.postProcessed) {try {// 调⽤MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition⽅法// AutowiredAnnotationBeanPostProcessor实现了MergedBeanDefinitionPostProcessor,即MergedBeanDefinitionPostProcessor的MergedBeanDefinitionPostProcesso applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);}catch (Throwable ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Post-processing of merged bean definition failed", ex);}mbd.postProcessed = true;}}// Eagerly cache singletons to be able to resolve circular references ⽴即缓存单例以便能够解析循环引⽤// even when triggered by lifecycle interfaces like BeanFactoryAware.boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));if (earlySingletonExposure) {if (logger.isDebugEnabled()) {logger.debug("Eagerly caching bean '" + beanName +"' to allow for resolving potential circular references");}addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));}// Initialize the bean instance.Object exposedObject = bean;try {// 填充bean,包含依赖注⼊populateBean(beanName, mbd, instanceWrapper);// 初始化bean,BeanPostProcessor的两个⽅法在此中被调⽤exposedObject = initializeBean(beanName, exposedObject, mbd);}catch (Throwable ex) {if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {throw (BeanCreationException) ex;}else {throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);}}if (earlySingletonExposure) {Object earlySingletonReference = getSingleton(beanName, false);if (earlySingletonReference != null) {if (exposedObject == bean) {exposedObject = earlySingletonReference;}else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {String[] dependentBeans = getDependentBeans(beanName);Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);for (String dependentBean : dependentBeans) {if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {actualDependentBeans.add(dependentBean);}}if (!actualDependentBeans.isEmpty()) {throw new BeanCurrentlyInCreationException(beanName,"Bean with name '" + beanName + "' has been injected into other beans [" +StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +"] in its raw version as part of a circular reference, but has eventually been " +"wrapped. This means that said other beans do not use the final version of the " +"bean. This is often the result of over-eager type matching - consider using " +"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");}}}}// Register bean as disposable.try {registerDisposableBeanIfNecessary(beanName, bean, mbd);}catch (BeanDefinitionValidationException ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);}return exposedObject;}View Code 我们重点看下 posProcessMergedBeanDefinition ⽅法和 populateBean ⽅法 可以看到会读取 bean 的 field 和 method 上的注解,并判断该注解是否在 autowiredAnnotationTypes 中 如果在则将 field 封装成 AutowiredFiledElement 对象、将 method 封装成 AutoWiredMethodElement 对象,并存放到 InjectionMetadata 对象的 Set<InjectedElement> checkedElements 属性中 最后将该 InjectionMetadata 对象缓存到了 AutowiredAnnotationBeanPostProcessor 的 Map<String, InjectionMetadata> injectionMetadataCache 属性中 说⽩了就是将 bean中被 @Autowried(当然还包括 @Value、@Inject)修饰的 field、method 找出来,封装成 InjectionMetadata 对象并缓存起来,就这么简单 不仅仅是上图中的 animalServiceImpl 这⼀个 bean,Spring 中所有的⾮延迟加载的 bean 都会⾛这个创建流程 是不是很简单,是不是⼲劲⼗⾜了 调⽤ AutowiredAnnotationBeanPostProcessor 的 postProcessPropertyValues ⽅法,从 injectionMetadataCache 中获取当前 bean 的依赖信息 ⽐如animalServiceImpl 依赖的dog、pig(有⼈可能会有这样的疑问:cat 呢?cat 是被@Resource 修饰的,⽽@Resource 不是由AutowiredAnnotationBeanPostProcessor ⽀持,后续会讲由谁⽀持) 然后逐个将依赖 bean 注⼊到⽬标 bean(将 dog、pig 实例注⼊到 animalServiceImpl 实例中) 依赖 bean 从哪来呢?还是从 beanFactory 中获取,如果不存在,则⼜回到 bean 的创建过程把依赖 bean(dog、pig)创建出来,流程与创建 animalServiceImpl 实例⼀模⼀样 也就说在 animalServiceImpl 实例的依赖注⼊过程中会把 dog、pig 对象也创建出来,⽽不是等到 Spring 逐个实例化 bean 的过程中轮到 dog、pig 才实例化 dog、pig 那后续轮到 dog、pig 时怎么办了,Spring 会把创建的 bean 缓存起来,下次就直接从缓存中取了 上图只演⽰ Field 的,Method 也差不太多,就不演⽰了,都是通过反射实现的总结 1、bean的创建与初始化 (1)instanceWrapper = createBeanInstance(beanName, mbd, args) 创建⽬标bean实例; (2)applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName) 寻找⽬标bean的依赖; (3)populateBean(beanName, mbd, instanceWrapper) 填充⽬标bean,完成依赖注⼊;(这⾥的循环依赖,有兴趣的可以⾃⾏去琢磨下) (4)initializeBean(beanName, exposedObject, mbd) 初始化⽬标bean 2、⾃动装配与⾃动配置 ⾃动配置⼀般⽽⾔说的是spring的@Autowired,是spring的特性之⼀,⽽⾃动配置是springboot的@Configuration,是springboot的特性之⼀ 3、Spring⽀持⼏下⼏种⾃动装配的注解 @Autowired、@Inject、@Resource以及@Value,⽤的最多的应该是@Autowired(⾄少我是这样的) @Inject 和@Value 也是由AutowiredAnnotationBeanPostProcessor ⽀持,⽽@Resource 是由CommonAnnotationBeanPostProcessor ⽀持(还⽀持@PostConstruct、@PreDestroy 等注解) 关于 @Value 与 @Autowired,不知道⼤家是否清楚他们之间的区别,不清楚的可以看看:或者 Spring 的官⽅⽂档 总结下:@Value >= @Autowired,只是平时应⽤中,@Value 更多的是⽤来注⼊配置值(如:@Value("${db.url}")),⽽ @Autowired 则是 bean 对象的注⼊参考。
五、Spring之自动装配
五、Spring之⾃动装配Spring之⾃动装配Spring利⽤依赖注⼊(DI),完成对IOC容器中各个组件依赖关系的赋值。
【1】@Autowired@Autowired 注解,它可以对类成员变量、⽅法及构造函数进⾏标注,完成⾃动装配的⼯作。
通过 @Autowired的使⽤来消除 set ,get⽅法。
在使⽤@Autowired之前,我们对⼀个bean配置其属性时,是这样做的:<property name="属性名" value="属性值"/>通过这种⽅式来,配置⽐较繁琐,⽽且代码⽐较多。
在Spring 2.5 引⼊了 @Autowired 注解。
由于该注解⽐较简单,这⾥就不再⽤代码举例说明了,主要来说⼀下@Autowired的原理和使⽤它的注意事项。
那么使⽤@Autowired的原理是什么?其实在启动Spring容器时,容器⾃动装载了⼀个AutowiredAnnotationBeanPostProcessor后置处理器,当容器扫描到@Autowied、@Resource或@Inject时,就会在IOC容器⾃动查找需要的bean,并装配给该对象的属性。
这⾥说明⼀下@Resource和@Inject这两个注解:@Resource是通过JSR250规范实现的,通过CommonAnnotationBeanPostProcessor类实现依赖注⼊@Inject是通过JSR330规范实现的,通过AutowiredAnnotationBeanPostProcessor类实现的依赖注⼊三个注解的相异之处:@Autowired和@Inject基本是⼀样的,因为两者都是使⽤AutowiredAnnotationBeanPostProcessor来处理依赖注⼊。
但是@Resource是个例外,它使⽤的是CommonAnnotationBeanPostProcessor来处理依赖注⼊。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
@Autowired可以对成员变量、方法和构造函数进行标注,来完成自动装配的工作,这里必须明确:@Autowired是根据类型进行自动装配的,如果需要按名称进行装配,则需要配合@Qualifier使用;
@Autowired可以对成员变量进行标注
1.package com.baobaotao;
2.import org.springframework.beans.factory.annotation.Autowired;
3.public class Boss {
4.@Autowired
5.private Car car;
6.@Autowired
7.private Office office;
8.…
9.}
在applicationContext.xml中把原来引用的<property >标签也去掉。
1.<?xml version="1.0" encoding="UTF-8" ?>
2.<beans xmlns="/schema/beans"
3.xmlns:xsi="/2001/XMLSchema-instance"
4.xsi:schemaLocation="/schema/beans
5./schema/beans/spring-beans-
2.5.xsd">
6.<!-- 该 BeanPostProcessor 将自动起作用,对标注 @Autowired 的
Bean 进行自动注入 -->
7.<bean class="org.springframework.beans.factory.annotation.
8.AutowiredAnnotationBeanPostProcessor"/>
9.<!-- 移除 boss Bean 的属性注入配置的信息 -->
10.<bean id="boss" class="com.baobaotao.Boss"/>
11.<bean id="office" class="com.baobaotao.Office">
12.<property name="officeNo" value="001"/>
13.</bean>
14.<bean id="car" class="com.baobaotao.Car" scope="singleton">
15.<property name="brand" value=" 红旗 CA72"/>
16.<property name="price" value="2000"/>
17.</bean>
18.</beans>
这样,当 Spring 容器启动时,AutowiredAnnotationBeanPostProcessor 将扫描 Spring 容器中所有 Bean,当发现 Bean 中拥有 @Autowired 注释时就找到和其匹配(默认按
类型匹配)的 Bean,并注入到对应的地方中去。
按照上面的配置,Spring 将直接采用 Java 反射机制对 Boss 中的 car 和 office 这两个私有成员变量进行自动注入。
所以对成员变量使用 @Autowired 后,您大可将它们的 setter 方法(setCar() 和 setOffice())从 Boss 中删除。
@Autowired可以对方法或构造函数进行标注
1.package com.baobaotao;
2.public class Boss {
3.private Car car;
4.private Office office;
5.@Autowired
6.public void setCar(Car car) {
7.this.car = car;
8.}
9.@Autowired
10.public void setOffice(Office office) {
11.this.office = office;
12.}
13.…
14.}
这时,@Autowired 将查找被标注的方法的入参类型的 Bean,并调用方法自动注入这些 Bean。
而下面的使用方法则对构造函数进行标注:
[java] view plain copyprint?
1.package com.baobaotao;
2.public class Boss {
3.private Car car;
4.private Office office;
5.@Autowired
6.public Boss(Car car ,Office office){
7.this.car = car;
8.this.office = office ;
9.}
10.…
11.}
由于 Boss() 构造函数有两个入参,分别是 car 和 office,@Autowired 将分别寻找和它们类型匹配的 Bean,将它们作为 Boss(Car car ,Office office) 的入参来创建 Boss Bean。