你的位置:首页 > Java教程

[Java教程]Spring之IoC总结帖


  Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构,分层架构允许使用者选择使用哪一个组件,同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言,任何Java应用都可以从Spring中受益。Spring的核心是控制反转(IoC)和面向切面(AOP)。简单来说,Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。

  一般在Web应用中引入Spring的程序框架流程如下所示:

Spring模块框架图一览:

  关于IoC更详细资料请点击:Spring学习之第一个hello world程序,IoC为控制反转,也成为DI(依赖注入),为Spring的核心模块,另一个是AOP。

1 Spring中的Bean配置

1.1 IOC和DI

  • IOC(Inversion of Control):其思想是反转资源获取的方向. 传统的资源查找方式要求组件向容器发起请求查找资源. 作为回应, 容器适时的返回资源. 而应用了 IOC 之后, 则是容器主动地将资源推送给它所管理的组件, 组件所要做的仅是选择一种合适的方式来接受资源. 这种行为也被称为查找的被动形式
  • DI(Dependency Injection) — IOC 的另一种表述方式:即组件以一些预先定义好的方式(例如: setter 方法)接受来自如容器的资源注入. 相对于 IOC 而言,这种表述更直接

1.2 Spring容器

  在Spring IoC容器读取Bean配置创建Bean实例之前,必须对其实例化,只有在容器实例化后,才可以从IOC中获取Bean实例并使用它。

Spring提供了2种类型的IOC容器实现:

  • BeanFactory: IoC容器的基本实现
  • ApplicationContext: 提供了更多的高级功能,是BeanFactory的实现类

  BeanFactory是Spring框架的基石,主要被Spring自身程序调用;而ApplicationContext主要面向使用Spring的程序员,几乎所有的场合都可以直接使用ApplicationContext而非底层的BeanFactory。无论使用哪种方式,它们的配置文件是相同的。

如何在IOC容器中配置Bean?

  在

<bean id="msg" >  <constructor-arg value="string"/></bean>

  id表示Bean名称,在IOC容器中需是唯一的,若id未指定,Spring自动将授权限定性名作为Bean的名字,若上图中Bean配置未设定id,则getBean()使用名字"java.lang.String"。id可以指定多个名字,名字之间可用逗号、分号、空号分割。

如何获取IOC容器中的Bean?

  从IOC容器中获取Bean实例有如下方法:

1.3 ApplicationContext

  ApplicationContext 的主要实现类有ClassPath

  ConfigurableApplicationContext 扩展于 ApplicationContext,新增加两个主要方法:refresh() 和 close(), 让 ApplicationContext 具有启动、刷新和关闭上下文的能力。

  WebApplicationContext 是专门为 WEB 应用而准备的,它允许从相对于 WEB 根目录的路径中完成初始化工作。

1.4 依赖注入的方式

  Spring支持3种依赖注入的方式:

  • 属性注入
  • 构造器注入
  • 工厂方法注入(较少使用,不推荐)

属性注入

  属性注入即通过 setter 方法注入Bean 的属性值或依赖的对象,使用 <property> 元素, 使用 name 属性指定 Bean 的属性名称,value 属性或 <value> 子节点指定属性值,属性注入是实际应用中最常用的注入方式。属性注入Bean类须有一个默认的构造方法。

<!-- Hello类中有一个String类型的msg属性 --><bean id="hello" class="com.luoxn28.Hello">  <property name="msg" value="luoxn28"/></bean>

构造方法注入

  通过构造方法注入Bean 的属性值或依赖的对象,它保证了 Bean 实例在实例化后就可以使用,构造器注入在 <constructor-arg> 元素里声明属性。

<bean id="msg" class="java.lang.String">  <constructor-arg value="string"/></bean>

<!-- 按照索引匹配入参 --><bean id="car" class="com.luoxn28.Car">  <constructor-arg value="比亚迪" index="0"/>  <constructor-arg value="中国制造" index="1"/>  <constructor-arg value="200000" index="2"/></bean><!-- 按照类型匹配入参 --><bean id="car2" class="com.luoxn28.Car">  <constructor-arg value="比亚迪" type="java.lang.String">  <constructor-arg value="中国制造" type="java.lang.String"/>  <constructor-arg value="200000" type="double"/></bean>

1.4 引用Bean

引用其他Bean

  组成应用程序的 Bean 经常需要相互协作以完成应用程序的功能。要使 Bean 能够相互访问,就必须在 Bean 配置文件中指定对 Bean 的引用,在 Bean 的配置文件中,可以通过 <ref> 元素或 ref 属性为 Bean 的属性或构造器参数指定对 Bean 的引用。也可以在属性或构造器里包含 Bean 的声明, 这样的 Bean 称为内部 Bean。

<bean id="msg" class="java.lang.String">  <constructor-arg value="luoxn28"/></bean><!-- Hello类中有一个String类型的msg属性 --><bean id="hello" class="com.luoxn28.Hello">  <property name="msg" ref="msg"/></bean>

内部Bean

  当 Bean 实例仅仅给一个特定的属性使用时,可以将其声明为内部 Bean,内部 Bean 声明直接包含在 <property> 或 <constructor-arg> 元素里,不需要设置任何 id 或 name 属性。内部 Bean 不能使用在任何其他地方。

<!-- Hello类中有一个String类型的msg属性 --><bean id="hello" class="com.luoxn28.Hello">  <property name="msg">    <bean class="java.lang.String">      <constructor-arg value="luoxn28"/>    </bean>  </property></bean>

1.5 属性集合

  • 在 Spring中可以通过一组内置的
  • 配置 java.util.List 类型的属性, 需要指定 <list> 标签, 在标签里包含一些元素. 这些标签可以通过 <value> 指定简单的常量值, 通过 <ref> 指定对其他 Bean 的引用. 通过<bean> 指定内置 Bean 定义. 通过 <null/> 指定空元素. 甚至可以内嵌其他集合。
  • 数组的定义和 List 一样, 都使用 <list>
  • 配置 java.util.Set 需要使用 <set> 标签, 定义元素的方法与 List 一样.
  • Java.util.Map 通过 <map> 标签定义, <map> 标签里可以使用多个 <entry> 作为子标签. 每个条目包含一个键和一个值. 必须在 <key> 标签里定义键。因为键和值的类型没有限制, 所以可以自由地为它们指定 <value>, <ref>, <bean> 或 <null> 元素. 可以将 Map 的键和值作为 <entry> 的属性定义: 简单常量使用 key 和 value 来定义; Bean 引用通过 key-ref 和 value-ref 属性定义。

  • 使用 <props> 定义 java.util.Properties, 该标签使用多个 <prop> 作为子标签. 每个 <prop> 标签必须定义 key 属性。

<!-- CollectionClass类有3个属性,List<String> list、Set<String> set、Map<String, String> map--><bean id="collectionClass" class="com.luoxn28.CollectionClass">  <property name="list">    <list>      <value>luoxn28</value>      <value>luoxn29</value>      <value>luoxn30</value>    </list>  </property>  <property name="set">    <set>      <value>luoxn28</value>      <value>luoxn29</value>      <value>luoxn30</value>    </set>  </property>  <property name="map">    <map>      <entry key="str1" value="luoxn28"/>      <entry key="str2"><value>luoxn29</value></entry>      <entry key="str3"><value>luoxn30</value></entry>    </map>  </property></bean>

1.6 使用p命名空间

  为了简化

<bean id="msg" class="java.lang.String">  <constructor-arg value="luoxn28"/></bean><!-- Hello类中有一个String类型的msg属性 --><bean id="hello" class="com.luoxn28.Hello" p:msg="luoxn28"></bean><bean id="hello1" class="com.luoxn28.Hello" p:msg-ref="msg"></bean>

  使用p命名空间需要引入 

 

2  Bean配置高级特性

2.1

  Spring IOC 容器可以自动装配 Bean. 需要做的仅仅是在 <bean> 的 autowire 属性里指定自动装配的模式

  • byType(根据类型自动装配): 若 IOC 容器中有多个与目标 Bean 类型一致的 Bean. 在这种情况下, Spring 将无法判定哪个 Bean 最合适该属性, 所以不能执行自动装配.
  • byName(根据名称自动装配): 必须将目标 Bean 的名称和属性名设置的完全相同.
  • constructor(通过构造器自动装配): 当 Bean 中存在多个构造器时, 此种自动装配方式将会很复杂. 不推荐使用

  注意:自动装配中如果被注入对象如果是Java基本类型的话,自动注入是不成功的,自定义的类是没问题的,如下所示。具体为什么我也不知道,还请知道原因的小伙伴在评论中告知我,谢谢^_^。

<!-- 这里为什么不会自动注入msg呢 --><bean id="hello" class="com.luoxn28.Hello" autowire="byName"></bean><bean id="msg" class="java.lang.String">  <constructor-arg value="110"/></bean>

  • 在 Bean 配置文件里设置 autowire 属性进行自动装配将会装配 Bean 的所有属性. 然而, 若只希望装配个别属性时, autowire 属性就不够灵活了.
  • autowire 属性要么根据类型自动装配, 要么根据名称自动装配, 不能两者兼而有之.
  • 一般情况下,在实际的项目中很少使用自动装配功能,因为和自动装配功能所带来的好处比起来,明确清晰的配置文档更有说服力一些

2.2 继承Bean配置

  • Spring 允许继承 bean 的配置, 被继承的 bean 称为父 bean. 继承这个父 Bean 的 Bean 称为子 Bean
  • 子 Bean 从父 Bean 中继承配置, 包括 Bean 的属性配置
  • 子 Bean 也可以覆盖从父 Bean 继承过来的配置
  • 父 Bean 可以作为配置模板, 也可以作为 Bean 实例. 若只想把父 Bean 作为模板, 可以设置 <bean> 的abstract 属性为 true, 这样 Spring 将不会实例化这个 Bean
  • 并不是 <bean> 元素里的所有属性都会被继承. 比如: autowire, abstract 等.
  • 也可以忽略父 Bean 的 class 属性, 让子 Bean 指定自己的类, 而共享相同的属性配置. 但此时 abstract 必须设为 true
<bean id="person" class="com.luoxn28.Person" p:name="luoxn28" p:age="23"></bean><!-- 这里使用到了bean配置的继承,指定属性继承哪个bean。配置注意:bean的继承和类之间的配置是不同的概念 --><bean id="person2" parent="person" p:name="luoxn29"></bean>

Bean依赖配置

  • Spring 允许用户通过 depends-on 属性设定 Bean 前置依赖的Bean,前置依赖的 Bean 会在本 Bean 实例化之前创建好
  • 如果前置依赖于多个 Bean,则可以通过逗号,空格或的方式配置 Bean 的名称
<bean id="msg" class="java.lang.String">  <constructor-arg value="luoxn28"/></bean><bean id="hello" class="com.luoxn28.Hello" depends-on="msg">  <property name="msg" ref="msg"/></bean>

2.3 Bean作用域

  在 Spring 中, 可以在 <bean> 元素的 scope 属性里设置 Bean 的作用域.。默认情况下, Spring 只为每个在 IOC 容器里声明的 Bean 创建唯一一个实例, 整个 IOC 容器范围内都能共享该实例:所有后续的 getBean() 调用和 Bean 引用都将返回这个唯一的 Bean 实例.该作用域被称为 singleton, 它是所有 Bean 的默认作用域。

<!-- Hello对象每次获取都会新建 --><bean id="hello" class="com.luoxn28.Hello" scope="prototype">  <property name="msg" value="luoxn28"/></bean>

2.3 使用外部属性文件

  • 在配置文件里配置 Bean 时, 有时需要在 Bean 的配置里混入系统部署的细节信息(例如: 文件路径, 数据源配置信息等). 而这些部署细节实际上需要和 Bean 配置相分离
  • Spring 提供了一个 PropertyPlaceholderConfigurer 的 BeanFactory 后置处理器, 这个处理器允许用户将 Bean 配置的部分内容外移到属性文件中. 可以在 Bean 配置文件里使用形式为 ${var} 的变量, PropertyPlaceholderConfigurer 从属性文件里加载属性, 并使用这些属性来替换变量.
  • Spring 还允许在属性文件中使用 ${propName},以实现属性之间的相互引用。

比如,程序中有一个db.properties的配置文件:

user=luoxn28password=123456driverClass=com.mysql.jdbc.DriverjdbcUrl=jdbc:mysql://192.168.1.150/test

程序中Spring的applicationContext.

<!-- 导入外部配置文件 --><context:property-placeholder location="classpath:db.properties"/><bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">  <property name="user" value="${user}"/>  <property name="password" value="${password}"/>  <property name="driverClass" value="${driverClass}"/>  <property name="jdbcUrl" value="${jdbcUrl}"/></bean>

程序中就可以使用了:

public static void main(String[] args) throws SQLException {  ClassPath= new ClassPath);  // 获取外部文件  DataSource dataSource = context.getBean("dataSource", DataSource.class);  System.out.println(dataSource.getConnection());}

2.4 Spring的表达式语言:SpEL

  • Spring 表达式语言(简称SpEL):是一个支持运行时查询和操作对象图的强大的表达式语言。
  • 语法类似于 EL:SpEL 使用 #{…} 作为定界符,所有在大框号中的字符都将被认为是 SpEL
  • SpEL 为 bean 的属性进行动态赋值提供了便利

通过 SpEL 可以实现:

  • 通过 bean 的 id 对 bean 进行引用
  • 调用方法以及引用对象中的属性
  • 计算表达式的值
  • 正则表达式的匹配

SpELl 字面量

整数:<property name="count" value="#{5}"/>小数:<property name="frequency" value="#{89.7}"/>科学计数法:<property name="capacity" value="#{1e4}"/>String可以使用单引号或者双引号作为字符串的定界符号:<property name=“name” value="#{'Chuck'}"/> 或 <property name='name' value='#{"Chuck"}'/>Boolean:<property name="enabled" value="#{false}"/>

SpELl 引用Bean、属性和方法

<!-- 引用其他对象 --><bean id="hello" class="com.luoxn28.Hello">  <property name="msg" value="#{msg}"/></bean><!-- 引用其他对象的属性或方法,通过T()来调用一个类的静态方法,它将返回一个Class Object,然后在调用响应的方法或属性 --><bean id="hello2" class="com.luoxn28.Hello">  <!-- <property name="msg" value="#{T(java.lang.String).valueOf(123)}"/> 使用spel为属性配置一个字面值 -->  <property name="msg" value="#{hello.msg}"/></bean>

SpELl 支持的运算符

<property name="xxx" value="#{1 + 1}"/><property name="xxx" value="#{1 - 1}"/><property name="xxx" value="#{1 * 1}"/><property name="xxx" value="#{1 / 1}"/><property name="xxx" value="#{'luoxn' + '28'}"/><property name="xxx" value="#{1 == 1}"/><property name="xxx" value="#{1 < 1}"/><property name="xxx" value="#{1 > 1}"/><property name="xxx" value="#{true ? 'true' : 'false'}"/><property name="xxx" value="#{email matches '[a-zA-Z0-9]+@[a-zA-Z0-9]+\\.[com|cn]'}"/>

2.5 IoC容器中Bean的生命周期方法

  • Spring IOC 容器可以管理 Bean 的生命周期, Spring 允许在 Bean 生命周期的特定点执行定制的任务.
  • Spring IOC 容器对 Bean 的生命周期进行管理的过程:
    • 通过构造器或工厂方法创建 Bean 实例
    • 为 Bean 的属性设置值和对其他 Bean 的引用
    • 调用 Bean 的初始化方法
    • Bean 可以使用了
    • 当容器关闭时, 调用 Bean 的销毁方法
  • 在 Bean 的声明里设置 init-method 和 destroy-method 属性, 为 Bean 指定初始化和销毁方法.

2.6 创建Bean后置处理器

  • Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理.
  • Bean 后置处理器对 IOC 容器里的所有 Bean 实例逐一处理, 而非单一实例. 其典型应用是: 检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性.
  • 对Bean 后置处理器而言, 需要实现 接口. 在初始化方法被调用前后, Spring 将把每个 Bean 实例分别传递给上述接口中的两个方法.该接口源码如下:
public interface BeanPostProcessor {  Object postProcessBeforeInitialization(Object var1, String var2) throws BeansException;  Object postProcessAfterInitialization(Object var1, String var2) throws BeansException;}

添加 Bean 后置处理器后 Bean 的生命周期

Spring IOC 容器对 Bean 的生命周期进行管理的过程:
  • 通过构造器或工厂方法创建 Bean 实例
  • 为 Bean 的属性设置值和对其他 Bean 的引用
  • 将 Bean 实例传递给 Bean 后置处理器的 postProcessBeforeInitialization 方法
  • 调用 Bean 的初始化方法
  • 将 Bean 实例传递给 Bean 后置处理器的 postProcessAfterInitialization方法
  • Bean 可以使用了
  • 当容器关闭时, 调用 Bean 的销毁方法

2.7 通过静态工厂和实例工厂创建Bean

通过调用静态工厂方法创建 Bean

  • 调用静态工厂方法创建 Bean是将对象创建的过程封装到静态方法中. 当客户端需要对象时, 只需要简单地调用静态方法, 而不同关心创建对象的细节.
  • 要声明通过静态方法创建的 Bean, 需要在 Bean 的 class 属性里指定拥有该工厂的方法的类, 同时在 factory-method 属性里指定工厂方法的名称. 最后, 使用 <constrctor-arg> 元素为该方法传递方法参数.
比如Hello类静态工厂方法如下:
public static Hello createHello() {  Hello hello = new Hello();  hello.setMsg("static");  return hello;}

Spring的applicationContext.

<bean id="hello" class="com.luoxn28.Hello" factory-method="createHello"></bean>

通过调用实例工厂方法创建 Bean


  • 实例工厂方法: 将对象的创建过程封装到另外一个对象实例的方法里. 当客户端需要请求对象时, 只需要简单的调用该实例方法而不需要关心对象的创建细节.
  • 要声明通过实例工厂方法创建的 Bean
    • 在 bean 的 factory-bean 属性里指定拥有该工厂方法的 Bean
    • 在 factory-method 属性里指定该工厂方法的名称
    • 使用 construtor-arg 元素为工厂方法传递方法参数

2.8 实现 FactoryBean 接口在 Spring IOC 容器中配置 Bean

  • Spring 中有两种类型的 Bean, 一种是普通Bean, 另一种是工厂Bean, 即FactoryBean.
  • 工厂 Bean 跟普通Bean不同, 其返回的对象不是指定类的一个实例, 其返回的是该工厂 Bean 的 getObject 方法所返回的对象 

FactoryBean接口源码如下所示:

public interface FactoryBean<T> {  // 返回的实例  T getObject() throws Exception;  // 返回的类型  Class<?> getObjectType();  // 是否为单例  boolean isSingleton();}

比如有一个Hello类如下:

public class Hello {  private String name;  private int age;  public String getName() {    return name;  }  public void setName(String name) {    this.name = name;  }  public int getAge() {    return age;  }  public void setAge(int age) {    this.age = age;  }  @Override  public String toString() {    return "Hello{" +        "name='" + name + '\'' +        ", age=" + age +        '}';  }}

定义Hello类的FactoryBean类:

public class HelloBeanFactory implements FactoryBean<Hello> {  @Override  public Hello getObject() throws Exception {    Hello hello = new Hello();    hello.setName("luoxn28");    hello.setAge(23);    return hello;  }  @Override  public Class<?> getObjectType() {    return Hello.class;  }  @Override  public boolean isSingleton() {    return true;  }}

然后在applicationContext.

<bean id="helloBean" class="com.luoxn28.hello.HelloBeanFactory"></bean>

public static void main(String[] args) {  ApplicationContext context = new ClassPath);  Hello hello = context.getBean("helloBean", Hello.class);  System.out.println(hello);}

 

3 基于注解的Bean配置

  • 组件扫描(component scanning):  Spring 能够从 classpath 下自动扫描, 侦测和实例化具有特定注解的组件.
  • 特定组件包括:
    • @Component: 基本注解, 标识了一个受 Spring 管理的组件
    • @Respository: 标识持久层组件
    • @Service: 标识服务层(业务层)组件
    • @Controller: 标识表现层组件
  • 对于扫描到的组件, Spring 有默认的命名策略: 使用非限定类名, 第一个字母小写. 也可以在注解中通过 value 属性值标识组件的名称
  当在组件类上使用了特定的注解之后, 还需要在 Spring 的配置文件中声明 <context:component-scan> :base-package 属性指定一个需要扫描的基类包,Spring 容器将会扫描这个基类包里及其子包中的所有类。当需要扫描多个包时, 可以使用逗号分隔。如果仅希望扫描特定的类而非基包下的所有类,可使用 resource-pattern 属性过滤特定的类,示例:
<context:component-scan base-package="com.luoxn28.hello" resource-pattern="hi/*.class"></context:component-scan>


  注意:<context:component-scan> 下可以拥有若干个 <context:include-filter> 和 <context:exclude-filter> 子节点,<context:include-filter> 子节点表示要包含的目标类,<context:exclude-filter> 子节点表示要排除在外的目标类。
比如Hello类源码如下:
@Componentpublic class Hello {  private String name;  private int age;...}

applicationContext.

<context:component-scan base-package="com.luoxn28.hello"></context:component-scan>

这样就可以在程序中按照如下方式获取了,注意,基于@Component方式时,该Bean实例的id为第一个字母为小写的类名。

public static void main(String[] args) {  ApplicationContext context = new ClassPath);  Hello hello = context.getBean("hello", Hello.class);  System.out.println(hello);}

3.1 组件装配


  <context:component-scan> 元素还会自动注册 AutowiredAnnotationBeanPostProcessor 实例, 该实例可以自动装配具有 @Autowired 和 @Resource 、@Inject注解的属性。
使用 @Autowired 自动装配 Bean
  @Autowired 注解自动装配具有兼容类型的单个 Bean属性
  • 构造器, 普通字段(即使是非 public), 一切具有参数的方法都可以应用@Authwired 注解
  • 默认情况下, 所有使用 @Authwired 注解的属性都需要被设置. 当 Spring 找不到匹配的 Bean 装配属性时, 会抛出异常, 若某一属性允许不被设置, 可以设置 @Authwired 注解的 required 属性为 false
  • 默认情况下, 当 IOC 容器里存在多个类型兼容的 Bean 时, 通过类型的自动装配将无法工作. 此时可以在 @Qualifier 注解里提供 Bean 的名称. Spring 允许对方法的入参标注 @Qualifiter 已指定注入 Bean 的名称
  • @Authwired 注解也可以应用在数组类型的属性上, 此时 Spring 将会把所有匹配的 Bean 进行自动装配.
  • @Authwired 注解也可以应用在集合属性上, 此时 Spring 读取该集合的类型信息, 然后自动装配所有与之兼容的 Bean.
  • @Authwired 注解用在 java.util.Map 上时, 若该 Map 的键值为 String, 那么 Spring 将自动装配与之 Map 值类型兼容的 Bean, 此时 Bean 的名称作为键值

Hello类与源码如下:

@Componentpublic class Hello {  @Autowired  private String name;  private int age;  public void test() {    System.out.println(name.toString() + ": " + age);  }...}

applicationContext.

<bean id="str" class="java.lang.String">  <constructor-arg value="luoxn28"/></bean><context:component-scan base-package="com.luoxn28.hello">  <!-- context:exclude-filter type="" expression="" : 子节点指定排除哪些指定的组件 -->  <!-- context:include-filter type="" expression="" : 子节点指定包含哪些指定的组件 --></context:component-scan>

程序中就可以按照如下方式获取了:

public static void main(String[] args) {  ApplicationContext context = new ClassPath);  Hello hello = context.getBean("hello", Hello.class);  System.out.println(hello);  hello.test();}

  当属性被设置为@Autowired时,注解自动装配具有兼容类型的单个 Bean属性,这里Hello实例装配的就是String实例。

3.2 使用 @Resource 或 @Inject 自动装配 Bean

  • Spring 还支持 @Resource 和 @Inject 注解,这两个注解和 @Autowired 注解的功用类似
  • @Resource 注解要求提供一个 Bean 名称的属性,若该属性为空,则自动采用标注处的变量或方法名作为 Bean 的名称
  • @Inject 和 @Autowired 注解一样也是按类型匹配注入的 Bean, 但没有 reqired 属性
  • 建议使用 @Autowired 注解

 

参考资料:

  1、Spring4.0从入门到精通视频教程(没有答疑服务)

  2、Spring学习之第一个hello world程序