Spring路径-01-Spring基础

1 Spring概述

1.1 Spring的简史

Spring是一个开源的轻量级Java开发应用框架，可以简化企业应用开发。Spring解决了开发者在JavaEE开发中遇到的许多常见问题，提供了功能强劲loC、AOP以及web MVC等功能。是当前企业中Java开发几乎不能缺少的框架之一，Spring的生态及其完善，不管是Spring哪个领域的解决方案都依附于Spring Framework基础框架的。

（1）Spring1.x 时代（xml配置）在Spring1.x时代，都是通过xml文件配置bean，随着项目的不断扩大，需要将xml配置分放到不同的配置文件中，需要频繁的在java类和xml配置文件中切换。

（2）Spring2.x时代（注解配置）随着JDK 1.5带来的注解支持，Spring2.x可以使用注解对Bean进行申明和注入，大大的减少了xml配置文件，同时也大大简化了项目的开发。

那么，问题来了，究竟是应该使用xml还是注解呢？

最佳实践：应用的基本配置用xml，列如：数据源、资源文件等；业务开发用注解，列如：Service中注入bean等；

（3）Spring3.x到Spring5.x（Java配置）从Spring3.x开始提供了Java配置方式，使用Java配置方式可以更好的理解你配置的Bean，目前我们就处于这个时代，并且Spring4.x和Spring boot都推荐使用java配置的方式。

Spring Framework核心概念

业务层需要调用数据层的方法，需要在业务层new数据层的对象，如果数据层的实现类发生变化，那么业务层的代码也需要跟着改变，发生变更后，都需要进行编译打包和重部署，所以，编写的过程中存在的问题是：耦合度高

解决方案：不使用new产生对象，转换为由外部提供对象。即Ioc

IoC ( Inversion of Control )：控制反转

使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转

Spring技术对IoC思想进行了实现

Spring提供了一个容器, 称为IoC容器，用来充当IoC思想中的心外部

IoC容器负责对象的创建、初始化等-系列工作, 被创建或被管理的对象在 IoC容器中统称为Bean

DI ( Dependency Injection )：依赖注入

在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入

1.2 Spring概述

Spring是2003年兴起的，它是一个轻量级的，非侵入式的IOC和AOP的一站式框架，为简化企业级应用开发。

轻量级：指的是核心jar包比较小的。
非侵入式的：框架代码不会侵入到业务代码，即业务代码的类不会实现或继承框架中接口或类。
IOC：Inversion Of Control 反转控制/控制反转，以前我们使用java对象，在哪使用就在哪里new，IOC思想就是对所有我们需要使用的对象进行封装管理（创建，功能增强，销毁），在哪使用我们就在哪里注入，耦合度降低。
AOC：面向切面编程，核心思想是将公共功能进行提取，然后统一代理调用。
一站式框架：spring还对jdbc，对web层进行封装，对事务管理等等。

1.2.1 Spring的模块

Spring框架提供了许多功能模块，主要模块如下：

Spring路径-01-Spring基础

1.2.1.1 核心容器CoreContaier

Spring 的核心容器是其他模块建立的基础，由 Beans 模块、Core 核心模块、Context 上下文模块和 SpEL 表达式语言模块组成，没有这些核心容器，也不可能有 AOP、Web 等上层的功能。具体介绍如下。

Beans 模块：提供了框架的基础部分，包括控制反转和依赖注入。
Core 核心模块：封装了 Spring 框架的底层部分，包括资源访问、类型转换及一些常用工具类。
Context 上下文模块：建立在 Core 和 Beans 模块的基础之上，集成 Beans 模块功能并添加资源绑定、数据验证、国际化、Java EE 支持、容器生命周期、事件传播等。ApplicationContext 接口是上下文模块的焦点。
SpEL 模块：提供了强劲的表达式语言支持，支持访问和修改属性值，方法调用，支持访问及修改数组、容器和索引器，命名变量，支持算数和逻辑运算，支持从 Spring 容器获取 Bean，它也支持列表投影、选择和一般的列表聚合等。

1.2.1.2 AOP、Aspects、Instrumentation和Messaging

在 Core Container 之上是 AOP、Aspects 等模块，具体介绍如下：

AOP 模块：提供了面向切面编程实现，提供列如日志记录、权限控制、性能统计等通用功能和业务逻辑分离的技术，并且能动态的把这些功能添加到需要的代码中，这样各司其职，降低业务逻辑和通用功能的耦合。
Aspects 模块：提供与 AspectJ 的集成，是一个功能强劲且成熟的面向切面编程（AOP）框架。
Instrumentation 模块：提供了类工具的支持和类加载器的实现，可以在特定的应用服务器中使用。
messaging 模块：Spring 4.0 后来新增了消息（Spring-messaging）模块，该模块提供了对消息传递体系结构和协议的支持。
jcl 模块： Spring 5.x中新增了日志框架集成的模块。

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

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

JDBC 模块：提供了一个 JDBC 的样例模板，使用这些模板能消除传统冗长的 JDBC 编码还有必须的事务控制，而且能享受到 Spring 管理事务的好处。
ORM 模块：提供与流行的“对象-关系”映射框架无缝集成的 API，包括 JPA、JDO、Hibernate 和 MyBatis 等。而且还可以使用 Spring 事务管理，无需额外控制事务。
OXM 模块：提供了一个支持 Object /XML 映射的抽象层实现，如 JAXB、Castor、XMLBeans、JiBX 和 XStream。将 Java 对象映射成 XML 数据，或者将XML 数据映射成 Java 对象。
JMS 模块：指 Java 消息服务，提供一套 “消息生产者、消息消费者”模板用于更加简单的使用 JMS，JMS 用于用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。
Transactions 事务模块：支持编程和声明式事务管理。

1.2.1.4 Web模块

Spring 的 Web 层包括 Web、Servlet、WebSocket 和 Webflux 组件，具体介绍如下。

Web 模块：提供了基本的 Web 开发集成特性，例如多文件上传功能、使用的 Servlet 监听器的 IOC 容器初始化以及 Web 应用上下文。
Servlet 模块：提供了一个 Spring MVC Web 框架实现。Spring MVC 框架提供了基于注解的请求资源注入、更简单的数据绑定、数据验证等及一套超级易用的 JSP 标签，完全无缝与 Spring 其他技术协作。
WebSocket 模块：提供了简单的接口，用户只要实现响应的接口就可以快速的搭建 WebSocket Server，从而实现双向通讯。
Webflux 模块： Spring WebFlux 是 Spring Framework 5.x中引入的新的响应式web框架。与Spring MVC不同，它不需要Servlet API，是完全异步且非阻塞的，并且通过Reactor项目实现了Reactive Streams规范。Spring WebFlux 用于创建基于事件循环执行模型的完全异步且非阻塞的应用程序。

此外Spring4.x中还有Portlet 模块，在Spring 5.x中已经移除

Portlet 模块：提供了在 Portlet 环境中使用 MVC 实现，类似 Web-Servlet 模块的功能。

1.2.1.5 Test模块

Test 模块：Spring 支持 Junit 和 TestNG 测试框架，而且还额外提供了一些基于 Spring 的测试功能，列如在测试 Web 框架时，模拟 Http 请求的功能。

包含Mock Objects, TestContext Framework, Spring MVC Test, WebTestClient。

1.3 Spring的生态

Spring Framework（Core）：Spring项目的核心。Spring Framework中包含了一系列的IoC容器的设计，提供了依赖反转模式的实现。同时，还集成了AOP功能，包含了其他Spring的基本模块，如MVC，JDBC，事务处理模块的实现。
Spring Web Flow：构件在Spring MVC基础上，相对于Spring Framework（Core）独立发展的。定义了一种特定的语言来描述工作流，同时高级的工作流控制器引擎可以管理会话状态（将交互流程从各个位置抽象出来，以工作流的形式定义出来，清晰，便于管理），支持AJAX来构件丰富的客户端体验，并且提供对JSF的支持。
Spring Security：一个能够为基于Spring的企业应用系统提供声明式的安全訪问控制解决方式的安全框架，在我们进行用户认证以及授予权限的时候，通过各种各样的拦截器来控制权限的访问，从而实现安全。
Spring Security OAuth：为OAuth在Spring上的集成提供支持。OAuth是一个第三方的模块，提供一个开放的协议的实现，通过这个协议，前端桌面应用可以对Web应用进行简单而标准的安全调用。
Spring Batch：提供构建批处理应用和自动化操作的框架，批处理：Hadoop、Storm、Spark。
Spring Integration：体现了“企业集成模式”的具体实现，并为企业的数据集成提供解决方案。两个功能：a.系统内提供轻量级、事件驱动交互行为的框架；b.系统间提供一种基于适配器的平台，以支持灵活的系统间交互。
Spring AMQP：是为Spring应用更好的使用AMQP（高级消息队列协议，典型实现：RabbitMQ）的消息服务而开发的。使在Spring应用中使用AMQP消息服务器变得更为简单。（相比KAFKA更重量级，数据一致性、稳定性与可靠性更高）
Spring Android：提供一个在Android应用环境中工作，基于java的REST客户端
Spring Web Services：聚焦于创建文档驱动服务，以便于连接使用SOAP协议赖做WebService的服务。
Spring Mobile：基于spring MVC构建，为移动终端的服务器应用开发提供支持，如：使用Spring Mobile可以在服务器端自动识别连接到服务器的移动端的相关设备信息，从而为特定的移动端实现应用定制。
Spring Data：为Spring应用提供使用关系/非关系型数据的能力（类似于MyBatis）
Spring Boot：简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。
Spring Cloud Data Flow：Spring Cloud Data Flow 是一个用于定义、部署和管理数据流应用程序的开源工具，它可以轻松地将各种数据流集成起来，实现数据的实时处理和传输。
Spring Cloud：利用 Spring Boot 的开发便利性简化了分布式系统的开发，列如服务发现、服务网关、服务路由、链路追踪等。将市面上开发得比较好的模块集成进去，进行封装，从而减少了各模块的开发成本。换句话说：Spring Cloud 提供了构建分布式系统所需的“全家桶”。
Spring Hateoas：HATEOAS（Hypermedia as the engine of application state）是 REST 架构风格中最复杂的约束，也是构建成熟 REST 服务的核心。Spring 框架的子项目 HATEOAS 来开发满足 HATEOAS 约束的 Web 服务。Spring框架为我们提供了一个极其简单的HATEOAS实现。
Spring Rest Docs：Spring REST Doc 给出了创建和维护 REST API 文档的另外一种思路，也就是手写文档和自动生成相结合。
Spring LDAP：（Lightweight Directory Access Protocol），
Spring Session：session的管理责任委托给spring-session承担。当request进入web容器，根据request获取session时，由spring-session负责存存储器中获取session，如果存在则返回，如果不存在则创建并持久化至存储器中。
Spring Shell：Spring Shell是Spring生态中的一员，用于开发命令行应用程序，官网：https://projects.spring.io/spring-shell。 Spring Shell构建在JLine之上，集成Bean Validation API实现命令参数校验。从2.0版本开始，Spring Shell还可以超级方便地与Spring Boot进行集成，直接使用Spring Boot提供的一些超级实用的功能（如：打包可执行jar文件）。
Spring Kafka：Spring整合Kafka
Spring Statemachine：应用程序开发人员在Spring应用程序中使用状态机概念的框架
Spring IO PlatForm：Spring IO Platform，简单的可以认为是一个依赖维护平台，该平台将相关依赖汇聚到一起，针对每个依赖，都提供了一个版本号，这些版本对应的依赖都是经过测试的，可以保证一起正常使用。
Spring Roo：协助我们快速生成项目原型。
Spring Scala：Spring Scala是由Spring Attic团队维护的一个开源项目，旨在为Spring框架提供对Scala语言的更好支持。它提供了许多有用的工具和库，可以协助你在Spring应用中轻松地使用Scala。
Spring BlazeDS Integration：提供Spring和Adobe Flex技术集成的模块。在Spring BlazeDS Integration项目中，通过Spring BlazeDS模块的Blaze协议，将Flex客户端与Spring后端粘合起来，为Flex客户端与后端的通信提供了和Spring开发模式一致的编程模型。
Spring Loaded：实现修改类文件的热部署
REST Shell：是一个由Spring社区开发的轻量级命令行工具，旨在简化与RESTful服务的交互过程。作为一个面向开发者的神器，它利用Java和Spring Boot的强劲功能，让测试、调试及管理你的REST API变得极其便捷。
Spring XD：Spring XD（eXtreme Data，极限数据）是Pivotal的大数据产品。它结合了Spring Boot和Grails，组成Spring IO平台的执行部分。尽管Spring XD利用了大量现存的Spring项目，但它是一种运行时环境，而不是一个类库或者框架，它包含带有服务器的bin目录，你可以通过命令行启动并与之交互。运行时可以运行在开发机上、客户端自己的服务器上、AWS EC2上或者Cloud Foundry上。
Spring Social：Spring框架的扩展，可以协助Spring应用更方便的使用Spring Security。

2 Spring项目快速搭建

Spring项目搭建为了方便包的管理，一般使用Mavan或者Gradle进行项目管理。

2.1 Mavan使用

2.1.1 Maven简介

Apache Maven是由Apache软件基金会所所提供的一个软件项目管理及自动构建工具。它包含：一个项目对象模型、一组标准集合、一个项目生命周期、一个依赖管理系统、运行定义在生命周期阶段中插件目标的逻辑。

Maven是专门用于管理和构建Java项目的工具，它的主要功能有：

提供了一套标准化的项目结构
提供了一套标准化的构建流程（编译、测试、打包、发布…）
提供了一套依赖管理机制

依赖管理：

依赖管理实则就是管理你项目所依赖的第三方资源（jar包、插件…）
1.下载jar包
2.复制jar包到项目
3.将jar包加入到工作环境

2.1.2 Maven安装

（1）Maven安装配置

1.解压安装包apache-maven-3.9.1-bin.zip即安装完成
2.配置环境变量MAVEN_HOME为安装路径的bin目录
3.配置本地仓库：修改conf/settings.xml中的<localRepository>为一个指定目录
4.配置阿里云私服：修改conf/settings.xml中的<mirros>标签，为其添加如下标签：

<mirror>
    <id>alimaven</id>
    <name>aliyun maven</name>
    <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    <mirrorOd>central</mirrorOf>
</mirror>

（2）配置环境变量

1）点击系统变量的新建

Spring路径-01-Spring基础

2）变量名为MAVEN_HOME，变量值为maven安装路径

Spring路径-01-Spring基础

3）点击系统变量中的Path,单击编辑

Spring路径-01-Spring基础

4）添加环境变量%MAVEN_HOME%in添加完成

Spring路径-01-Spring基础

5）此时打开cmd窗口输入mvn -version出现如下结果表明配置成功。

Apache Maven 3.9.6 (bc0240f3c744dd6b6ec2920b3cd08dcc295161ae)
Maven home: D:WorkSpacesBraceapache-maven-3.9.6
Java version: 1.8.0_381, vendor: Oracle Corporation, runtime: D:AppJavajdk-1.8jre
Default locale: zh_CN, platform encoding: GBK
OS name: "windows 11", version: "10.0", arch: "amd64", family: "windows"

2.1.3 Maven元素解析-pom.xml

一个pom.xml中包含了许多标签，各个标签是对项目生命周期、依赖管理的配置。常用的主要有：

peoject：pom.xml的根标签，一个maven项目用一对标签包裹。
modelVersion:maven的版本
当前项目的坐标以及打包方式：

<groupId>：企业网址反写+项目名

<artifactId>：项目名-模块名

<version>：版本号+类型

版本号由三个整数表明，每个整数用“.”分隔，表明：大版本号.分支版本号.小版本号

类型：版本类型。主要有：snapshot快照版本(简化版本)、alpha内测版、beta公测版、release稳定版、GA正式发布版

<packaging>：打包类型，默认是jar，可以配置成war、zip、pom类型。

name：当前项目名
url：项目地址
description：项目描述信息
developers：开发者信息
licenses：项目许可证信息，用来发布时授予别人使用此项目的权利
organization：组织信息，企业信息

以上都是对这个maven项目的相关信息配置。

properties：属性值标签，也叫变量标签。与Ant中的property一样，可以通过这个标签包含一些属性并指定属性值。那么在pom.xml的其他地方，可以通过EL表达式访问变量的方法——${属性名} 来获取具体的属性值。一般这个用来作为整个pom.xml中需要重复使用的内容或者全局变量使用。
依赖标签

<dependencies>

    <!--一个依赖包-->
    <dependency>

       <!--通过坐标指定依赖包-->
        <groupId>        </groupId>
        <artifactId>      </artifactId>
        <version>        </version>

        <!--可选项：依赖范围。有六个可选值：常用compile/provided/test/runtime等-->
        <scope>一个范围</scope>
        <!--可选项：排除依赖传递：即：当前项目依赖当前配置的依赖包A时，如果这个依赖包又依赖其他包B，这里可以选择排除依赖的传递性，不下载导入B-->
         <exclusions>
            <exclusion>
              <!--被排除的依赖包坐标-->
              <groupId> </groupId>
              <artifactId> </artifactId>
              <version> </version>
            </exclusion>
         </exclusions>
    </dependency>
</dependencies>

依赖管理标签：主要用于制定父pom.xml，其他项目可以继承这个pom.xml，从而避免重复定义某些depency。

<depencyManagement>
    <depencies>
       <depency>
           依赖包的坐标...
       </depency>
    </depencies>
</depencyManagement>

build：项目支持标签，一般用来引入插件

<build>
    <plugins>
      <plugin>
         <!--插件坐标-->
         <groupId>         </groupId>
         <artifactId>         </artifactId>
         <version>         </version>

         其他设置...

      </plugin>
    </plugins>
</build>

parent：继承标签，用于继承父项目。
moudules：聚合标签，用于聚合多个maven项目，这样用某指令执行这个pom就会把聚合的各项目全部执行，同时处理多个项目。

示例：一个简单的构建JavaWeb项目的pom.xml如下：

<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/maven-v4_0_0.xsd">
  
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.test</groupId>
  <artifactId>WebApp</artifactId>
  <packaging>war</packaging>
  <version>1.0</version>
  
  <name>WebApp Maven Webapp</name>
  <url>http://maven.apache.org</url>
  
  <dependencies>    
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.2.1</version>
    </dependency>
    
    <!--commons-io为commons-fileupload的可选依赖包-->
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>1.3.2</version>
    </dependency>
  </dependencies>
  
  <build>
    <finalName>WebApp</finalName>
  </build>
</project>

2.2 Spring项目的搭建

Spring项目一般有以下三种搭建方式：

Spring Tool Suite 参考：https://spring.io/tools/sts/all
Net Beans 参考：http://netbeans.org/downloads
Intellij IDEA

2.2.1 Intellij IDEA方式搭建

使⽤ Maven ⽅式来创建⼀个 Spring 项⽬，创建 Spring 项⽬和 Servlet 类似，总共分为以下 3 步：

（1）创建⼀个普通 Maven 项⽬。

Spring路径-01-Spring基础

（2）添加 Spring 框架⽀持（spring-context、spring-beans）。

在项⽬的 pom.xml 中添加 Spring 框架的⽀持，xml 配置如下：

<dependencies>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.3.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>5.2.3.RELEASE</version>
    </dependency>
</dependencies>

（3）添加启动类。

最后在创建好的项⽬ java ⽂件夹下创建⼀个启动类，包含 main ⽅法即可。

3 Spring基础配置

3.1 Spring的依赖注入

3.1.1 基础知识

控制翻转（Inversion of Control-IOC）和依赖注入（dependency injection-DI）在Spring环境下是等同的概念，控制翻转是通过依赖注入实现的。所谓的依赖注入指的是容器负责创建对象和维护对象间的依赖关系，依赖注入的主要目的就是为了解耦，体现了一种“组合”的理念。

Spring IoC容器（ApplicationContext）负责创建Bean，并通过容器将功能类Bean注入到所需要的Bean中。Spring提供使用xml、注解、Java配置、groovy配置实现Bean的创建和注入。

无论是xml配置、注解配置还是Java配置，都被称为配置元数据，所谓元数据即描述数据的数据。元数据本身不具备任何可执行的能力，只能通过外界代码来对这些元数据进行解析后进行一些有意义的操作。Spring容器解析这些配置元数据进行Bean初始化、配置和管理依赖。

声明Bean的注解：

@Component组件，没有明确的角色。
@Service 在业务逻辑层（Service层）使用。
@Repository 在数据访问层（dao层）使用。
@Controller 在展现层（MVC—>SpringMVC）使用。

注入Bean的注解：

@Autowired：Spring提供的注解。

3.1.2 示例

（1）编写功能类Bean。

import org.springframework.stereotype.Service;

@Service //1
public class FunctionService {
    public String sayHello(String word) {
        return "Hello" + word + "!";
    }
}

代码解释 注解1：使用@Service注解声明当前FunctionService类是Spring管理的一个Bean。其中使用@Component、@Service、@Repository和@Controller是等效的，可根据需要选用。

（2）使用功能类的Bean

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

@Service //1
public class UseFunctionService {
    @Autowired //2
    FunctionService functionService;

    public String sayHello(String word) {
        return functionService.sayHello(word);
    }
}

代码解释 注解1：使用@Service注解声明当前UseFunctionService类是Spring管理的一个Bean；注解2：使用@Autowired将FunctionService的实体Bean注入到UseFunctionService中，让UseFunctionService具备FunctionService的功能。

（3）配置类

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

@Configuration //1
@ComponentScan("test") //2
public class DiConfig {
}

代码解释 注解1：@Configuration声明当前类是一个配置类；注解2：使用@ComponentScan，自动扫描包下所有使用@Service、@Component、@Repository和@Controller的类，并注册为Bean。

3.2 Java配置

3.2.1 基础知识

Java配置是通过@Configuration和@Bean来实现的。

@Configuration 声明当前类是一个配置类，相当于一个Spring配置的xml文件。
@Bean 注解在方法上，声明当前方法的返回值为一个Bean。

主要的原则是：全局配置使用Java配置（如数据库相关配置、MVC相关配置），业务Bean的配置使用注解配置（@Service、@Component、@Repository、@Controller）。

2. 示例

（1）编写功能类的Bean。

public class FunctionService {
    public String sayHello(String word) {
        return "Hello" + word + "!";
    }
}

(2) 使用功能类的Bean。

public class UseFunctionService {

    FunctionService functionService;

    public void setFunctionService(FunctionService functionService) {
        this.functionService = functionService;
    }

    public String sayHello(String word) {
        return functionService.sayHello(word);
    }
}

(3) 配置类。

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

@Configuration //1
public class JavaConfig {
    @Bean //2
    public FunctionService functionService() {
        return new FunctionService();
    }

    @Bean
    public UseFunctionService useFunctionService() {
        UseFunctionService useFunctionService = new UseFunctionService();
        useFunctionService.setFunctionService(functionService());//3
        return useFunctionService;
    }

//    @Bean 
    //4
//    public UseFunctionService useFunctionService(FunctionService functionService) {
//        UseFunctionService useFunctionService = new UseFunctionService();
//        useFunctionService.setFunctionService(functionService);
//        return useFunctionService;
    }
}

代码解释 注释1：使用@Configuration 注解表明当前类是一个配置类，这意味着这个类里可能有0个或者多个@Bean注解，此处没用使用包扫描，是由于所有的Bean都在此类中定义了。注释2：使用@Bean注解声明当前方法FuncionService的返回值是一个Bean，Bean的名称是方法名。注释3：注入FunctionService的Bean时候直接调用functionService(). 注释4：另外一种注入方式，直接将FunctionService作为参数给useFunctionService(),这也是Sping容器提供的极好的功能。在Spring容器中，只要容器中存在某个Bean，就可以在另外一个Bean的声明方法的参数中注入。

3.3 AOP

3.3.1 基础知识

AOP：面向切面编程，相对于OOP面向对象编程。 Spring的AOP存在的目的是为了解耦。AOP可以让一组类共享一样的行为。在OOP只能通过继承类和实现接口，来使代码的耦合度增强，且类继承只能为单继承，阻碍更多行为添加到一组类上，AOP弥补了OOP的不足。 Spring支持AspectJ的注解式切面编程。（1）使用@Aspect声明是一个切面。（2）使用@After、@Before、@Around定义建言（advice），可直接将拦截规则（切点）作为参数。（3）其中@After、@Before、@Around参数的拦截规则为切点（PointCut），为了使切点复用，可使用@PointCut专门定义拦截规则，然后在@After、@Before、@Around的参数中调用。（4）其中符合条件的每一个被拦截处为连接点（JoinPoint）。