陈龙
我回答的内容比较长，修订补充了好几次，可能还会继续完善，耐心看。有任何疑问都可以在评论区提出来，我会解答。
本问题下所有其他回答都没有提到核心区别，因为所有人都在以一个非常狭小的视野观察问题然后得出结论的。
Spring Boot 没有颠覆 Java EE 开发，但是我的回答会颠覆你对 Spring Boot 的认知。
我们先说说 Spring Boot 和 SSM 本质上的区别
SSM 是什么？是三个臭皮匠 (裨将)，Spring IoC、Spring MVC、Mybatis 的组合。SSM 限定死了你只能开发 Java Web 应用，而且 MVC 框架必须用 Spring MVC，持久层必须用 Mybatis，无他！我说的是 SSM 包含这些啊，没说你不能在这三个基础上自己加其他框架和库上去。
Spring Boot 呢？诸葛亮。有了诸葛亮，你用兵的可选方案更多，不管用哪几员将军，出师更顺利。Spring Boot 没有和任何 MVC 框架绑定！没有和任何持久层框架绑定！没有和任何其他业务领域的框架绑定！
你开发 Web 应用可以用 Spring Boot。用 spring-boot-starter-web 就帮你配置好了 Spring MVC。你不想用 Spring MVC 了，换成 Spring WebFLux(用 spring-boot-starter-webflux) 写响应式 Web 应用可以吗？当然可以，而且这个是 Spring 5 主推的新 Web 框架。
你不开发 Web 应用，只实现纯粹的数据层业务，开发 Spring Cloud Stream 和 Task 也可以。
数据持久层，你可以用 Spring Data 项目下的任何子项目 (JPA\JDBC\MongoDB\Redis\LDAP\Cassandra\Couchbase\Noe4J\Hadoop\Elasticsearch…)，当然用非 Spring 官方支持的 Mybatis 也可以。只要用上对应技术或框架的 spring-boot-starter-xxx 就可以了。
但是必须要知道，Spring Boot 提供的只是这些 starters，这些 Starter 依赖了 (maven dependence) 对应的框架或技术，但不包含对应的技术或框架本身！
这就是很多人用 “全家桶” 这个词来比喻 Spring Boot 的错误之处。肯德基麦当劳的全家桶里面包含了鸡腿、鸡翅、鸡块，这些东西都是包含在里面的，而且是不可选择的。你吃的完是这些，吃不完也是这些。你喜欢吃其中几样，也可能不喜欢吃其中几样。但是 Spring Boot 不是啊，Spring Boot 没有包含 Spring MVC，没有包含 Mybatis，只有他们对应的 starters。
一个更恰当的比喻是，Spring MVC、Spring Data、Websocket 这东西对应电脑硬件的显卡、声卡、硬盘、网卡。Spring Boot 提供的 Starters 对应这些硬件的驱动。只要你在主板上插上了这些硬件，Spring Boot 提供的对应驱动就能让能让你享受到即插即用 (Plug & Play) 的体验。Spring Boot 提供的是驱动，没有包含显卡、声卡这些硬件本身，这些驱动能够让你 DIY 的电脑顺畅的引导 (boot) 并运行起来。
很多 Java 服务器端的常见第三方框架，Spring Boot 都能用 Convention over Configuration 的方式帮你默认配置好。
具体支持什么看这里：
上面官方文档的列表只给出了 Spring Boot 官方提供的 starters，其他第三方自己提供 (例如 Mybatis 的 starter) 的没有包含在这个列表里。
前几天 https://start.spring.io/ 改版了，也可以去看看：
红框里的 Dependency 是空的，没有限制你必须用哪一个，Web 都是可选的。而且你输入 Web，会有 Spring MVC 和 Spring WebFlux 让你选。
上图下拉列表中，第一个 Web 就是 Spring MVC，第二个 Reactive Web 就是 Spring WebFLux。本文后面我们还会讲到。
关于 http://start.spring.io，也就是 Spring Initializr，看我回答的另外一个问题，非常简单：
spring mvc+hibernate+spring 开发框架搭建？
其他答案提到的：配置方便 (也就是我上面说的 Convention over Configuration) 只是表象，其实 CoC 一直都是 Spring 贯彻的理念，只是 Spring Boot 又把它提高到了一个新的高度。
Spring Boot 的最核心理念就体现在名字上，Spring 就不说啦，那 Boot 是啥意思啊？
Boot 是引导启动的意思，Windows 安装启动的过程不就需要引导盘 (boot disk 或 bootable usb) 吗？
类似的，前端有一个 Bootstrap，也是这个意思，让你快速搭建前端 UI。上面提到的那个 Spring Initializr，打开页面，看左上角，写的什么？Spring Initializr Bootstrap your application。
如果一家公司一直用 SSH/SSM，用了若干年了，经历了大大小小几个项目，基本上配置都已经好了，早就形成了自己的一套默认配置。国内大多数中小公司，新项目的启动就是把上一个项目 Copy 过来改！还需要用啥 Spring Boot？在这种情况下，三个臭皮匠就顶上诸葛亮了！
但是如果你的新项目需要用到以前没整合过的技术呢？比如数据库要用 MongoDB 了，也许还用到 Redis，可能还需要用 Spring Security，估计还要上 Kafka 消息队列，还可能要用 Websockets。你的项目怎么才能平稳、顺利、快速启动？手动配置这些东西可能就要花不少时间，而且还不一定配置的好。
明白我上面说的那些，很多问题都没必要问了。例如我回答过的这些问题：
可以不学 spring 其他，直接学 spring boot 吗？spring boot 与 spring mvc 的区别是什么？熟悉使用 Springboot，还有必要学习 SpringMVC 么？
这个问题下原来赞数最多回答推荐的那本书我没看过，但是之前就知道这本书。我看到副标题 —Java EE 开发的颠覆者，就误导了入门读者，传递了错误观念，仅仅是为了自己的销量。
这个问题下有人不是比喻 Spring Boot 和 SSM 之间是自动挡和手动挡的关系吗？有点像。但我还是更喜欢我在这个回答里的比喻：
哪些企业或项目在用 Spring boot, 或者它会在多大程度上替代 Spring?
从马车到汽车是交通出行的颠覆，从燃油车到纯电动车是能源利用的颠覆，从人工驾驶到 AI 智是驾驶方式的颠覆。但，只是给传统汽车改成自动挡、加装一键启停、无钥匙进入、自动跟车、车道偏离预警，我觉得不算颠覆。
**这个” 颠覆 “给人的感觉就是：Spring MVC 不用学了，Spring 其他都不用学了，Spring Boot 颠覆了他们的，取代他们的，包含了他们以前所有的功能。**然后就误导出了上面那些问题。
我们再看看这个问题下其他答案
回答 1：两个一样的，只不过是 springboot 省去了很多配置
怎么可能一样呢？如果一样，大部分公司都没必要迁移到 Spring Boot。因为上面说了，只要做了几个项目，基本也就把 SSM 配置的差不多了。每个项目都 Copy 套用就可以了。
回答 2：Spring Boot 就像一个脚手架一样 能让你快速的搭建项目 他不是替代 SSM 的 至于返回什么 完全看前端需求和文档规定吧
Spring Boot 就像一个脚手架，但绝对不是一个脚手架。什么是脚手架？我们都见过，就是建筑工地盖楼房的时候外面那一层钢管搭建的架子，还有一层绿网，就是方便构建楼房。但是楼房竣工以后，脚手架是要被拆掉的，不会作为物业的一部分交给业主。软件开发中的脚手架也是类似的，帮助快速搭建项目，而脚手架不会作为最终交付成果的一部分。
你用了 Spring Boot，那么 Spring Boot 以及其他 starter 的 jar 都会最终进入你打包编译的 jar 里，作为你成果的一部分。
那么 Spring 体系当中，有没有真正的脚手架呢？有的，就是答案上面截图的 http://start.spring.io，它叫做 Spring Initializr Bootstrap your application，就是通过页面上的操作，很快帮你生成搭建好一个初始化好的 Spring Boot 应用。但是 Spring Initializr 自己不会进入你最后打包的 jar，Spring Initializr 是 Spring Boot 应用的一个简单脚手架工具。
怎么又是一个 “简单” 的脚手架工具了？因为还有 Spring Boot Cli 啊。Cli 是 Command Line Interface 的缩写，就是命令行工具。Spring Boot Cli 通过命令行交互的方式提供了脚手架功能，你可以用它初始化一个 Spring Boot 项目，也可以用它完成打包 jar 的工作。
Theinitcommand lets you create a new project by using start.spring.io without leaving the shell
—Spring Boot 文档
例如运行 spring init：
$ spring init --dependencies=web,data-jpa my-project
Using service at https://start.spring.io
Project extracted to '/Users/developer/example/my-project'
就完成了在 http://start.spring.io 中创建项目的工作。
Spring Boot 不是替代 SSM 的，这个是对的。因为答案上面解释过了，Spring Boot 没有和任何 Web MVC 绑定，没有和任何数据持久化绑定。Spring Boot 自己根本无法完成 SSM 能完成的工作，需要其他 starter 作为桥梁，自动帮你配置好对应的框架才行。
回答 3：springboot 采用 约定大于配置 的方式，简化了大量的 xml 配置，真正做到了[开箱即用]。减少了 web 开发的难度
Spring Boot 是采用 约定大于配置 (就是 Convention over Configuration)，简化了大量的 XML 配置。难道在 Spring Boot 出来以前 Spring Framework 或者其他 Spring 体系下的框架就没有采用 CoC 吗？就没有提倡用 Java Annotation 来简化配置吗？ CoC 一直就是 Spring 所倡导的，只是 Spring Boot 更进一步发扬光大了！
真正做到开箱即用？没有吧，那还需要 Spring Initializr 干嘛？或者还需要手动配置 POM 干嘛？还是要做一定定制化的。如果论开箱即用 (Out of Box)，我答案里说的传统公司的流程才是开箱即用。新项目 Copy 老项目就算开箱了，直接上去改就算开始用了。
回答 4：SSM：面相 XML 编程。SpringBoot：面相注解编程
Spring Boot 出现以前，Spring Framework 已经在推荐 Java Annotation 的配置方式了，在所有的文档里都会同时介绍注解和 XML 两种配置方式，并且优先介绍注解的方式。
回答 5：ssm 是自己买家具装修。spring boot 是全屋定制
SSM 不是自己买家具，而是住酒店，酒店房间里的东西就这些，没得换。你只能自己带一些小件日用品。SSM 这家酒店你不喜欢，那就换 SSH 那家去。Spring Boot 是全屋定制，这个形容不错。而且家具种类齐全，品种多样。你只要下单就可以，包送货、包安装调试。
回答 6：没有区别，springboot 只是提供了一套默认配置，用于原型的快速开发。
怎么可能没区别，就不多说了。用于原型快速开发这句话存在严重片面理解。快速开发没问题，但绝对不是只限于开发原型。
Spring Boot 文档开章明义就讲了：
Spring Boot makes it easy to create stand-alone, production-grade Spring-based Applications that you can run.
怎么是 Production-grade(产品级) 呢？
Spring Boot 文档第 V 章，专门讲了这些，指的是 Actuator，用来监控和控制 Spring Boot 应用。包括 Loggers，Metrics，Auditing，HTTP Tracing，Process Monitoring 等等产品环境下需要的一套机制。
回答 7：区别就是配置方式不一样，对于实现业务逻辑来说没有任何区别。
区别不仅仅是配置方式不一样，实现业务逻辑更是大有不同！用 SSM 开发应用，大多数公司的技术栈还在使用 JSP，很少采用前后端分离的。而 Spring Boot 倡导前后端分离的开发，Spring Boot 的应用只向前端提供 RESTful API。下面一节会重点说这个。
不再逐一分析了。为什么要批判这些回答？因为这些回答代表的观念不仅仅出现在这个问题下的回答里，其他 Spring Boot 相关的问题下面都能见到这些观点层出不穷。
我们再说说题主在问题描述中表达的困惑
原来使用 ssm 开发，后来公司用 springboot，虽然一直在用但除了 springboot 简化构建项目以外，还有个别的几个不一样的注解，其他的都感觉差不多，有人看到一个框架说: 他虽然使用 spring boot 构建了项目，但是里面开发还是用的 ssm，因为他使用了 ModelAndView，那么问题来了，那 spring boot 中又是返回什么呢？
问题描述中的这段话充分体现了软件开发上的一些根本性的问题。
软件开发，首先是思想行为，其次才是编码。想明白想通了，处处顺风顺水。想不通，觉得别扭，开发也束手束脚。
当了解学习一个新技术新框架新工具的时候，首先要了解其思想。它新在哪里？它提倡了什么理念？它想引导开发者向哪里发展？难道以前的同类技术不行了吗？
这个问题是关于 Spring 的，也就是关于 Java 服务器端技术的，那咱们就举个 Java 的例子。大家学 Java，都知道一本书叫《Thinking In Java》吧？中文叫《Java 编程思想》好像是。
Java 新手，特别是以前熟悉过程语言的人，首先要理解面向对象的思想，才能用好面向对象的语言。否则你就是用面向过程的语言写着面向过程的程序。你用来用去，就会问自己，和我以前用的那个语言到底有啥区别呢？
不仅仅是编程语言和框架，学习说话语言也是一样。任何人学外语都不会像用自己母语那么自然，关键就是没有用对方语言的思维去组织语言！背再多单词，记再多语法，没有转变到那门语言的思维方式上，就很难说出地道的外语。
生活中也是一样的。这个问题下有用手动挡车和自动挡车来类比 Spring Boot 和 SSM。假如一个人以前开了十几年手动挡汽车，然后换了一部手自一体的，他一开始也不习惯。用自动挡模式驾驶，他的手也会不自觉的去摸档把。最后他把车切换成手动模式才觉得稍微习惯一点。
在日常开发中，经常会见到一种人，他们学习新框架总是要把自己对以前旧框架的认识和经验往上套。套不上就会骂这个东西真难用，套上了就会问到底有啥区别为什么要折腾，这就是底层程序员的通病。
那么 Spring Boot 和 SSM 相比，除了之前说过的那些区别，在 Web 开发上引入了什么新思想？打算把开发者引导到什么方向上去呢？其中重要的一点就是：抛弃服务器端模板，用 REST API 和前端配合，做到前后端分离的开发。
看我回答过的两个问题：
Java Web 开发使用 jsp 页面是否已经落后了？是的话现在流行用什么？spring cloud 怎么传递参数到同个项目的 jsp？
别人的问题和文章：
为什么 spring boot 不能很好的支持 jsp？启蛰：12.Spring Boot 之开启 JSP 支持
总之，Spring Boot 开发 JSP 有一些限制！如果要开发 JSP，还要做额外的配置，这不就和 Spring Boot 减少配置让项目快速启动开发的理念背道而离了吗？不仅仅是限制 JSP，而是现在前后端分离的开发就是大势所趋。因为前端越来越专业越来越复杂了，从语言到框架到开发工具已经完全和服务器端不同了，服务器端包含 JSP 在内的模板语言越来越没有用了。
上面并没有说明确。如果对 Spring Framework 有最新了解的话，就会知道所谓的 “Spring Boot 对 JSP 有一些限制” 指的是 Spring Boot 结合 Spring MVC 的情况下，也就是用 spring-boot-starter-web 这个 Starter 的时候。
Spring Boot 开发 Web 应用难道可以不用 Spring MVC，还能用其他框架？当然啊，我在回答的第一部分，讲 Spring Boot 和 SSM 本质区别的时候就提到了。我们还可以让 Spring Boot 用 spring-boot-starter-webflux 这个 Starter，用上 Spring 5 最新提供的 Spring WebFlux！关于 WebFlux，可以看我另外一个回答：
我们再次看一下 Spring 官网 (http://spring.io) 的一副大图 (我上面这个回答也用了这幅图)：
右侧是传统的 Spring MVC，是基于 Servlet API 的，也就是说至少还支持 JSP，只是有一些限制。而左侧是 Spring 5 最新推出的 Spring WebFlux，完全不支持 JSP！
看一下 Spring Boot 文档里分别是怎么说的：
Spring Boot 结合 Spring MVC 部分：
If possible, JSPs should be avoided.
如果可能的话，最好别用 JSP。
Spring Boot 结合 Spring WebFlux 部分：
压根没提到 JSP。
再多谈一些
我们再看看 Spring 官网 (http://Spring.io) 首页最大最醒目的一幅图。
Your App
你的 App？难道不是用 Spring Boot 开发的吗？对。指的是 Desktop App、Web App、Mobile App，当然 Mobile App 也可能是 Hybrid 或 H5 开发的。灰色的 Your App 不是 Spring Boot 开发的，右侧绿色那三个块块才是。
总之他们都是独立运行在客户端的，他们不是用 Spring Boot 开发出来的！他们都会向服务器端 Spring Boot 发送 API 请求。其中 Web App 就是我们现在用前端框架写的 SPA(Single Page Application)，不是 JSP，也不是其他任何服务器端模板语言 (FreeMarker、Thymeleaf)！ JSP 是服务器端生成 HTML，不是客户端技术，而是 Java Server Page，是 Page，写不出 APP。
第一个方块
Spring Boot，Build Anything。为啥是 Build Anything？按照绝大多数人的理解，Build Web 不就完了吗？就好像我现在正在回答的这个问题大多数其他答主片面肤浅理解的那样，Spring Boot 和 SSM 好像没啥区别啊，都是开发 Java Web 的，只是配置更方便。
Anything，在我回答的第一部分就已经解释过了。Spring Boot 没有必须用 Spring MVC，可以不用，也可以换成 Spring WebFlux。也可以结合其他专用框架开发应用，都不一定要用 Web。
第二个方块
Spring Cloud，就是基于 Spring Boot 的。
我们看 Spring 官网 (http://spring.io) 首页的另一副大图：
注意最左侧灰色的 IoT、Mobile、Browser，同样是之前我们引用的三个方块图里最左侧的 “Your App”，右侧绿色的才是 Spring Cloud 架构里的组成部分。IoT 是 Internet of Things，物联网。
Spring Cloud 架构里面包含的的 Service Registry、Service Configuration Center、API Gateway、每一个 MicroService，都是基于 Spring Boot 的应用。
特别是每一个 MicroService，不会再用模板引擎，当然也不会用 JSP。因为所有前端的 API 请求都发给 API Gateway，Gateway 再转发给某个微服务。
我们看看 Spring Cloud 文档里怎么说的：
Many of those features are covered by Spring Boot, on which Spring Cloud builds.
Spring Boot has an opinionated view of how to build an application with Spring. For instance, it has conventional locations for common configuration files and has endpoints for common management and monitoring tasks. Spring Cloud builds on top of that and adds a few features that probably all components in a system would use or occasionally need.
比如我们写一个 Spring Cloud Config Server：
package hello;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;
@EnableConfigServer
@SpringBootApplication
public class ConfigServiceApplication {
public static void main(String[] args) {
SpringApplication.run(ConfigServiceApplication.class, args);
}
}
比如我们写一个 Spring Cloud Eureka Service Registry:
package hello;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
@EnableEurekaServer
@SpringBootApplication
public class EurekaServiceApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaServiceApplication.class, args);
}
}
比如我们写一个 Spring Cloud Zuul Proxy(Gateway):
package hello;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;
@EnableZuulProxy
@SpringBootApplication
public class GatewayApplication {
public static void main(String[] args) {
SpringApplication.run(GatewayApplication.class, args);
}
}
比如我们写一个微服务：
package hello;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
@RestController
@SpringBootApplication
public class SayHelloApplication {
private static Logger log = LoggerFactory.getLogger(SayHelloApplication.class);
@RequestMapping(value = "/greeting")
public String greet() {
log.info("Access /greeting");
List<String> greetings = Arrays.asList("Hi there", "Greetings", "Salutations");
Random rand = new Random();
int randomNum = rand.nextInt(greetings.size());
return greetings.get(randomNum);
}
@RequestMapping(value = "/")
public String home() {
log.info("Access /");
return "Hi!";
}
public static void main(String[] args) {
SpringApplication.run(SayHelloApplication.class, args);
}
}
这些都要用到 @SpringBootApplication
如果 MicroService 也包含 JSP，就产生了这个问题：
spring cloud 怎么传递参数到同个项目的 jsp？
这个问题的提出，就是我上文说过的：在日常开发中，经常会见到一种人，他们学习新框架总是要把自己对以前旧框架的认识和经验往上套。套不上就会骂这个东西真难用，套上了就会问到底有啥区别为什么要折腾，这就是底层程序员的通病。
第三个方块
Spring Cloud DataFlow。我们可以写 Stream 和 Task，做数据的抽取、分析、转换等等，他们同样是 Spring Boot 的应用！这也是 Anything 包含的，而 SSM 没这些！
比如我们写一个 Task:
@EnableTask
@SpringBootApplication
public class MyTask {
public static void main(String[] args) {
SpringApplication.run(MyTask.class, args);
}
}
同样是一个 @SpringBootApplication
谈一些更深入的问题
这个问题，我之所以花了将近两天时间去写答案，然后不断补充和修订，不仅仅是因为问题本身。而是这个问题以及问题下的答案充分反映了国内程序员的一些通病，一些根源性的问题。
这些问题及我的观点，也是我从去年开始在知乎回答问题到现在，一年时间里不断纠正、提倡、引导的。
思想要跟上变化
软件开发，首先是思想活动，其次才是敲代码。 这句话不知道在我的知乎回答里出现了多少遍了，上面的回答内容中也有所体现。
做软件开发不可避免的遇到新语言、新技术、新框架、新工具的出现。当遇到新东西的时候，必须要问自己：为什么会出现这个东西，以前我开发的好好地，为啥冒出这么个东西来。
我以前用 Struts，现在出来个 Spring MVC，Spring 这帮人是傻吗？
我现在用 Java，Java 太强大了，怎么又出来个 Kotlin，JetBrains 这帮人是活腻了吗？他们想取代 Java？
我一直在用 JSP，怎么最近几年前端那么火爆？不就是写个页面吗？jQuery 不是很好用？那些 React、VUE 出来干嘛？
我以前用 SSM，现在出来个 Spring Boot，怎么又搞一个新 “框架” 啊？这个 “框架” 感觉就是比 SSM 配置起来方便点，怎么就这么火呢，做 Java 服务器端的无人不吹 Spring Boot？
整个 IT 产业到目前还属于朝阳产业。软件开发和编程到现在还处于起步阶段，尤其是国内的程序员都是软件开发行业的第一代人，几乎没有自己的父母就是程序员的。软件开发技术就像婴儿，每天一个变化，千万不要用一成不变的眼光看待它。
所以，新产业就会有新需求，就会有新思想不断涌现去满足那些新需求。当原有技术无法支撑新的思想，就必定涌现出新的东西。
如果有人觉得 Struts1 还能满足需要，只是需要稍加优化，那就出现 Struts2。有另外一拨人觉得 Struts 根本不能支撑自己的新想法，那就出现 Spring MVC 了，现在又出现 Spring WebFlux 了。
如果有人觉得 jQuery 能够满足自己的需要，那就继续维护增加新功能进去。有人觉得满足不了需求，那就 Angularjs、Backbone、Ember 出来了，后来又有人觉得这些框架无法支撑自己的想法了，搞出第二代前端框架 Angular、React、Vue。
所以，学习新技术，千万不要用自己以前建立起来的老经验往上生拉硬套！要分清楚哪部分是传承，哪部分是创新。套不上就骂这个框架难用，套上了就问和以前有什么区别。
以前用 SSM，只知道框架。有了 Spring Boot 就认为它必然就是个新框架而已。然后得出结论：和 SSM 一样，就是配置简单点。SSM 能写的它都能写。殊不知，Spring Boot 可能是 Java 服务器端从来没有出现过的概念，它代表了新理念，不能用任何已经固化的概念去套。
宝宝长出牙，父母就无所适从了，这是又长出一层嘴唇？还是舌头变硬了？反正必须用以前见过的东西网上套。有这样的父母吗？如果没有，那就别用这样的方式去看待软件开发。
为什么不去读文档
这个问题的回答，我引用了多少 Spring 的文档？而且 http://Spring.io 首页的三幅图就说明了很多问题。可惜的是，我见到的大多数开发人员没有阅读过官网文档。从来没有访问过 http://spring.io 首页的都大有人在，更别提去认真读一遍 Spring Boot/Sprint Framework/Spring Cloud/Spring Data 这些具体项目的文档。
面试过太多人。
问他们：你们用到 Spring 了吗？
回答：用到了。
问：Spring 什么版本？
回答：不知到。
问：看过 Spring 的文档吗?
回答：看过。
问：Spring 官网地址是什么?
回答：不知道。
问：那你在哪里看的文档？
回答：CSDN、论坛、视频…
但是这个面试者的简历里很可能写着：精通 Spring 源代码…
曾经在知乎里回答过一个问题：
我和其他所有该问题下的回答都不同，我不支持初学者一头扎入源代码，具体观点可以去这个回答里看。
就拿我们当前的这个问题来说。你要看多少 Spring 的源代码才能了解我在回答里里阐述的这些事实，才能对 Spring Boot 从宏观上有一个全面、清晰的理解？
知乎里有很多类似这样的问题：程序员如何避免走弯路？
我觉得对于国内很多程序员来说，最大的弯路、冤枉路就是迷信源代码，跳过熟读文档这一步而一头扎进源代码。
我个人认为的任何成熟软件技术的最佳入门路径都是：
- 先看官方文档。好的技术和框架，官方文档一定全面丰富详实，http://Spring.io 就是好文档的典范。所以先把官方文档过一遍，理解的就理解，不理解的要记住在文档的哪一节。
- 开始实践。有些知识只有实践的过程中才能理解，并且加深认识。遇到问题，知道这个问题对应文档的哪一部分，然后去查文档。
- 做完一两个实际项目之后，返回去再读一遍文档，这时你会发现自己站在一个新高度上。
- 1/2/3 部分循环…
越成熟越优秀的开源框架，文档就越丰富越详实。Java 这边的 Spring 就是最典型的例子，前端的 Angular、React 都是例子。
如果一个框架文档不齐全，不丰富，说明这个框架本身也不成熟，这个框架的开发团队主要精力还放在功能上，而没有更多地投入到文档上。
别丢掉英语
英语是工具，是你程序员职业生涯上的一对翅膀。大部分一手资料都是英文的。如何慢慢习惯英文阅读，看我曾经回答过一个问题：
软件开发圈的人，一开始是怎么学会使用纯英文描述的 API 和各种软件（比如 Tomcat）的使用方法的？
看到原来最高赞答案推荐了《Java EE 开发的颠覆者：Spring Boot 实战》，我去京东上搜了一下，发现两个问题。
发现 Spring Boot 最早的中文 (原创或翻译) 书都是从 16 年开始陆续上市的。而我 14 年就开始用 Spring Boot，15 年初开始用 JHipster 2.0 了。
我没有看过那些书，所以对书的内容不做评价。但是发现另一个问题，就是这些书都叫 Spring Boot 实战、Spring Boot 揭秘、深入浅出 Spring Boot，中文编程的书好像就想不起什么好名字了。尤其是这个” 揭秘 “。我只在小时候看 UFO、玛雅文明、亚特兰蒂斯、克格勃这些书才能看到这个词。Spring Boot 有什么秘密可言吗？代码都是开源的！文档随便读！
Spring 团队生怕大家不会用，生怕大家不理解，编写了完备的文档，给出了丰富的例子。结果两年后中文书好像还能挖出 Spring 官方自己都不知道的什么秘密，并且能写厚厚一本。
官方团队在这里给出了八十多个例子：
长图预警八十多个例子：
这些例子涵盖了 Spring Boot 的方方面面，各种用法各种特性应有尽有。网上第三方的例子还有很多很多。
可悲的是，国内 Java 服务器端开发人员对如此丰富免费的文档和例子视而不见，却要多等两年，还要花几十几百块钱去买 xxx 揭秘 xxx 实战。
知乎用户
springboot 和 ssm 开发中有什么区别？
这个问题问的很好
对于普通开发而言，springboot 和 ssm 好像并没有太多的区别，尤其 web 开发过程中，基本上就是 springmvc 接收请求，spring 做对象管理，mybatis 进行数据操作，在这一层面而言，使用 springboot 和 ssm or ssh，并没有什么区别
Controller 层接收请求 →service 处理操作 - >dao 层数据操作
但是跳转到更上一级而言，springboot 的意义就十分重大了。
它提供了一个 “标准”
在以往的 ssm 架构中，根据不同架构师的理念，对于 ssm 的整体配置，有着不同的理解，有些架构师喜欢将 html 页面，静态文件等等扔在一个目录下解析，有些架构师喜欢分开目录解析，还有些架构师喜欢在页面后附加. do 来区分是请求 controller 还是静态资源。
当然这样做并没有太大的问题，唯一的问题是，有没有一个良好的标准来约束。从而减少开发人员上手时，减少阅读配置文件的时间? 如果形成一个良好的规范，大家都遵守该规范，那么也就不再有必要阅读那些毫无意义却又十分重要的配置文件？
在 springboot-starter-web 中，你可以直接将静态资源放在 / static 下，静态页面放在 / public 下，若是需要配置站点的 icon，只需要在目录下放置一个对应名称的文件即可。
若是需要连接 mysql，则可以选择对应的 starter，然后根据对应 starter 所要求必须的配置项，在 application.properties 中配置即可。
而若是使用 ssm 架构，或许架构师会这么做。
首先引入对应的 jar 包，然后处理对应的依赖，若是有冲突，则需要解决依赖冲突，解决完毕后，配置对应的配置文件，然后再配置 spring 的 xml。
换成 springboot ，就只需要两步，寻找 starter，在 application.properties 配置必要参数
依赖问题由 starter 及 springboot parent 去解决，参数配置集中配置在 application.properties。
这就解决了好几个问题，首先，参数配置均在 application.properties 中，其次，依赖问题有 starter 自己解决，依赖冲突有 springboot parent 去解决。我们只需要关注最核心的几个参数配置即可，而且其他人上手该项目，也只需要去关注最重要的几个点即可，而不是在一堆 xml 中去查证对应配置。
由此看来，springboot 和传统的 ssm 的区别，则在于其提供了一个良好且有效的标准，虽然它允许你可以自由配置，但是它仍旧希望你在满足需求的前提下，使用它的默认配置，而在目前看来，springboot 的默认配置，也已经满足了绝大多数情况下的开发要求。
对于 springboot 和 ssm 的区别，个人理解看来，springboot 更像是一个应用商店，你需要什么，你就去寻找对应的应用 (starter)，并组装完成你的需求，而 ssm，则仅仅是一个简单的应用工具，仅用于 web 开发领域。
动力节点 java 培训机构
什么是 Spring Boot?
从本质上来说，Spring Boot 就是 Spring, 它做了那些没有它你也会去做的 Spring Bean 配置。
Spring
Boot 的作用？
它使用 “习惯优于配置”（项目中存在大量的配置，此外还内置了一个习惯性的配置，让你无需手动进行配置）的理念让你的项目快速运行起来。使 用 Spring
Boot 很容易创建一个独立运行（运行 jar, 内嵌 Servlet 容器）、准生产级别的基于 Spring 框架的项目，使用 Spring Boot 你可以不用或者只需要很少的 Spring 配置。
Spring
Boot 的优点？
Spring 由于其繁琐的配置，一度被人认为 “配置地狱”，各种 XML、Annotation 配置，让人眼花缭乱，而且如果出错了也很难找出原因。
SpringBoot 帮助开发者快速启动一个 Web 容器；
SpringBoot 继承了原有 Spring 框架的优秀基因；
SpringBoot 简化了使用 Spring 的过程。
Spring
Boot 的缺点？
Spring Boot 作为一个微框架，离微服务的实现还是有距离的。没有提供相应的服务发现和注册的配套功能，自身的 acturator 所提供的监控功能，也需要与现有的监控对接。没有配套的安全管控方案，对于 REST 的落地，还需要自行结合实际进行 URI 的规范化工作。
什么是 SSM？
SSM（Spring+SpringMVC+MyBatis）框架集由 Spring、SpringMVC、MyBatis 三个开源框架整合而成，常作为数据源较简单的 web 项目的框架。
其中 spring 是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。
SpringMVC 分离了控制器、模型对象、分派器以及处理程序对象的角色，这种分离让它们更容易进行定制。
MyBatis 是一个支持普通 SQL 查询，存储过程和高级映射的优秀持久层框架。
SSM 有什么用？
SpringMVC：
-
客户端发送请求到 DispacherServlet（分发器）
-
由 DispacherServlet 控制器查询 HanderMapping，找到处理请求的 Controller
3.Controller 调用业务逻辑处理后，返回 ModelAndView
4.DispacherSerclet 查询视图解析器，找到 ModelAndView 指定的视图
- 视图负责将结果显示到客户端
Spring：我们平时开发接触最多的估计就是 IOC 容器，它可以装载 bean（也就是我们 Java 中的类，当然也包括 service dao 里面的），有了这个机制，我们就不用在每次使用这个类的时候为它初始化，很少看到关键字 new。另外 spring 的 aop，事务管理等等都是我们经常用到的。
Mybatis：mybatis 是对 jdbc 的封装，它让数据库底层操作变的透明。mybatis 的操作都是围绕一个 sqlSessionFactory 实例展开的。mybatis 通过配置文件关联到各实体类的 Mapper 文件，Mapper 文件中配置了每个类对数据库所需进行的 sql 语句映射。在每次与数据库交互时，通过 sqlSessionFactory 拿到一个 sqlSession，再执行 sql 命令。
SSM 的优缺点？
SSM 优缺点应该分开来说的，比如
1）spring 不说了，核心 ioc、aop 技术，ioc 解耦，使得代码复用，可维护性大幅度提升，aop 提供切面编程，同样的增强了生产力。
2）spring mvc 嘛，是对比 struts2 等 mvc 框架来说的，不说 struts2 爆出的那么多安全漏洞，而且是类拦截，所有 Action 变量共享，同时是 filter 入口的，而 spring mvc 是方法拦截，controller 独享 request response 数据，采用的 serlvet 入口，与 spring 无缝对接。开发而言，spring mvc 更加轻量和低入门。
3）mybatis 嘛，看业务场景，主要是 mybatis 的 sql 可以由开发者去掌控和调优，相对 hibernate 等 orm 框架来说，更加直观。在业务场景比较复杂，sql 好多联合关联的情况下，mybatis 谁用谁知道。当然缺点就是对 sql 不熟悉的开发者就不太友好了。
二者相比较优缺点？
SSM 框架和 spring boot 全家桶相比有哪些优缺点？
这两者对比起来有点奇怪。因为 SSM 是 WEB 应用框架，涵盖整个应用层，而 spring boot 你可以看做一个启动、配置、快速开发的辅助框架，本身针对的是微服务。
springboot 只是为了提高开发效率，是为了提升生产力的：
1、springboot 一个应用是一个可执行 jar（启动类 main 方法启动 web 应用），而不像传统的 war，内嵌 tomcat 容器，可以 jar 形式启动一个服务，可以快速部署发布 web 服务，微服务最好不过了。
2、将原有的 xml 配置，简化为 java 配置
3、当然结构可能跟一般的 ssm 有一定区别，但其实主要是在资源文件。
来源：CSDN
原文：https://blog.csdn.net/qq_43202482/article/details/88378771
知乎用户
其实 Spring Boot 本质还是一个普通的 Spring 应用，并不是什么新的框架技术。没有它我们照样通过 xm 配置 bean 的方式也可以实现对应的功能。
之所以 Spring Boot 这几年这么火，主要原因是 Java 程序员苦 Spring 久已！ 并不是说 Spring 不好，相反它非常的优秀，帮我们可以实现很多高级功能，但是这些年 使用 Spring 开发每个项目都要加一堆相似的配置，比如 bean 配置，数据库的 xml 配置，springmvc 配置，还有管理很多 jar 包依赖等，这个就让我们开发一个 Spring 应用阻力比较大。
Spring Boot 通过四大核心特性的支持（自动配置、起步依赖、Spring Boot CLI、Actuator）让我们无需配置开箱即用。
这个视频给大家分享下创建 Spring Boot 应用程序的 3 种方式，让你直观的感受到和传统 Spring 项目开发的区别。
纯洁的微笑
区别就是一起你需要三个框架整合来开发，并且需要注意各种配置和兼容；
现在只需要使用 Spring Boot 就行了，因为其它使用它都帮你办了。
老胡聊 Java
先从语法角度来讲。
1 开发 Spring Boot 时，能用比较便捷的注解来定义功能，而在 spring mvc 或 ssm 框架中，则需要用比较麻烦的 xml 配置文件来定义功能。
就拿定义 Dubbo 远端方法来说，spring boot 中可能只需要通过简单的 @Reference 注解就行，SSM 如果要引入 Dubbo，估计要写一堆 xml 配置文件。
所以 Spring Boot 比 SSM 要好写，好维护。
2 Spring Boot 内嵌 Web 服务器，只要编写好用 @SpringBootApplication 修饰的启动类，然后直接启动，就能对外提供服务，而 ssm 框架估计要打包部署到 tomcat 等服务器上再运行。
所以 Spring Boot 项目比 ssm 项目要好维护。
3 SSM 框架，只能用 Mybatis 来连接数据库，而 spring boot 框架中，不仅可以用 mybatis，而且还可以用 jpa。
所以总体上来，从开发角度，Spring boot 框架要比 ssm 框架好用。
但是，spring boot，或者 SSM 框架，顶了天了只能开发单机版项目，比如程序员可以用这些框架在 windows 环境上开发增删改查。不过现在都讲分布式了，比如引入 redis 集群做缓存，引入 dubbo，引入 rabbitmq 做消息队列，引入 nginx 做负载均衡。总之得用分布式组件应对高并发。
SSM 框架不能说不能整合诸多分布式组件，但由于 SSM 框架是通过 xml 等配置文件来定义和分布式组件的连接，所以整合起来比较麻烦，得开发维护一大堆 xml 文件。
相比之下，spring boot 可以用注解 + 非常少量（估计也就 application.yml）的方式来整合诸多分布式组件。所以在高并发项目中，基本都用 spring boot，而不是 SSM。
甚至可以这样说，如果是初学者，用 ssm 搭个学习项目，了解基本的 web 开发或全栈开发，这也是可以的，或者用 ssm 做个毕业设计课程设计也行，但如果程序员要升级到高级开发，那么最好学下 spring boot，必要是最好学下 spring boot 和诸多分布式组件的整合方式。
本人最近完稿了一本 spring boot 整合分布式组件的书。
[
广告
Spring Boot+Vue.js + 分布式组件全栈开发训练营：视频
京东
¥50.10
去购买
**这本书用视频教学，**不仅讲了 spring boot 的基本技能点，比如搭建 Spring Boot 开发环境、用 JPA 操作数据库、面向切面编程、拦截器和过滤器、RESTful 规范定义服务、Swagger 组件可视化服务、logback 和 ELK 组件输出日志、基于 Junit 的单元测试技术。
还讲述了 Spring Boot 整合诸多分布式组件的技术，包括整合 MongoDB、Redis 和 MyCAT 数据层组件、整合 Dubbo 和 Zookeeper、整合 RabbitMQ 消息中间件和基于 Nginx 的分布式部署。
在此基础上，还给出了两大案例，一个是后端分离项目，前端用到了 Vue、Element-UI 和 Axios 等组件，后端用到了 Redis 缓存组件和 MyCAT 分库组件；另一个是通过高并发限流和秒杀项目讲述了 Redis 和 RabbitMQ 等分布式组件的用法。
本人本职是架构师，平时还兼职讲 java 课，根据我讲课的经验，当我在课上用大概 2 个月的时间，用这本书和学生讲完 spring boot 技能点后，我的学生不仅能掌握 spring boot 的基本技能，还能掌握 Spring boot 整合诸多分布式组件的用法。所以这本书应当能帮助广大想学 spring boot 的朋友有效地提升学习效率。
程序员泥瓦匠
SSM = Spring Boot （Spring MVC + Spring ）+ Mybatis
东方翌
回答：spring boot 是什么？有什么作用？什么场景下使用？
SSM 是什么？有什么作用？什么场景下使用？
两个相比较，各自的优缺点
什么是 Spring Boot?
从本质上来说，Spring Boot 就是 Spring, 它做了那些没有它你也会去做的 Spring Bean 配置。
Spring
Boot 的作用？
它使用 “习惯优于配置”（项目中存在大量的配置，此外还内置了一个习惯性的配置，让你无需手动进行配置）的理念让你的项目快速运行起来。使 用 Spring
Boot 很容易创建一个独立运行（运行 jar, 内嵌 Servlet 容器）、准生产级别的基于 Spring 框架的项目，使用 Spring Boot 你可以不用或者只需要很少的 Spring 配置。
Spring
Boot 的优点？
Spring 由于其繁琐的配置，一度被人认为 “配置地狱”，各种 XML、Annotation 配置，让人眼花缭乱，而且如果出错了也很难找出原因。
SpringBoot 帮助开发者快速启动一个 Web 容器；
SpringBoot 继承了原有 Spring 框架的优秀基因；
SpringBoot 简化了使用 Spring 的过程。
Spring
Boot 的缺点？
Spring Boot 作为一个微框架，离微服务的实现还是有距离的。没有提供相应的服务发现和注册的配套功能，自身的 acturator 所提供的监控功能，也需要与现有的监控对接。没有配套的安全管控方案，对于 REST 的落地，还需要自行结合实际进行 URI 的规范化工作。
什么是 SSM？
SSM（Spring+SpringMVC+MyBatis）框架集由 Spring、SpringMVC、MyBatis 三个开源框架整合而成，常作为数据源较简单的 web 项目的框架。
其中 spring 是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。
SpringMVC 分离了控制器、模型对象、分派器以及处理程序对象的角色，这种分离让它们更容易进行定制。
MyBatis 是一个支持普通 SQL 查询，存储过程和高级映射的优秀持久层框架。
SSM 有什么用？
SpringMVC：
-
客户端发送请求到 DispacherServlet（分发器）
-
由 DispacherServlet 控制器查询 HanderMapping，找到处理请求的 Controller
3.Controller 调用业务逻辑处理后，返回 ModelAndView
4.DispacherSerclet 查询视图解析器，找到 ModelAndView 指定的视图
- 视图负责将结果显示到客户端
Spring：我们平时开发接触最多的估计就是 IOC 容器，它可以装载 bean（也就是我们 Java 中的类，当然也包括 service dao 里面的），有了这个机制，我们就不用在每次使用这个类的时候为它初始化，很少看到关键字 new。另外 spring 的 aop，事务管理等等都是我们经常用到的。
Mybatis：mybatis 是对 jdbc 的封装，它让数据库底层操作变的透明。mybatis 的操作都是围绕一个 sqlSessionFactory 实例展开的。mybatis 通过配置文件关联到各实体类的 Mapper 文件，Mapper 文件中配置了每个类对数据库所需进行的 sql 语句映射。在每次与数据库交互时，通过 sqlSessionFactory 拿到一个 sqlSession，再执行 sql 命令。
SSM 的优缺点？
SSM 优缺点应该分开来说的，比如
1）spring 不说了，核心 ioc、aop 技术，ioc 解耦，使得代码复用，可维护性大幅度提升，aop 提供切面编程，同样的增强了生产力。
2）spring mvc 嘛，是对比 struts2 等 mvc 框架来说的，不说 struts2 爆出的那么多安全漏洞，而且是类拦截，所有 Action 变量共享，同时是 filter 入口的，而 spring mvc 是方法拦截，controller 独享 request response 数据，采用的 serlvet 入口，与 spring 无缝对接。开发而言，spring mvc 更加轻量和低入门。
3）mybatis 嘛，看业务场景，主要是 mybatis 的 sql 可以由开发者去掌控和调优，相对 hibernate 等 orm 框架来说，更加直观。在业务场景比较复杂，sql 好多联合关联的情况下，mybatis 谁用谁知道。当然缺点就是对 sql 不熟悉的开发者就不太友好了。
二者相比较优缺点？
SSM 框架和 spring boot 全家桶相比有哪些优缺点？
这两者对比起来有点奇怪。因为 SSM 是 WEB 应用框架，涵盖整个应用层，而 spring boot 你可以看做一个启动、配置、快速开发的辅助框架，本身针对的是微服务。
springboot 只是为了提高开发效率，是为了提升生产力的：
1、springboot 一个应用是一个可执行 jar（启动类 main 方法启动 web 应用），而不像传统的 war，内嵌 tomcat 容器，可以 jar 形式启动一个服务，可以快速部署发布 web 服务，微服务最好不过了。
2、将原有的 xml 配置，简化为 java 配置
3、当然结构可能跟一般的 ssm 有一定区别，但其实主要是在资源文件。
2018.07.20
------- 这个问题浏览量过万了，非常多人关心这个 SpringBoot 的使用，下面分享一下：《JavaEE 开发的颠覆者 Spring Boot 实战》-------
有人说，Spring Boot 的出现，让 Java 迎来了又一春，它是 Java 应用开发的颠覆者，彻底改变了 Java 应用开发的模式。
以往我们做 Spring 应用开发，要知道配置哪些类来让 Hibernate 和 Spring 一起工作，要知道如何配置 view resolver 来控制哪个模版进行视图层的展示。经常写了一大堆代码之后发现只是在处理 Spring 框架本身的配置，根本一行业务逻辑都没有写。
我们还要考虑部署的问题，且不说部署到非常笨重的应用服务器，比如 WebSphere, Weblogic 或者 JBoss，即使部署到 Tomcat 或者 Jetty 这种轻量级容器上面，我们要知道如何配置容器，如何修改配置文件等等。而且在多应用部署到同一个 Tomcat 的时候，经常会出现冲突。就算我们花了很大力气解决了这些问题，程序部署成功之后，我们很难去了解这个程序的运行状态。有可能我们要配置很多第三方工具来去知道这个应用程序运行状态如何，有哪些参数，环境变量是什么。尽管 Spring 帮我们解决了依赖注入的问题，简化了一些 MVC 的流程，但是 Spring 框架本身集成了越来越多东西，导致其越来越难配置，维护成本成直线上升。
很多时候，Python, Ruby 或者 JavaScript 程序员敲几个命令安装一些库，然后简单的敲几行代码，引入一些框架比如 flask，然后直接一个简单的 API 就可以跑起来了。Java 程序员可能还在研究该使用 Maven 里面的哪个库，如何在代码里面进行配置。
但是现在 Spring Boot 的出现让这一情况有了很大的改观。
它使用 “习惯优于配置”（项目中存在大量的配置，此外还内置一个习惯性的配置，让你无须手动进行配置）的理念让你的项目快速运行起来。使用 Spring Boot 很容易创建一个独立运行（运行 jar，内嵌 Servlet 容器）、准生产级别的基于 Spring 框架的项目，使用 Spring Boot 你可以不用或者只需要很少的 Spring 配置。
【Spring Boot 核心功能】
独立运行的 Spring 项目
Spring Boot 可以以 jar 包的形式独立运行，运行一个 Spring Boot 项目只需通过 java –jarxx.jar 来运行。
内嵌 Servlet 容器
Spring Boot 可选择内嵌 Tomcat、Jetty 或者 Undertow ，这样我们无须以 war 包形式部署项目。
提供 starter 简化 Maven 配置
Spring 提供了一系列的 starter pom 来简化 Maven 的依赖加载，例如，当你使用了 spring-boot-starter-web 时，会自动加入依赖包。
自动配置 Spring
Spring Boot 会根据在类路径中的 jar 包、类，为 jar 包里的类自动配置 Bean，这样会极大地减少我们要使用的配置。当然，Spring Boot 只是考虑了大多数的开发场景，并不是所有的场景，若在实际开发中我们需要自动配置 Bean，而 Spring Boot 没有提供支持，则可以自定义自动配置。
准生产的应用监控
Spring Boot 提供基于 http、ssh、telnet 对运行时的项目进行监控。
无代码生成和 xml 配置
Spring Boot 的神奇的不是借助于代码生成来实现的，而是通过条件注解来实现的，这是 Spring 4.x 提供的新特性。
Spring 4.x 提倡使用 Java 配置和注解配置组合，而 Spring Boot 不需要任何 xml 配置即可实现 Spring 的所有配置。
SpringBoot 不仅让我们做 Java 开发变的简单有效，更重要的是 SpringBoot 彻底颠覆了我们对 Java 开发的认识，让我们第一次有了” 原来 Java 开发可以这么做” 的感觉。
------------ 获取相关电子版书籍请私信留言哦 ------------
希望对大家有所帮助，更多文章后续会更新出来，敬请期待哦（如获取最新的文章，进行关注收藏哦）
夏昊
springboot 和 ssm 之间最大的区别就在于它的自动配置，springboot 自动配置原理也是 springboot 的精髓，可以说掌握了它就掌握了 springboot 的 90%，便可以游刃有余的使用 springboot, 我来说说 springboot 的自动配置原理：
我们创建好一个 springboot 项目它是从这里开始执行的：
@SpringBootApplication
public class SpringbootDemoApplication {
public static void main(String[] args**)** {
SpringApplication**.run(SpringbootDemoApplication.class,** args**);**
}
}
似乎没有什么特别之处，除了 @SpringBootApplication 注解，spirngboot 的神奇能力正是由它带来的，我们看看这个注解：
@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 {
…
它上面又有很多注解，我们只看和自动配置有关的：@EnableAutoConfiguration 注解，通过这个注解开启了 springboot 的自动配置：
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
…
它上面有一个注解：@Import({AutoConfigurationImportSelector.class})，这个注解可以利用 AutoConfigurationImportSelector 扫描所有 jar 包类路径下的 META-INF/spring.factories 文件并且获取到文件中 EnableAutoConfiguration 的值 (也就是各种自动配置类)，将他们放入 spring 容器中。
在 spring-boot-autoconfigure 中 spring.factories 文件如下
Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
…
所有的以 AutoConfiguration 为后缀的类的对象都被放入 spring 容器中，就是用他们来完成自动配置。
以 HttpEncodingAutoConfiguration （http 编码自动配置）为例看看它是如何完成自动配置：
@Configuration( // 表示他是一个配置类
proxyBeanMethods = false
)
@EnableConfigurationProperties({HttpProperties.class}) // 启用 HttpProperties 类上的 ConfigurationProperties
@ConditionalOnWebApplication( // 判断当前应用是否是 web 应用，如果是则当前配置类生效
type = Type.SERVLET
)
@ConditionalOnClass({CharacterEncodingFilter.class}) // 判断当前项目有没有 CharacterEncodingFilter 类
//（spring mvc 中解决乱码问题的）, 如果有则当前配置类生效
@ConditionalOnProperty( // 判断当前项目中是否有 spring.http.encoding.enabled 配置如果有
// 或者没有设置该属性则当前配置类生效
prefix = “spring.http.encoding”,
value = {“enabled”},
matchIfMissing = true
)
public class HttpEncodingAutoConfiguration {
private final Encoding properties;
public HttpEncodingAutoConfiguration(HttpProperties properties) {
this.properties = properties.getEncoding();
}
@Bean // 将 CharacterEncodingFilter 对象放入 spring 容器
@ConditionalOnMissingBean
public CharacterEncodingFilter characterEncodingFilter() {
CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
filter.setEncoding(this.properties.getCharset().name());
filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.REQUEST));
filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.RESPONSE));
return filter;
}
…
@EnableConfigurationProperties({HttpProperties.class}) 注解可以启用 HttpProperties 类上的 ConfigurationProperties，当我们在配置文件中设置或修改属性时就会映射到 HttpProperties 类中的属性。
@ConfigurationProperties( // 将配置文件中的值和 HttpProperties 类绑定，
prefix = “spring.http”
)
public class HttpProperties {
public static class Encoding {
public static final Charset DEFAULT_CHARSET;
private Charset charset;
private Boolean force;
…
例如：我可以在 springboot 配置文件 application.properties 中配置: spring.http.charset 的值，它会被映射到 HttpProperties 类中的 charset 属性。
因此我们在配置文件中所做的配置都会被映射到一个 以 properties 为后缀的类，也就是说当我们需要对某一个功能做配置的时候能去配置什么可以参考该功能对应的属性类。
@ConditionalOnWebApplication，@ConditionalOnClass，@ConditionalOnProperty 都是根据条件判断 HttpEncodingAutoConfiguration 自动配置类是否能够生效。
如果这些条件都满足，HttpEncodingAutoConfiguration 自动配置类生效，则：
@Bean // 将 CharacterEncodingFilter 对象放入 spring 容器
@ConditionalOnMissingBean
public CharacterEncodingFilter characterEncodingFilter() {
CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
filter.setEncoding(this.properties.getCharset().name());
filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.REQUEST));
filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.RESPONSE));
return filter;
}
CharacterEncodingFilter 对象会被放入 spring 容器，在这个方法中有一行代码：
filter.setEncoding(this.properties.getCharset().name()); 表示设置编码，在获取编码的时候是从
properties 中获取的
private final Encoding properties;
public HttpEncodingAutoConfiguration(HttpProperties properties) {
this.properties = properties.getEncoding();}
从这里可以看出 properties 是 HttpProperties 类型的对象，从前面的分析我们知道 springboot 中的配置会被映射到 HttpProperties 类, 所以我们可以通过修改 springboot 的配置文件来修改他的值。
总结一下：springboot 会扫描所有 jar 包类路径下的 META-INF/spring.factories 文件，加载大量功能的自动配置类，某个功能的自动配置类，在满足条件生效以后会向 spring 容器中放入相应对象，这些对象的属性可以通过以 properties 为后缀的配置类来设置，而配置类又和 springboot 的配置文件绑定，因此我们可以通过修改配置文件来设置这些对象的属性。
知道了 springboot 自动配置的原理，如果我们要开发一个功能首先可以去找一下看看有没有相应的自动配置类，如果有再看看这个自动配置类中配置了哪些对象，有没有我们需要的，如果有直接用就 ok, 没有就需要我们自己去开发了。
千锋 Java 学习站
springboot 和 ssm 开发的区别
1. Springboot 是什么?.
谈 springboot 之前, 咱们要先说一下传统的 SSM 开发, 使用过 SSM 开发的人都会发现, 传统的 SSM 框架项目会有大量的配置文件, 需要手动的区整合三个框架, 也就是 springmvc,spring,mybatis, 并且需要注意各种配置和兼容, 后期的维护难度也很大.
现在快速开发的一个网站的方式层出不穷, 像 Node js,Php. 脚本语言也越来越流行, 比如 python,scala,ruby 等, 这时候 spring 的开发模型就显得相对笨重了.
在这种情况下, 由 Pivotal 团队开发了一个工具集, 叫 springboot. 其实本质还是 spring framework. 底层代码也还是 springmvc 和 spring 的整合. 不过不需要手动的区配置, 只需要导入相应的依赖, springboot 会自动配置.
Springboot 帮我们做什么什么事情呢?
-
springboot 使用了特定的配置方式, 开发人员不需要再定义样板化的配置, 简化项目的初始构建.
-
springboot 提供了更多的组合式注解, 简化开发过程.
-
springboot 可以 “零配置” 整合很多第三方工具.
-
springboot 提供了内置的容器, 部署也变得异常简单.
-
springboot 应对监控也提供了相应的方案.
-
… 等等好处.
2. Springboot 和 ssm 的关系.
springboot 和 ssm 不冲突, springboot 只是简化了配置, 实际开发 没什么区别.
SSM 就好像开手动挡的汽车, 需要踩离合, 挂档, 给油车才能开动.
而 springboot 就好像自动挡的汽车, 给油就走, 踩刹车就停.
3. Springboot 和 SSM 的区别.
在开发中的区别还是存在的, 虽然 springboot 简化了配置, 但并不代表不需要编写配置文件, 还是需要在自带的 application.yml 文件中去编写一些内容. 只不过编写的方式变得简单了, 虽然简单了, 但是和 SSM 整合的方式还有些区别.
在使用 SSM 开发的时候, 多数会选择 Jsp 作为视图, 但是 springboot 不推荐使用 jsp, 主推的是 thymeleaf 和 freemarker 等模板引擎, 也造成了使用 SSM 开发到 springboot 开发也需要一定得学习成本. 不过如果掌握了 SSM 的话, 学习 springboot 也是水到渠成, 异常的简单.
4. 推荐 springboot.
更推荐使用 springboot 开发, 一是 springboot 工具集的简化配置等操作, 可以让程序员把精力主要放在代码的业务逻辑上, 二是想学习 springcloud 微服务组件的话, springboot 是基础.