投稿
  1. 极客之音首页
  2. 技术随笔

Spring Framework核心–装配bean

飞熊 • • 技术随笔 • 阅读 283

得意时要看淡，失意时要看开。不论得意失意，切莫大意;不论成功失败，切莫止步。志得意满时，需要的是淡然，给自己留一条退路;失意落魄时，需要的是泰然，给自己觅一条出路Spring Framework核心–装配bean，希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com，来源：原文

文章目录

Spring的两个核心特性：

依赖注入 (dependency injection, DI)

面向切面编程 (aspect oriented programming, AOP)

为了降低Java开发的复杂性，Spring采取了以下4种关键策略：

  • 基于POJO的轻量级和最小侵入性编程
  • 通过依赖注入和面向接口实现松耦合
  • 基于切面和惯例进行声明式编程
  • 通过切面和模板减少样板式代码

Spring模块分类图：

以下为Spring 4的一些模块设计

在这里插入图片描述

1. Core Container（核心容器）

Spring的核心容器是其他模块建立的基础，它主要由Beans模块、Core模块、Context模块、Context-support模块和SpEL（Spring Expression Language,Spring表达式语言）模块组成，具体介绍如下。

  • Beans模块：提供了BeanFactory，是工厂模式的经典实现，Spring将管理对象称为Bean。
  • Core核心模块：提供了Spring框架的基本组成部分，包括IoC和DI功能。
  • Context上下文模块：建立在Core和Beans模块的基础之上，它是访问定义和配置的任何对象的媒介。其中ApplicationContext接口是上下文模块的焦点。
  • Context-support模块：提供了对第三方库嵌入Spring应用的集成支持，比如缓存（EhCache、Guava、JCache）、邮件服务（JavaMail）、任务调度（CommonJ、Quartz）和模板引擎（FreeMarker、JasperReports、速率）。
  • SpEL模块：是Spring 3.0后新增的模块，它提供了Spring ExpressionLanguage支持，是运行时查询和操作对象图的强大的表达式语言。

2.Data Access/Integration（数据访问/集成）

数据访问/集成层包括JDBC、ORM、OXM、JMS和Transactions模块，具体介绍如下。

  • JDBC模块：提供了一个JDBC的抽象层，大幅度地减少了在开发过程中对数据库操作的编码。
  • ORM模块：对流行的对象关系映射API，包括JPA、JDO和Hibernate提供了集成层支持。
  • OXM模块：提供了一个支持对象/ XML映射的抽象层实现，如JAXB、Castor、XMLBeans、JiBX和XStream。
  • JMS模块：指Java消息传递服务，包含使用和产生信息的特性，自4.1版本后支持与Spring-message模块的集成。
  • Transactions事务模块：支持对实现特殊接口以及所有POJO类的编程和声明式的事务管理。

3.Web

Spring的Web层包括WebSocket、Servlet、Web和Portlet模块，具体介绍如下。

  • WebSocket模块：Spring 4.0以后新增的模块，它提供了WebSocket和SockJS的实现，以及对STOMP的支持。
  • Servlet模块：也称为Spring-webmvc模块，包含了Spring的模型—视图—控制器（MVC）和REST Web Services实现的Web应用程序。
  • Web模块：提供了基本的Web开发集成特性，例如：多文件上传功能、使用Servlet监听器来初始化IoC容器以及Web应用上下文。
  • Portlet模块：提供了在Portlet环境中使用MVC实现，类似Servlet模块的功能。

4．其他模块

Spring的其他模块还有AOP、Aspects、Instrumentation以及Test模块，具体介绍如下。

  • AOP模块：提供了面向切面编程实现，允许定义方法拦截器和切入点，将代码按照功能进行分离，以降低耦合性。
  • Aspects模块：提供了与AspectJ的集成功能，AspectJ是一个功能强大且成熟的面向切面编程（AOP）框架。
  • Instrumentation模块：提供了类工具的支持和类加载器的实现，可以在特定的应用服务器中使用。
  • Messaging模块：Spring 4.0以后新增的模块，它提供了对消息传递体系结构和协议的支持。
  • Test模块：提供了对单元测试和集成测试的支持。

以下为Spring 5的一些模块设计

Core Container （核心容器）

Spring的核心容器是其他模块建立的基础。

  • Beans模块：提供了BeanFactory，是工厂模式的经典实现，Spring将管理对象称为Bean。
  • Core核心模块：提供了Spring框架的基本组成部分，包括IoC和DI功能。
  • Context 上下文模块：建立在Core和Beans模块的基础之上，它是访问定义和配置的任何对象的媒介。其中ApplicationContext接口是上下文模块的焦点。
  • Context-support模块：提供了对第三方库嵌入Spring应用的集成支持，比如缓存（EhCache、Caffeine、JCache）、邮件服务（JavaMail）、任务调度（CommonJ、Quartz）和模板引擎（FreeMarker）。
  • SpEL模块：是Spring 3.0后新增的模块，它提供了Spring ExpressionLanguage支持，是运行时查询和操作对象的强大的表达式语言。
  • Context-indexer模块：是Spring 5后新增的模块，添加此依赖，可以通过在编译时创建候选对象的静态列表来提高大型应用程序的启动性能。

Data Access/Integration（数据访问/集成）

  • JDBC模块：提供了一个JDBC的抽象层，大幅度地减少了在开发过程中对数据库操作的编码。
  • R2DBC模块：提供了一个R2DBC的抽象层。R2DBC基于Reactive Streams反应流规范，它是一个开放的规范，为驱动程序供应商和使用方提供接口（r2dbc-spi），与JDBC的阻塞特性不同，它提供了完全反应式的非阻塞API与关系型数据库交互。
  • ORM模块：对流行的对象关系映射API，包括JPA、JDO和Hibernate提供了集成层支持。
  • OXM模块：提供了一个支持对象/ XML映射的抽象层实现，如JAXB、MIME、JiBX和XStream。
  • JMS模块：指Java消息传递服务，包含使用和产生信息的特性，自4.1版本后支持与Spring-message模块的集成。
  • Transactions事务模块：支持对实现特殊接口以及所有POJO类的编程和声明式的事务管理。

Web

  • Web模块：提供了基本的Web开发集成特性，例如：多文件上传功能、使用Servlet监听器来初始化IoC容器以及Web应用上下文。
  • WebMVC：提供基于Servlet的Spring MVC。
  • WebFlux：非阻塞web框架，它利用多核、新一代处理器并处理大量并发连接。
  • WebScoket：提供WebScoket功能。

其他模块

  • AOP模块：提供了面向切面编程实现，允许定义方法拦截器和切入点，将代码按照功能进行分离，以降低耦合性。
  • Aspects模块：提供了与AspectJ的集成功能，AspectJ是一个功能强大且成熟的面向切面编程（AOP）框架。
  • Instrument模块：提供了类工具的支持和类加载器的实现，可以在特定的应用服务器中使用。
  • Messaging模块：Spring 4.0以后新增的模块，它提供了对消息传递体系结构和协议的支持。
  • JCL模块：Spring5.x开始，自己实现了日志框架的适配器功能模块。
  • Test模块：提供了对单元测试和集成测试的支持。

Maven项目的pom.xml中使用如下依赖：
例子：

<dependencies>
        <!-- Spring依赖 -->
        <!-- 1.Spring核心依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.0.18.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.0.18.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.18.RELEASE</version>
        </dependency>
        <!-- 2.Spring dao依赖 -->
        <!-- spring-jdbc包括了一些如jdbcTemplate的工具类 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.0.18.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.0.18.RELEASE</version>
        </dependency>
        <!-- 3.Spring web依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.0.18.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.0.18.RELEASE</version>
        </dependency>
        <!-- 4.Spring test依赖：方便做单元测试和集成测试 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.18.RELEASE</version>
        </dependency>
    </dependencies>

DI

DI 全称 Dependency Injection，意思是依赖注入，它是 IOC 的具体实现。
Spring通过DI（依赖注入）实现IOC（控制反转）
简单来说，依赖注入就是使用 Spring 的工厂和配置文件为一个类的成员变量赋值。

Spring常用的注入方式主要有三种：

  1. 构造方法注入
  2. setter注入
  3. 基于注解的注入

Spring配置的可选方案

Spring容器负责创建应用程序中的bean，同时通过ID来协调这些对象之间的关系。
创建应用对象之间协作关系的行为通常称为装配 (wiring)，这也是依赖注入(DI)的本质。

Spring有三种主要的装配机制：

  • 在XML中进行显式装配
  • 在Java代码中进行显式装配
  • 隐式的bean发现机制和自动装配

当然这些方式也可以配合使用。

通过XML装配bean

通过XML的方式，是Spring中历史最长的一种方式，从Spring建立之初就出现。
Spring 的配置文件可以放到项目中的任意一个地方，也可以随意命名，一般建议命名为：applicationContext.xml。
可以将这个配置文件看成一个装有一堆 bean 标签的容器。

创建XML配置规范

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- beans details -->
</beans>

声明一个简单的bean

Spring 工厂创建的对象，叫做 bean，所以一个 bean 标签代表一个对象。
声明bean，使用<bean>，类似于JavaConfig中的@Bean注解。
bean 标签中必须要有 class 属性，它的值是一个类的全限定名（包名+类名）。
除了 class 属性，bean 标签还可以设置 id 、name 、scope等属性。(具体的可以查阅 xsd文件)
没有明确给定id，这个bean将会根据全限定类名来进行命名。
推荐借助id属性，为每个bean设置一个专属的名字。

<bean id="cdPlayer" class="org.example.soundsystem.CDPlayer"/>

构造器注入初始化bean

构造器注入，有2种基本的配置方案：

  1. <constructor-arg> 元素
  2. 使用Spring 3.0 所引入的c-命名空间

第一种方式：

public class CarDriver implements Driver {
    private Vehicle vehicle;

    public CarDriver(Vehicle vehicle) {
        this.vehicle = vehicle;
    }

    @Override
    public void drive() {
        System.out.println("car driver drive the car");
    }
}

<?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="car" class="org.example.vehicle.Car"/>

    <bean id="carDriver" class="org.example.vehicle.CarDriver">
        <constructor-arg ref="car"/>
    </bean>

</beans>

引用值：<constructor-arg ref=“”/>
字面量：<constructor-arg value=“”/>

第二种方式：

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

    <bean id="car" class="org.example.vehicle.Car"/>

    <bean id="carDriver" class="org.example.vehicle.CarDriver"
          c:vehicle-ref="car">
    </bean>
</beans>

注意，多了一条声明：
xmlns:c=“http://www.springframework.org/schema/c”

  • 引用值：c: 构造器参数名-ref=“”
    解析：c:vehicle-ref=“car”
    c 命名空间前缀
    vehicle 构造器参数名
    -ref 命名约定

    其他的写法：**
    利用参数的索引位置，改写成 c:_0-ref=“car”
    因为在XML中，不允许数字作为属性的第一个字 符，因此必须要添加一个下划线作为前缀。
    如果只有一个参数，可以简写，不用标识参数
    c:_-ref=“car”

  • 字面量：c: _构造器参数名=“”
    其他的写法：
    c: _0=“”
    c: _1=“”
    如果只有一个参数，可以简写，不用标识参数
    c: _=“”

装配集合

在装配引用值和字面值方面， <constructor-arg> 和c-命名空间的功能是相同的。
但是在装配集合时， c-命名空间就无法做到。

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

    <bean id="car" class="org.example.vehicle.Car"/>

    <bean id="carDriver" class="org.example.vehicle.CarDriver">
		<constructor-arg>
			<list>
				<ref bean="car" />
				<ref bean="car1" />
				<ref bean="car2" />
			</list>
		</constructor-arg>
    </bean>
</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:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="car" class="org.example.vehicle.Car"/>

    <bean id="carDriver" class="org.example.vehicle.CarDriver">
		<constructor-arg>
			<list>
				<value>aa</value>
				<value>bb</value>
				<value>cc</value>
			</list>
		</constructor-arg>
    </bean>
</beans>

除了使用List，还可以使用Set、Map、甚至数组等。

set注入：设置属性

没有构造器的情况下，也没有任何强依赖的情况下，可以通过属性注入的方式。
例如：

<?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="car" class="org.example.vehicle.Car"/>
    ...
    
    <bean id="carDriver" class="org.example.vehicle.CarDriver">
        <property name="car1" ref="car1"/>
        <property name="car" ref="car"/>
    </bean>

</beans>

<property>元素为属性的Setter方法所提供的功能。
与之类似，存在类似的-p命名空间
多一条声明：
xmlns:c=”http://www.springframework.org/schema/p
引用值格式为

p:属性名-ref="所注入bean的id"

字面值格式为

p:属性名="具体的值"

注意，不能使用-p命名空间来装配集合。

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

    <bean id="car" class="org.example.vehicle.Car"/>
    ...

    <bean id="carDriver" class="org.example.vehicle.CarDriver"
        <p:car1="car1"/>
        <property name="car" ref="car"/>
    </bean>
</beans>

扩展，也可以使用util-命名空间，来简化集合的配置。

自动化装配bean

便利性方面，最强大的还是Spring的自动化配置。
Spring从两个角度来实现自动化装配：

  • 组件扫描 （component scanning）：Spring会自动发现 应用上下文所创建的bean。
  • 自动装配（autowiring）：Spring自动满足bean之间的依赖。

将这两者结合在一起使用，既可以将显示配置降低到最少。

创建可被发现的bean

如下案例，详见注释：

package org.example.soundsystem;

public interface CompactDisc {
    void play();
}

package org.example.soundsystem;

import org.springframework.stereotype.Component;

@Component
public class SgtPeppers implements CompactDisc {
    private String title = "Sgt. Pepper's Lonely Hearts Club Band";
    private String artist = "The Beatles";

    @Override
    public void play() {
        System.out.println("Playing " + title + " by " + artist);
    }
}

@Component 注解表明该类会作为组件类，并告知Spring要为这个类创建bean。
注意，组件扫描默认是不开启的

Spring应用上下文中所有的bean都会给定一个ID，spring默认是将类名第一个字母变成小写，作为ID。
通过下面的写法，可以为组件扫描的bean命名
@Component(“newSgtPeppers”)

package org.example.soundsystem;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackageClasses = {SgtPeppers.class})
public class CDPlayerConfig {
}

@Configuration 注解表明这个类是一个配置类，该类应该包含在Spring应用上下文中如何创建bean的细节。
@ComponentScan 这个注解能在Spring中启动组件扫描。默认会扫描与配置类相同的包，以及该包下的所有子包，查找带@Component注解的类，并且会在Spring中自动为其创建一个bean。
也可以自己设置扫描多个基础包，通过下面的写法等：

@ComponentScan(basePackages = {"org.example.soundsystem", "org.example.sound"})
// 这种方式，缺点：类型不安全，如果包名改变，漏改就会报错

@ComponentScan(basePackageClasses = {SgtPeppers.class, SgtPeppers2.class})
// 推荐这种写法，列举出的类所在的包都会作为组件扫描的基础包

如果更想通过XML来开启组件扫描，可以使用Spring context命名空间的context:component-scan元素，如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="org.example.soundsystem"/>
</beans>

为bean添加注解实现自动装配

自动装配就是让Spring自动满足bean依赖的一种方式，在满足依赖的过程中，会在Spring应用上下文中寻找匹配某个bean需求的其他bean。为了声明要进行自动装配，可以借助Spring的@Autowired注解。

@Autowired注解可以用在类的任何方法上。Spring都会尝试满足方法参数上所声明的依赖。
例如：构造器、普通方法、属性的setter方法等等

自动装配时，会有三种情况：

  • 假设只有一个bean匹配依赖需求的话，那么这个bean就会被装配进来。
  • 假设没有匹配的bean，那么在创建应用上下文的时候，Spring会抛出异常（为了抑制异常，可以将设置@Autowired(required=false)，一定要有判断null的逻辑，不然也会报错）
  • 假设有多个匹配的bean，那么在创建应用上下文的时候，Spring也会抛出异常，因为Spring不知道选择哪一个bean进行自动装配。

扩展：大多数情况下，@Inject（来源于Java依赖注入规范）和@Autowired是可以相互替换的。

package org.example.soundsystem;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class CDPlayer implements MediaPlayer {
    private CompactDisc cd;

    @Autowired
    public CDPlayer(CompactDisc cd) {
        this.cd = cd;
    }

    @Override
    public void play() {
        cd.play();
    }
}

通过Java代码装配bean

在有些场景下，通过自动化配置的方案行不通，比如将第三方库中的组件装配到你的应用中，这种情况下，是没有办法在它的类上添加@Component和@Autowired注解。所以就要使用显示装配的方式。
JavaConfig与其他Java代码有区别，它和应用程序的业务逻辑和领域代码是不同的。JavaConfig是配置代码，意味着它不应该包含任何业务逻辑，通常会将它放到单独的包里。

创建配置类

创建JavaConfig类的关键在于为其添加@Configuration注解，表明该类是一个配置类，该类应该包含在Spring应用上下文如何创建bean的细节。
详见上面的CDPlayerConfig class

声明简单的bean

在JavaConfig类中声明bean：
添加@Bean 注解会告诉Spring这个方法将返回一个对象，该对象要注册为Spring应用上下文中的bean。方法体中包含了最终产生bean实例的逻辑。

@Bean
public CompactDisc sgtPeppers() {
	return new SgtPeppers();
}

默认情况下，bean的ID与带有@Bean注解的方法名是一样的。
在上面例子中，bean的名字将会是sgtPeppers。如果想为其设置一个不同的名字，可以通过name属性指定一个不同的名字。

@Bean(name = "sgtBean")
public CompactDisc sgtPeppers() {
	return new SgtPeppers();
}

借助JavaConfig实现注入

@Bean
public CDPlayer cdPlayer(CompactDisc compactDisc) {
	 return new CDPlayer(compactDisc);
}

cdPlay() 方法请求一个CompactDisc作为参数。当Spring调用cdPlayer()创建CDPlayer bean时, 它会自动装配一个CompactDisc到配置方法中，方法体中可以按照合适的方式来使用它。
通过这种方式引入其他bean通常是最好的选择，因为它不会要求将CompactDisc声明到同一个配置类之中。
不管CompactDisc是采用什么方式创建出来的，Spring都会将其传入到配置方法中，并用来创建CDPlayer bean。

Bean的生命周期

Bean 的生命周期指的就是由 Spring 管理的对象从创建到销毁的过程。
它主要分为三个阶段： 创建 –> 初始化 –> 销毁

创建阶段

Spring 的工厂创建对象的方式分两类：

  1. singleton 模式
    当 scope 属性为 singleton ，创建 Spring 工厂的同时创建所有单例对象。
    如果想修改创建单例对象的方式为获取的时候才创建，只需要在 bean 标签上面添加如下属性：lazy-init=“true”
  2. prototype 模式
    只有获取对象的时候才会创建对象。

初始化阶段

Spring 中 bean 的初始化操作指的是在创建对象的时候完成一些附加的功能。bean 的初始化操作有两种实现方式：

  1. 实现 InitializingBean 接口
  2. 通过创建普通方法完成初始化，添加属性：init-method=“”

销毁阶段

Spring 销毁对象前，会调用对象的销毁方法，完成销毁操作。
当 Spring 工厂关闭时，Spring 工厂会调用我们自定义的销毁方法。
销毁方法的定义有两种方式：

  1. 实现DisposableBean接口
  2. 创建普通方法，添加属性：destroy-method=“”

常用注解

Spring 配置文件相关注解

@Configuration

@Configuration 注解用于替换 xml 配置文件。
意思就是说你在一个类上面加一个 @Configuration 注解，这个类就可以看成 Spring 的配置类，你就不用再写 xml 文件了。
我们之前是根据 xml 文件创建 Spring 的工厂，那怎样根据配置类创建工厂呢？
有两种方式：
方式一：根据类.class

ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

方式二：根据配置类所在的路径

ApplicationContext ctx = new AnnotationConfigApplicationContext("com.xxl");

@Bean

@Bean 注解也是用来创建对象的，相当于spring 配置文件中的 bean 标签。
在实际开发中我们一般会用 @Bean 注解创建一些复杂的对象，例如 Redis、MQ 等一些组件对象。

@ComponentScan

@ComponentScan 注解相当于 xml 配置文件中的注解扫描标签：

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

作用：用来扫描@Component 等相关注解
属性：
basePackages：注解所在的包路径

创建对象相关注解

@Component

作用：替换 bean 标签，用来创建对象。就是在类上面加了这个注解，就不用在配置文件上写 bean 标签了。

位置：类上面

id 属性：默认首单词首字母小写

@Component 衍生注解

我们在开发程序的时候一般会将程序分层，例如分为控制层（controller），业务层（service），持久层（dao）。
但是 @Component 注解并不能区分这些类属于那些层，所以 Spring 提供了以下衍生注解：
1.@Controller：表示创建控制器对象
2.@Service：表示创建业务层对象
3.@Repository：表示创建持久层对象

这三个注解的作用和 @Component 的作用一样，都是用来创建对象。

@Scope

我们知道 Spring 工厂创建的对象默认都是单例的，也就是 bean 标签中 scope 属性默认是 singleton。
@Scope 注解可以用来修改创建对象的 scope 属性。
默认：也就是说你不写 @Scope 注解，默认就是 singleton，所以可以省略。

生命周期相关注解

@PostConstruct

初始化方法注解，作用在方法上。用来替换 bean 标签的 init-method 属性。

@PreDestory

销毁方法注解，作用在方法上。用来替换 bean 标签的 destory-method 属性。

注入相关注解

@Autowired

我们之前学 DI 的时候知道：注入就是赋值。

@Autowired 主要是为自定义的类型赋值，例如 service、dao 层的各种类。
@Autowired 是基于类型进行注入，所注入对象的类型必须和目标 变量类型相同或者是他的子类、实现类。

如果想基于名字注入，可以和 @Qualifier 注解连用

@Resource

@Resource 注解是 JAVAEE 规范中提供的注解，他和 @Autowired 注解的作用一样， 但是他是基于名字进行注入

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/155799.html

赞 (0)
飞熊的头像飞熊bm
0 0

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！