Spring boot 全面学习笔记（1）

JAVAEE 回顾

Java EE 是一种企业应用的软件架构。

Java EE 与Web ：互联网从根本上改变了对企业软件的系统需求，软件需要处理来自互联网的大量请求，并要及时做出响应。
Java EE 与分布式应用： 20 世纪80 年代，个人计算机性价比逐渐达到了高端工作站和服务器的水准，使分布式计算应用迅速普及。SUN 在推出Java 后，紧接着推出了远程方法调用RMI,并在90 年代末期，以RMI 为通信基础构建了JavaEE 。
在相当长的一段时间里， Java EE 就是一种分布式应用，这让Java EE 战胜了CORBA 、. COM＋，但是也带来了巨大的系统交互开销（超出一个数量级的）。毕竟不是所有的企业应用和互联网应用都是分布式的，这让一些人认为JavaEE 架构有问题。然而这并不是Java EE 的错，在市场上， Java EE 需要迎合当时的分布式技术潮流。现在如果你不用分布式， Java EE 也同样提供了相关技术供你使用，如Local E JB 。
作为企业应用或者互联网应用的架构，总有如下功能需求， Java EE 有相应的规范实现与之对应。
- Web 支持：企业应用、互联网应用越来越多的是基于B / S 的结构， Java EE 对应的有Servlet 规范，规定了Web 容器、Servlet 组件，还设有JSP&JSTL 处理动态页面。
- 事务支持：提供事务管理器，支持管理事务，如单一数据库、多个数据库，以及数据库和其他资源的事务协作等。Java EE 里提供了JTA 事务API 和JTS 事务服务规范。事务支持也实现了分布式事务管理，管理多个数据库或者支持事务的资源。
- 消息服务：企业各个系统、系统模块之间通过消息服务进行并步交互， Java EE 提供了JMS 服务，用于系统间可靠的消息交互。
- 数据库持久层、Java EE 先有EJB 规范，后来又提出了更有实际操作性的JPA ，这些都是企业访问数据库常用的方法。
- Container：提供了WebContainer ，用于实现Servlet ，以及EJB Container ，实现EJB,Container 用于管理这些组件，并提供组件需要的服务，比如JTS 、JMS 等。

其他技术还包括如下所述的内容。

JWS ：这也是分布式系统交互的一种方式，是Java 实现的一种WebService 。
JAX-RS: Java EE 6 引入的新技术，通过阻ST 进行交互。
JNDI ：查找服务和对象的接口，如查找一个配置好的数据源。
JAXP / JAXB: XML 流行的时候，解析和绑定Ja va B ean 的XM L 工具。
JAX-RPC ：分布式系统交互的一种方式，通过RPC 方式调用。
JACC ：安全认证。
Java EE Application Server：提供了上述所有服务的Web 服务器，我们常用的Tomcat 、Resin ，只能算是Java EE Web 服务器，开源的JBoss 、商业的weblogic 等称为应用服务器。
综上所述， Java EE 提供了企业应用技术的实现规范，简化了企业应用和Web 开发，如下图所示:

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-meSveU2N-1577433226125)(C:\Users\wangxf\AppData\Roaming\Typora\typora-user-images\1577354972450.png)]$

RMI可参考https://www.jianshu.com/p/de85fad05dcb

RMI和RCP区别https://cloud.tencent.com/developer/article/1353191

JAVAEE缺点

过于复杂： Java EE 针对的是复杂的分布式企业应用，然而现实情况是大部分应用都比
较简单，复杂的架构带来了复杂的开发方式和部署方式（早期的Java EE 普通系统打包部署都需要数十分钟）
追求分布式：大部分应用并非都是Java EE 假定的分布式系统，像EJB 、JMS 、JWS等技术实现门槛又高又容易出错。Spring 曾经反对过这种分布式架构，只提供了容器管理，因此获得了巨大成功。大型应用采用分布式架构不可避免， Spring 提供了其他的技术支持，比如支持RestFul架构。
不能及时与流行开源技术结合：比如消息处理，除了有标准的JMS 支持，现在还有性能更好的RabbitMQ 和Kafka ，Java EE 并没有与之相应的标准，反而是Spring ，具有统一的实现消息处理模式，无论用的是JMS 、RabbitMQ ，还是性能更好的Kafka ，都能快速上手。
Java EE 应用服务器通常由商业公司提供，价格不菲，少有公司采用。管理应用服务器和部署应用对初学者和自学者有一定门槛。

从Spring到SpringBoot

认识一个事务最好的方式就是首先去了解它的历史。

Spring 框架是由Rod Johnson 在2001 年开始开发的一个开源框架，主要为了解决企业级应用程序开发的复杂性。

Spring 提倡“零”侵入设计原则，颠覆了传统的编程模式。
Spring 引人控制反转（ Inversion of Control, IoC ）的核心编程思想，控制反转还有一个名字叫作依赖注入（ Dependency Inversion, DI ），就是由容器来管理协同Bean 之间的关系，而非传统实现中，由程序代码直接操控。同时， Spring 还把面向切面编程（ AOP ）集成进来，使得AOP 的编程范式发扬光大。
Spring 从IoC 容器发展而来，通过不断集成AOP , MVC 、OR/Mapping 以及几乎你能想到的各项服务而提供完善的企业应用框架。目前大多数J2EE 项目都已经采用Spring框架。

2014 年4 月发布Spring Boot 1.0 。2014 年12 月发布Spring 4.1 .3

2015 年7 月发布Spring 4.2

2016 年6 月发布Spring 4.3

2017 年9 月发布Spring 5.0

2017 年11 月发布Spring Boot v2. O.O.M7

2018 年3 月1 日发布Spring Boot v2.0.0.Release ;

Spring核心技术

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ayARUl47-1577433226126)(C:\Users\wangxf\AppData\Roaming\Typora\typora-user-images\1577257670674.png)]$

Core 模块封装了框架依赖的最底层部分，包括资源访问、类型转换及一些常用工具类
Beans 模块中的主要组件是BeanFactory ，它是工厂模式的实现
Context 模块是一个配置文件，向Spring 框架提供上下文信息。
EL 模块提供强大的表达式语言支持。
Test 模块支持Junit 和TestNG 测试框架，而且还额外提供了一些基于S pring 的测试功
能，比如在测试Web 框架时，模拟Http 请求的功能。

核心技术可参考文章：https://blog.csdn.net/LUCKWXF/article/details/100881964

Spring 本身提供了两个最核心的技术一一IoC 容器和AOP 增强

在这里插入图片描述

loC Core Container: Spring Container 负责管理你的任意对象，并结合你对对象的描述进行初始化和加强。比如，对于一个用注解＠Controller 声明的对象， Spring 会认为这个对象是个Web Controller ，如果这个对象里的方法有＠RequestMapping 注解，则会将客户端发起的HTTP请求转化成Java 方法调用。
```
@Controller
public class HelloworldController {
@RequestMapping ("/sayhello .html")
public @ResponseBody String say(String name) {
return ” hello ” +name;
}
```
上面的例子中， Spring Container 在容器中初始化HelloworldController 实例后，对于客户端发起的／sayhello.html 请求，会执行say 方法，并自动将请求参数按照say 方法声明的名称一一对应上。

Spring 通常提供一些＠Contra ller 、＠Service 、＠Component 、＠ Configuration 注解，只有使用这些注解的类才会引起Spring容器的注意，并根据注解含义来管理和增强对象。

Spring 可以管理和增强任意对象，如常见的＠ Service 注解对象，通常用来处理业务逻辑，Spring Container 往往会增强这类对象的事务控制能力。

容器管理还可以为被管理的Bean 提供其他被管理和被增强的Bean ，如一个己经被＠ Service注解的UserService 类，在HelloworldController 类中，使用＠ Auto wired 自动注入这个实例：

@Controller
public class HelloworldController {
@Autowired UserService userService;
}

AOP ：上面提到的对象增强离不开AOP 技术， AOP (Aspect Oriented Programming ）指面向切面编程，通过预编译方式或者运行时刻对目标对象动态地添加功能。AOP 分离了企业应用的业务逻辑和系统级服务，比如事务服务，还有应用系统的审计、安全访问等代码。

AOP (Aspect-Oriented P rogramming ，面向切面编程）提供了另外一种思路来实现应用系统的公共服务。AOP通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

原文链接：https://blog.csdn.net/LUCKWXF/article/details/100881964

AOP 之所以能得到广泛认可，主要是因为它将应用系统拆分分了2个部分：核心业务逻辑（Core business concerns）及横向的通用逻辑，也就是所谓的切面Crosscutting enterprise concerns。例如，所有大中
型应用都要涉及到的持久化管理（Persistent）、事务管理（TransactionManagement）、权限管理（Privilege Management）、日志管理（Logging）和调试管理（Debugging）等。使用AOP 技术，可以让开发人员只专注核心业务，而通用逻辑则使用AOP 技术进行横向切入，由专人去处理这些通用逻辑，会使得任务简单明了，提高开发和调试的效率。

Spring缺点

随着Spring 功能的不断丰富，版本的不断迭代发展， Spring 框架渐渐暴露出了一些问题和弊端。例如太多样板化的配置、烦琐复杂的使用过程等，我们不仅需要维护程序代码，还需要额外去维护相关的配置文件。Spring 项目的配置越来越复杂，让人难以承受。大量的XML 配置以及复杂的依赖管理使得人们不得不去解决这个问题一－Spring Boot 由此应运而生。

使用门槛升高，要入门Spring 需要较长时间。
对过时技术兼容，导致使用复杂度升高。
XML 配置已经不是流行的系统配置方式。
集成第三方工具时候，程序员还要考虑工具之间的兼容性。
系统启动慢，不具备热部署功能，完全依赖虚拟机或者Web 服务器的热部署。

传统项目：整合SSH或者SSM，考虑配置文件、JAR包冲突问题、整合起来繁琐，打包方式:打包成一个War放入tomcatWebapps目录进行执行。

演示传统SSH整合项目。

什么是Spring Boot?

SpringBoot是一个快速开发框架，能够帮助我们快速整合第三方框架（Maven依赖关系 ## Maven继承) ，完全采用注解化，简化XML配置；内嵌Http服务器（Tomcat、Jetty)，默认嵌入Tomcat服务器。最终以Java应用程序进行执行。

SpringBoot项目中没有Web.xml

原理:（Maven依赖关系 ## Maven继承）完全采用注解化，Spring3.0之后采用注解方式启动SpringMVC、内嵌HTTP服务器 JAVA创建Tomcat。

Spring Boot优点

相比于Spring, Spring Boot 具有以下优点：
实现约定大于配置，是一个低配置的应用系统框架。不像Spring 那样“地狱般的配置体验”， Spring Boot 不需要配置或者极少配置，就能使用Spring 大量的功能。
提供了内置的Tomcat 或者Jetty 容器。
通过依赖的jar 包管理、自动装配技术，容易支持与其他技术体系、工具集成。
支持热加载，开发体验好。也支持Spring B oot 系统监控，方便了解系统运行状况。

Spring Boot核心组件

在这里插入图片描述

spring-boot
Spring Boot 核心工程。
starters
是Spring Boot 的启动服务工程。spring-boot 中内置提供的starter 列表可以在SpringBoot 项目源代码工程spring-boot/spring-boot- starters 中看到。这些starters 的使用例子，在源码中的spring-boot/spring-boot-samples 工程中。
autoconfigure
是Spring Boot 实现自动配置的核心工程。
actuator
提供Spring Boot 应用的外围支撑性功能。比如：应用状态监控管理、应用健康指示表、
远程shell 支持、metrics 支持等。

tools
提供了Spring Boot 开发者的常用工具集。诸如， spring -boot-gradle-plugin 、spring-bootmaven-plugin 就在这个模块里面。
cli
是Spring Boot 命令行交互工具，可用于使用Spring 进行快速原型搭建。可以用它直接运行Groovy 脚本。如果你不喜欢Maven 或Gradle ，可用CLI ( Command Line Interface ）来开发运行Spring 应用程序。可以使用它来运行Groovy 脚本，甚至编写自定义命令。

SpringBoot与SpringCloud区别

在这里插入图片描述

使用Spring Boot 构建一切服务。Spring Boot 旨在让你尽可能快地启动和运行，并极简化Spring 配置。
使用Spring Cloud 协调一切服务。Spring Cloud 使得实现分布式的、微服务风格的架构更加简单。Spring Cloud 数据流提供了一个统一的服务，用于创建地址流和基于ETL 的数据处理模式、可组合的数据微服务。
使用Spring Cloud Data Flow 连接一切服务。Data Flow 将企业服务连接到任何移动设备、传感器、可穿戴设备、汽车等的互联网上。

SpringBoot，其实是一个快速开发框架，能够帮助我们快速整合（第三方常用框架），完全采用注解化、简化XML配置，最终以JAVA应用程序进行执行。

SpringCloud是一套目前完整的微服务解决框架，功能非常强大。注册中心、客户端调用工具、服务治理（负载均衡、断路器、分布式配置中心、网关、服务链路等。）

关系：

SpringBoot+SpringCloud是微服务

SpringBoot 实现快速开发。

微服务通信技术HTTP+json(restful)轻量级

SpringBoot WEB组件默认集成SpringMVC，SpringCloud依赖与SpringBoot实现微服务，使用SpringMVC编写微服务接口。

总结：SpringCloud与SpringBoot区别

微服务开发-------------RPC远程通讯技术、服务治理

核心区别：SpringCloud 是微服务框架 RCP远程调用

单纯的只是集成Springboot实现快速开发

SpringBoot与SpringMVC关系

SpringBoot web组件集成SpringMVC框架。

但是SpringBoot启动SpringMVC的时候没有传统配置文件。那么SpringBoot如何启动SpringMVC?

—SpringMVC3.0之后产生注解

—SpringMVC在3.0支持注解方式启动SpringMVC

约定优于配置极简化理念

约定优于配置（ Convention Over Configuration COC)。也被称为按照约定编程，是一种软件设计范式，旨在减少软件开发人员需做决定的数量，获得简单的好处，而又不失灵活性。

例如， Spring 通过使用约定好的注解来标注Spring 应用中各层中的Bean 类：
口＠Component－一一标注一个普通的Spring Bean 类。
口＠Controller「一标注一个控制器组件类。
口＠Service一一标注一个业务逻辑组件类。
口＠Repository一一标注一个DAO 组件类。
其实Java 的成功， Spring 的成功， XML 的成功， Maven 的成功等，都有其必然性，因为它们的设计理念都包含个很简单但很深刻的道理一一那就是“通用” 。为什么通用？因为遵循约定。

创建第一个SpringBoot项目

新版本SpringBoot完全基于SpringBoot2.0开发，JDK环境必须1.8以上。

①创建Maven工程编写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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.newchaintech</groupId>
  <artifactId>springboot2.0-helloworld</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  
  <!-- spring-boot-starter-parent 整合第三方常用框架依赖信息 (各种依赖信息)-->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.0.RELEASE</version>
  </parent>
  <dependencies>
  <!-- spring-boot-starter-web 是SpringBoot 整合SpringMVC Web 实现原理：Maven依赖继承关系-->
  <!-- 相当于把第三方常用Maven依赖信息，在parent项目中已经封装好了，使用springboot提供依赖想你想关联整合的jar包-->
  <!-- springboot中快速原理（Maven子父依赖关系）,springboot对常用依赖信息进行封装 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
      <!-- 为什么不要写版本号：在parent里面已经封装好了 -->
    </dependency>
  </dependencies>
  <!-- springcloud依赖于springboot 实现微服务 ### springboot
  默认集成springMVC组件 springcloud 使用springMVC编写http接口
  微服务通信接口（http+json格式）-->
</project>

②编写Controller

package com.newchaintech.member.controller;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * springboot2.0第一个案例
 * @author 
 *
 */

@RestController
@EnableAutoConfiguration
public class MemberController {
//@RestController注解表示该类中的所有方法返回JSON格式；@Controller+@ResponseBody
//@RestController是spring 提供的吗？ 答：不是；springMVC 4.0就有为微服务提供返回JSON格式	
//spring启动原理：springmvc注解方式启动 内置http服务器（Tomcat)
//@EnableAutoConfiguration注解作用：扫包范围默认当前类里面
	@RequestMapping("/memberIndex")
	public String memberIndex() {
		
		return "欢迎访问！springboot2.0全新版本教程######";
				
	}
	
    public static void main(String[] args) {
	   //整个程序入口启动springboot项目，创建内置tomcat服务器，使用TOMCAT加载springmvc 注解启动类
    	SpringApplication.run(MemberController.class,args);
    }
	
}

上面的 @EnableAutoConfiguration 只能扫描当前类，第二种做法是加上扫描包，使用@ComponentScan注解,将启动类抽取出来，比如建立一个App.class类。

package com.example.member.controller;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;

/*
 * 将启动的代码抽取出来单独运行
 */
@EnableAutoConfiguration
@ComponentScan("com.example.member.controller")
public class App {
	//整个程序的入口启动springBoot 项目创建内置tomcat服务器，使用Tomcat加载SpringMVC注解启动类
   public static void main(String[] args) {
	SpringApplication.run(App.class, args);
   }
}

上面的@ComponentScan 缺点：如果扫包多的话是十分麻烦，比如增加了order.controller包。

@ComponentScan(basePackages= {"com.example.member.controller","com.example.order.controller"})

@SpringBootApplication注解

等于与@EnableAutoConfiguration+@ComponetScanto同级包（包含子包）和当前包。

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/*
 * 将启动的代码抽取出来单独运行
 */
//@EnableAutoConfiguration
//@ComponentScan(basePackages= {"com.newchaintech.member.controller","com.newchaintech.order.controller"})
@SpringBootApplication
public class App {
	//整个程序的入口启动springBoot 项目创建内置tomcat服务器，使用Tomcat加载SpringMVC注解启动类
	//@SpringBootApplication注解	等于与@EnableAutoConfiguration+@ComponetScan 同级包（包含子包）和当前包。
   public static void main(String[] args) {
	SpringApplication.run(App.class, args);
   }
}

@SpringBootApplication 注解

总结：@SpringBootApplication 注解的定义：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
@Filter(type = FilterType.CUSTOM, classes= TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter. class) } )
public @interface SpringBootApplication { ... }

@SpringBootApplication 注解实际上封装了以下三个注解：

＠SpringBootConfiguration ：配置类注解。
＠EnableAutoConfiguration ：启用自动配置注解。
＠ComponentScan ：组件扫描注解。

下面分别说明：

＠SpringBootConfiguration ：与＠Component 注解是一样的。＠SpringBootConfiguration 其实是Spring Boot 包装的＠Configuration 注解。而＠Configuration 注解使用的又是＠Component 注解：我们知道，＠Component 注解的功能是把普通POJO 实例化到Spring 容器中，相当于配置文件中的＜bean id =””class ＝””／＞
@ EnableAutoConfiguration 这个注解是Spring Boot 的最核心注解。首先我们看它的定义：
```
@Target(ElementType TYPE)
@Retention(RetentionPolicy . RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationimportSelector.class)
public @interface EnableAutoConfiguration ( ... }
```
其中，导入配置类注解＠ Import 标识导入＠ Configuration 标注的配置类。＠Import 用来整合所有在＠ Configuration 注解中定义的Bean 配置。这与我们将多个XML 配置文件导人到单个文件的场景一致。＠ Import 注解实现了相同的功能。使用＠ EnableAutoConfiguration 注解可以启用Spring 应用程序上下文的自动配置，Spring Boot 会去尝试猜测和配置你可能需要的Bean 。自动配置类通常是根据类路径中你定义的Bean 来推断可能需要怎样的配置。

＠ ComponentScan 组件扫描注解＠ ComponentScan

提供的功能与Spring XML 配置文件中的＜ context:component- scan ＞元素等价。对应＠ ComponentScan 注解的处理类是ConfigurationClassParser 。@ComponentScan 告诉Spring 去哪个package 下面扫描Spring 注解。Spring 会去自动扫描这些被Spring 注解标注的类，并且将其注册到Bean 容器中。

XML 配置与注解自己置

本节简单对比一下传统的Spring XML 配置与基于JavaConfig 的注解配置Bean 的两种方式。
Spring 对于Bean 的配置有两种方式： XML 配置，注解配置。

XML 配置
优点：可以在后期维护的时候适当地调整Bean 管理模式，并且只要遵循一定的命名规
范，可以让程序员不必关心Bean 之间的依赖关系。
缺点：系统越庞大， XML 配置文件就越大；关系错综复杂，容易导致错误。
2 . 注解配置
优点：配置比较方便，程序员只要在service 层代码设置即可实现，不需要知道系统需
要多少个Bean ，交给容器来注入就好了。
缺点：当你要修改或删除一个Bean 的时候，你无法确定到底有多少个其他的Bean 依赖于这个Bean 。（解决方法：需要有严格的开发文档，在修改实现时尽可能继续遵守相应的接口规则，避免使其他依赖于此的Bean 不可用。）

深入理解Spring Boot自动配置

1、传统SSM开发过程

①我们需要小心翼翼地配置pom.xml 中的各种项目依赖及其版本保证jar 包不冲突。

这个pom.xml 将是一个很庞大的依赖配置，动辄上百行。这么多的依赖，各种版本号也都
必须要对得上，不能发生版本不兼容的情况。

②我们还需要仔细配置Spring 上下文spring.xml 文件。

这个Spring 配置文件是Spring 的BeanFactory 工厂进行Bean 生产、依赖关系注入（装配）及Bean 实例分发的“图纸总纲” 。

Spring 配置文件是一个或多个标准的XML 文档，。如果在web.xml 中没有显式指定ContextConfigLocation。将会使用XmlWebApplicationContext 的默认的配置／WEB-INF/applicationContext.xml 它是Spring 的默认配置文件。

web.xml 文件是用来初始化整个项目的配置信息的。比如Welcome 页面、servlet 、
servlet -mapping 、filter 、listener 、启动加载级别等。web . xml 又叫部署描述符文件，是
在Servlet 规范中定义的，是web 应用的配置文件。

web.xml 的加载顺序是：
<context -param＞一－＞＜ listener> －→ ＜ filter ＞一－＞

<web-app version="2.4" 
	xmlns="http://java.sun.com/xml/ns/j2ee" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
	http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
< !- 配置Spring -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring.xml</param-value>
</context-param>
</web-app>

③如果是Java Web 项目的开发，通常还需要配置SpringMVC 的上下文spring-mvc.xml

SpringMVC 的上下文配置文件主要是：
org . sprigframework.web.servlet DispatcherServlet这个DispatcherServlet 类在初始化过程中使用。DispatcherServlet 提供Spring Web MVC的集中访问点，负责职责的分派，而且与Spring IoC 容器无缝集成，从而可以获得Spring的所有好处。我们需要在spring-mvc.xml 中配置默认的注解映射的支持、自动扫描包路径、视图模板引擎等等一系列配置，完整的spring-mvc . xml 配置文件内容参考示例工程源代码。

在Web 应用中的web.xml 中通常还需要配置DispatcherServlet ，在应用程序目录中的classpath: spring- mvc . xml 配置springMVC 的配置文件位置。

例如：

 <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
  
<!-- 指定Spring Bean的配置文件所在目录。默认配置在WEB-INF目录下 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>WEB-INF/config/applicationContext.xml</param-value>
    </context-param>
   

<!--SPRING MVC 配置-->
    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>WEB-INF/config/spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springMvc</servlet-name>
        <url-pattern>/</url-pattern>
        <!--注意/和/*的区别-->
    </servlet-mapping>

这样， Spring Web MVC 框架将加载“ c l asspath : spring-mvc.xml ”来进行初始化上下文
而不是约定的默认文件路径“／WEB - INF/ [ servlet 名字］- servlet.xml ” 。

原理：

原来Spring 是父容器， Spring MVC是子容器，子容器可以访问父容器的bean,父容器不能访问子容器的bean。

那么，有没有一种方案，可以把上面这些繁杂费时费力的重复性劳动“一键打包、开箱即用”？
接下来，我们就逐步展示Spring Boot 是怎样通过自动配置和提供一系列开箱即用的启动器starter 来封装上面的复杂性使其简单化的。

2、Spring Boot 自动配置原理

①Java 配置

在整个Spring Boot 应用程序中，我们将看不到一个传统意义上的Spring XMI 配置文
件。其实，在Spring3.x 和Spring4.x 中就出现了大量简化XML 配置的解决方案。例如：

组件扫描（ Component Scan ) : Spring 去自动发现应用上下文中创建的Bean 。
自动装配（ Autowired ) : Spring 自动创建Bean 之间的依赖。
通过JavaConfig 方式实现Java 代码配置Bean 。

下面是一个使用Java Config 方式配置Thymeleaf 视图模板引擎的代码示例：

@Configuration
@ComponentScan(basePackages = { "com.easy.Spring Boot ” })
@EnableWebMvc II 启用WebMVC 配置（关于WebMVC 的自定义配置我们将在后面章节中介绍）
public class WebMvcConfig extends WebMvcConfigurerAdapter
@Bean
public TemplateResolver templateResolver() ｛ ／／ 配置模板解析器
TemplateResolver templateResolver =new ServletContextTemplateResolver();
templateResolver.setPrefix （ ”／WEB－工NF/views ／”） ；
templateResolver.setSuffix ( ”.html “);
templateResolver.setTemplateMode (”HTML5 ”) ;
templateResolver.setCacheable(false);
return templateResolver ;
@Bean
public SpringTemplateEngine templateEngine() ｛／／配置模板引擎
SpringTemplateEng 工ne templateEngine = new SpringTemplateEngine();
templateEngine . setTemplateResolver(templateResolver() );
return templateEngine ;
@Bean
public ThymeleafViewResolver v工ewResol ver () （／／配置视图解析器
ThymeleafViewResolver thymeleafViewResolver = new ThymeleafView
Resolver() ;
thymeleafViewResolver setTemplateEngine(templateEngine());
thymeleafViewResolver.setCharacterEncoding( " UTF-8 ”);
returηthymeleafViewResolver;
@Override
publiC void addResourceHandlers(ResourceHandlerRegistry registry)
                                           registry addResourceHandler （ ” ／ resources ／ ＊食’＇ ） .addResourceLocations
( ” I resources I " ) ;
@Bean(name =”messageSource ”)
public MessageSource configureMessageSource () （／／消息源配置
ReloadableResourc eBundleMessageSource messageSource ＝ ηew Reloada
bleResourceBundleMessageSource() ;
messageSource.setBasename ( ”c lasspath :messages ” ) '
messageSource . setCacheSeconds(S) ;
messageSource.setDefaultEncoding ( ” UTF- 8 ” ) ;
return messageSource;
 }
 }

在WebMvcConfig.java 配置类中，我们做了如下的配置：

将它标记为使用＠Configuration 注释的Spring 配置类。
启用基于注释的Spring MVC 配置，使用＠EnableWebMvc 。
通过注册TemplateResolver 、SpringTemplateEngine 、ThymeleafViewResolver Bean
来配置Thymeleaf View Resolver 。
注册的ResourceHandlers Bean 用来配置URI/resources／材静态资源的请求映射到／
resources／目录下。
配置的MessageSource Bean 从classpath 路径下的ResourceBundle 中的messages{
country-code} .properties 消息配置文件中加载i 18n 消息。
这些样板化的Java 配置代码比XML 要更加简单些，同时易于管理。而Spring Boot则是引入了一系列的约定规则，将上面的样板化配置抽象内置到框架中去，用户连上面的Java 配置代码也将省去。

②条件化Bean

1 . 条件注解＠Conditional

条件注解是根据特定的条件来选择Bean 对象的创建。条件注解根据不同的条件来做出不同的事情（简单说就是if else 逻辑）。

③组合注解

组合注解就是将现有的注解进行组合，生成一个新的注解。使用这个新的注解就相当
于使用了该组合注解中所有的注解。这个特性还是蛮有用的，例如Spring Boot 应用程序的
人口类注解＠Spring BootApplication 就是典型的例子。

早期版本的Spring Boot 中，用户需要使用如下三个注解来标注应用人口main 类：
＠Configiration
＠EnableAutoConfiguration
＠ComponentScan
在Spring Bootl .2.0 中只需用一个统一的注解＠Spring BootApplication 。

3、Spring Boot 自动配置过程

Spring Boot 内置自动配置原理是怎样的呢？这一切都在＠Enab leAutoConfiguration 这
个注解里：

@Target(ElementType.TYPE)
@Retention(Retent 工onPolicy.RUNTiME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration

其中的核心注解是＠Import(EnableAutoConfigurationlmportSelector.class），借助EnableAutoConfigurationlmportSelector 、＠EnableAutoConfiguration 、Spring Boot 应用将所有符合条件的＠Configuration 配置类都加载到当前Spring 容器中一一就像一只“八爪鱼”一样。具体的实现是使用了Spring 框架中原有的一个

工具类SpringFactoriesLoader 。这样，＠EnableAutoConfiguration 就可以智能实现Bean 的自动配置。

SpringBoot访问静态资源

访问js、css、图片等静态资源.

SpringBoot要求：静态资源存放在resources。

默认配置

Spring Boot默认提供静态资源木目录位置于classpath下，目录名称需符合如下规则：

/static

/public

/resources

/META-INF/resources

举例子：我们可以在src/main/resources/目录下创建static，在该位置放置一个图片文件。程序启动后尝试访问

http://localhost:8080/D.jpg 。如能显示图片，配置成功.

全局捕获异常

原理：全局捕获异常使用AOP技术，采用异常通知。

@ControllerAdvice ，这是一个增强的 Controller。可以实现三个方面的功能：

全局异常处理
全局数据绑定
全局数据预处理

全局捕获异异常：应用场景：

演示例子：

package com.newchain.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
 * 全局捕获异常例子
 * @author wangxf
 *
 */

@RestController
public class ErrorController {
	
	//全局捕获异常使用AOP技术，采用异常通知。
	//如果每个方法加上try，当然不好啦。
	@RequestMapping("/getUser")
	public String getUser(int i) {
		int j=1/i;
		return "success"+j;
	}
	

}

捕获异常类：

package com.newchain.error;

import java.util.HashMap;
import java.util.Map;

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * 全局捕获异常案例
 * @author wangxf
 *
 */

@ControllerAdvice(basePackages="com.newchain.controller")
public class GlobalExceptionHandler {
    @ExceptionHandler(RuntimeException.class)
	@ResponseBody
	 public Map<String,Object> erroResult (){
		 
		Map<String,Object> erroResultMap=new HashMap<String,Object>();
		erroResultMap.put("erroCode", "500");
		erroResultMap.put("erroMsg", "系统错误！");
		
		return erroResultMap; 
	 }
}

沙漠之鹰007

发布了40 篇原创文章 · 获赞 8 · 访问量 1万+

私信关注