Spring在java EE开发中是实际意义上的标准，但我们在开发Spring的时候可能会遇到以下令人头疼的问题：

1.大量配置文件的定义。
2.与第三方软件整合的技术问题。

Spring每个版本的退出都以减少配置作为自己的主要目标，例如：

1.推出@Component，@Service，@Repository，@Controller注解在类上声明Bean
2.推出@Configuration，@Bean的java配置来替代xml配置。

Spring Boot具有以下特征：

1.遵循“习惯优于配置”的原则，使用Spring Boot只需要很少的配置。大部分可以使用默认配置。
2.项目快速搭建，可无配置整合第三方框架。
3.可完全不使用xml配置，只使用自动配置和java config。
4.内嵌servlet容器，应用可用jar包运行。
5.运行中应用状态的监控。

虽然Spring Boot给我们带来了类似于脚本语言开发的效率，但Spring Boot里没有使用如何让你意外的技术，完全是一个单纯的基于Spring的应用。如，Spring Boot的自动配置是通过Spring 4.x 的@Conditional注解来实现的。

第一部分.点睛Spring 4.x

Chapter1.Spring基础

Spring的简史：

1.xml配置

在Spring 1.x时代，使用Spring开发满眼都是xml配置的Bean，随着项目的扩大，我们需要xml配置文件分放到不同的配置文件里，那时候需要频繁地在开发的类和配置文件中切换。

2.注解配置

在Spring 2.x时代，随着JDK 1.5带来的注解支持，Spring提供了声明Bean的注解（如@Component，@Service），大大减少了配置量。这时Spring圈子里存在着一种争论：注解配置和xml配置究竟哪个好？我们最终的选择是应用的基本配置（如数据库配置）用xml，业务配置用注解。

3.java配置

Spring3.x到现在，Spring提供了java配置的能力，使用java配置可以让你更理解你配置的Bean。我们目前刚好处于这个时代，Spring 4.x和Spring Boot都推荐使用java配置，所以我们在本书通篇将使用java配置。

Spring使用简单的POJO（plain old java object，即无任何限制的普通java对象）来进行企业化开发，每一个被Spring管理的java对象都称之为Bean。而Spring提供了一个IoC容器用来初始化对象，解决对象间的依赖管理和对象的使用。

Spring的生态：

1.Spring Boot：使用默认开发配置来实现快速开发
2.Spring Data：对主流的关系型和NoSQL数据库的支持
3.Spring Security：通过认证和授权保护应用
4.Spring Web Flow：基于Spring MVC提供基于向导流程式的Web应用开发
5.Spring Web Services：提供了基于协议有限的SOAP/Web服务
6.Spring Session：提供一个API及实现来管理用户会话信息
等等，还有很多。

Spring框架本身有四大原则：

1.使用POJO进行轻量级和最小侵入式开发
2.通过依赖注入和基于接口编程实现松耦合
3.通过AOP和默认习惯进行声明式编程
4.通过AOP和模板（template）减少模块化代码

我们经常说的控制翻转（inversion of control-IOC）和依赖注入（dependency injection-DI）在Spring环境下是等同的概念，控制翻转是通过依赖注入实现的。所谓的依赖注入指的是容器负责创建对象和维护对象间的依赖关系，而不是通过对象本身自己的创建和解决自己的依赖。比如典型的：

1 2	`@Autowired` `MyBean bean;`

而不是自己new出一个对象

声明Bean的注解：

1.@Component组件，没有明确的角色
2.Service在业务逻辑层（service层）使用
3.@Repository在数据访问层（dao层）使用
4.@Controller在展现层（MVC->Spring MVC）使用

注入Bean的注解：

1.@Autowired，Spring提供的注解（推荐使用）
2.@Inject，JSR-330提供
3.@Resource，JSR-250提供

注入Bean的注解可以注解在set方法上或者属性上，不过最好是在属性上，优点是代码更少，层次更清晰。

@Configuration声明当前类是一个配置类。

使用@ComponentScan，自动扫描包名下所有使用@Service，@Component，@Compository，@Controller的类，并注册为Bean。

java配置是通过@Configuation和@Bean来实现的。

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

何时使用java配置或者注解配置呢？
我们的原则是：全局配置使用java配置（如数据库相关配置，MVC相关配置），业务Bean的配置使用注解配置。

AOP：面向切面编程，相对于OOP面向对象编程

Spring的AOP的存在的目的是为了解耦。AOP可以让一组类共享相同的行为。在OOP中只能通过继承类和实现接口，来使代码的耦合度增强，且类继承只能为单继承，阻碍更多行为添加到一组类上，AOP弥补了OOP的不足。

注解：注解本身是没有功能的，就和xml一样。注解和xml都是一种元数据，元数据即解释数据的数据，这就是所谓的配置。

Chapter2.Spring常用配置

Scope描述的是Spring容器如何新建Bean的实例的。有以下几种，通过@Scope注解来实现：

1.Singleton：一个Spring容器中只有一个Bean的实例，此为Spring的默认配置，全容器共享一个实例。
2.Prototype：每次调用新建一个Bean的实例。
3.Request：Web项目中，给每一个http request新建一个Bean实例。
4.Session：Web项目中，给每一个http session新建一个Bean实例。

Spring EL-Spring表达式语言，支持在xml和注解中使用表达式，类似于JSP的EL表达式语言。

示例：

//注入普通字符串

@Value("I Love You!") //1

private String normal;

//注入操作系统属性

@Value("#{systemProperties['os.name']}") //2

private String osName;

//注入表达式结果

@Value("#{ T(java.lang.Math).random() * 100.0 }") //3

private double randomNumber;

在实际开发的时候，经常会遇到Bean在使用使用之前或者之后做些必要的操作。在使用java配置和注解配置下提供了如下两种方式：

1.java配置方式：使用@Bean的initMethod和destroyMethod
2.注解方式：利用JSR-250的@PostConstruct和@PreDestroy

Spring的事件（Application Event）为Bean与Bean之间的消息通信提供了支持。当一个Bean处理完一个任务之后，希望另外一个Bean知道并能做相应的处理，这时我们就需要让另一个Bean监听当前Bean说发送的事件。

Spring的事件需要遵循如下流程：

1.自定义事件，继承ApplicationEvent
2.定义事件监听器，实现ApplicationListener
3.使用容器发布事件

具体例子看书籍源码即可。

Chapter3.Spring高级话题

Spring的依赖注入的最大亮点就是你所有的Bean对容器Spring容器的存在是没有意识的。即你可以将你的容器替换成别的容器。

但在实际项目中，不可避免要用到Spring容器本身的功能资源，这时你的Bean必须要意识到Spring容器的存在，才能调用Spring说提供的资源，这就是所谓的Spring Aware。其实，Spring Aware本来就是Spring设计用来框架内部使用的，若使用了Spring Aware，你的Bean将会和Spring框架耦合。

Spring Aware的目的是为了让Bean获得Spring容器的服务。

多线程：

Spring通过任务执行器（TaskExecutor）来实现多线程和并发编程。使用ThreadPoolTaskExecutor可实现一个基于线程池的TaskExecutor。而实际开发中任务一般是非阻碍的，即异步的，所以我们要在配置类中通过@EnableAsync开启对异步任务的支持。并通过在实际执行的Bean方法中使用@Async注解来声明其是一个异步任务。

计划任务：

计划任务在Spring中的实现变得异常的简单。首先通过在配置类注解@EnableScheduling来开启对计划任务的支持，然后在要执行任务的方法上注解@Scheduled，声明这是一个计划任务。

Spring通过@Scheduled支持多种类型的计划任务，包含cron，fixDeley，fixedRate等。例如：

//每个5秒执行一次

@Scheduled(fixedRate=5000)

//UNIX或LINUX系统下的定时任务

@Scheduled(cron="0 28 11 ? * *")

组合注解和元注解：

注解的大量使用，尤其相同的多个注解用到各个类或方法中，会相当繁琐。这就是所谓的样板代码，是Spring设计原则中要消除的代码。

所谓元注解其实就是可以注解到别的注解上的注解，被注解的注解称之为组合注解。

@Enable*注解：

通过观察@Enable*注解的源码，我们发现所有的注解都有一个@Import注解，@Import是用来导入配置类的，这也就意味着这些自动开启的实现其实是导入了一些自动配置的Bean。这些导入的配置主要分为三种类型：

1.直接导入配置类
2.依据调价选择配置类
3.动态注册Bean

vc-4x">第二部分.点睛Spring MVC 4.x

分清MVC和三层架构的不同：

MVC：Model+View+Controller（数据模型+视图+控制器）

三层架构：Presentation tier+Application tier+Data tier（展现层+应用层+数据访问层）

实际的MVC只存在三层架构中的展现层，M实际上是数据模型，是包含数据的对象。在Spring MVC中，有一个专门的类叫Model，用来和V之间的数据交互、传值；V指的是视图页面，包含JSP，Thymeleaf等。C当然就是控制器（Spring MVC的注解@Controller类）。

//Spring MVC配置

@Configuration

@EnableWebMvc

@EnableScheduling

@ComponentScan("com.wisely.highlight_springmvc4")

public class MyMvcConfig extends WebMvcConfigurerAdapter {

@Bean

public InternalResourceViewResolver viewResolver() {

InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();

viewResolver.setPrefix("/WEB-INF/classes/views/");

viewResolver.setSuffix(".jsp");

viewResolver.setViewClass(JstlView.class);

return viewResolver;

}

注意这里对路径前缀的配置为/WEB-INF/classes/views/，不是和我们的开发的目录一样。因为看到的页面效果是运行时而不是开发时的代码，运行时代码会将我们的页面自动编写到/WEB-INF/classes/views/（因为我把JSP文件放在了/resources/views目录下）下。

@Controller

public class HelloController {

@RequestMapping("/index")

public String hello(){

return "index";

}

通过上面的ViewResolver的Bean配置，返回值为index，说明我们的页面放置的路径为/WEB-INF/classes/views/index.jsp。

Spring MVC的常用注解：

1.@Controller
2.@RequestMapping
3.@RequestBody
@RequestBody允许request的参数在request体中，而不是在直接链接在地址后面。
4.@ResponseBody
@ResponseBody支持将返回值放在response体内，而不是返回一个页面。
5.@PathVariable
6.@RestController
是一个组合注解，组合了@Controller和@ReponseBody。

示例：
添加jackson即相关依赖，获得对象和json或xml之间的转化。

特别指出：在实际项目中，我们主要支持json数据，没必要同时支持json和xml，因为json比xml更简洁，而且也更推荐。

public class DemoObj {

private Long id;

private String name;

//jackson对对象和json做转换时一定需要此空构造

public DemoObj() {

super();

}

public DemoObj(Long id, String name) {

super();

this.id = id;

this.name = name;

}

public Long getId() {

return id;

}

public void setId(Long id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

演示@Controller控制器：

@Controller // 1

@RequestMapping("/anno") //2

public class DemoAnnoController {

@RequestMapping(produces = "text/plain;charset=UTF-8") // 3

public @ResponseBody String index(HttpServletRequest request) { // 4

return "url:" + request.getRequestURL() + " can access";

}

@RequestMapping(value = "/pathvar/{str}", produces = "text/plain;charset=UTF-8")// 5

public @ResponseBody String demoPathVar(@PathVariable String str, //3

HttpServletRequest request) {

return "url:" + request.getRequestURL() + " can access,str: " + str;

}

@RequestMapping(value = "/requestParam", produces = "text/plain;charset=UTF-8")

//6演示常规的request参数获取，访问路径

//为/anno/requestParam?id=1

public @ResponseBody String passRequestParam(Long id,

HttpServletRequest request) {

return "url:" + request.getRequestURL() + " can access,id: " + id;

}

@RequestMapping(value = "/obj", produces = "application/json;charset=UTF-8")

//演示解释参数到对象，访问路径为/anno/obj?id=1&name=xx

@ResponseBody //8

public String passObj(DemoObj obj, HttpServletRequest request) {

return "url:" + request.getRequestURL()

+ " can access, obj id: " + obj.getId()+" obj name:" + obj.getName();

}

@RequestMapping(value = { "/name1", "/name2" }, produces = "text/plain;charset=UTF-8")//9

public @ResponseBody String remove(HttpServletRequest request) {

return "url:" + request.getRequestURL() + " can access";

}

演示@RestController控制器：

@RestController //1

@RequestMapping("/rest")

public class DemoRestController {

@RequestMapping(value = "/getjson",

produces={"application/json;charset=UTF-8"}) //2

public DemoObj getjson (DemoObj obj){

//直接返回对象，对象会自动转换称json

return new DemoObj(obj.getId()+1, obj.getName()+"yy");

}

@RequestMapping(value = "/getxml",

produces={"application/xml;charset=UTF-8"})//4返回数据的媒体类型为xml

public DemoObj getxml(DemoObj obj){

return new DemoObj(obj.getId()+1, obj.getName()+"yy");

}

Spring MVC的基本配置：

Spring MVC的定制配置需要我们的配置类继承一个WebMvcConfigureAdapter类，并在此类使用@EnableWebMvc注解，来开启对Spring MVC的配置支持，这样我们就可以重写这个类的方法，完成我们的常用配置。

静态资源映射：

@Configuration

//1开启Spring MVC支持，若无此句，重写

//WebMvcConfigurerAdapter方法无效

@EnableWebMvc

@EnableScheduling

@ComponentScan("com.wisely.highlight_springmvc4")

public class MyMvcConfig extends WebMvcConfigurerAdapter {// 2重写方法进行配置

@Bean

public InternalResourceViewResolver viewResolver() {

InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();

viewResolver.setPrefix("/WEB-INF/classes/views/");

viewResolver.setSuffix(".jsp");

viewResolver.setViewClass(JstlView.class);

return viewResolver;

}

@Override

public void addResourceHandlers(ResourceHandlerRegistry registry) {

//addResourceLocations指的是文件放置的目录，

//addResourceHandler指的是对外暴露的访问路径

registry.addResourceHandler("/assets/**").addResourceLocations(

"classpath:/assets/");

}

快捷的ViewController：
我们在配置页面转向的时候使用下面的代码：

@RequestMapping("/index")

public Stirng hello(){

return "hello";

}

如果只是单纯的转向，没有其他的业务逻辑的话，这样写很麻烦，我们可以通过重写addViewControllers来简化配置：

@override

public void addViewControllers(ViewControllerRegistry registry){

registry.addViewController("/index").setViewName("index")

}

文件上传配置：

在Spring的控制器中，通过MultipartFile file来接收文件，通过MultipartFile[] files接收多个文件上传。

服务器端推送技术：

服务器推送技术在日常生活中较为常用，很多人早期的方案是使用Ajax向服务器轮询消息，这种方式的轮询频率不好控制，所以大大增加了服务器的压力。

本节的服务器端推送方案都是基于：当客户端向服务端发送请求，服务端会抓住这个请求不放，等有数据更新的时候才返回给客户端，当客户端接收到消息后，再向服务端发送请求，周而复始。这种方式的好处是大大减少了服务器的请求数量，大大减少了服务器的压力。

Spring MVC的测试：

为了测试Web项目通常不需要启动项目，我们需要一些Servlet相关的模拟对象。比如：MockMVC，MockHttpServletRequest，MockHttpServletResponse，MockHttpSession等。

测试驱动开发（TDD）：

我们按照需求先写一个自己预期结果的测试用例，这个测试用例刚开始肯定是失败的测试，随着不断的编码和重构，最终让测试用例通过测试。这样才能保证软件的质量和可控性。

我们主要借助的是JUnit来进行测试。
演示测试：

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(classes = {MyMvcConfig.class})

@WebAppConfiguration("src/main/resources") //1

public class TestControllerIntegrationTests {

private MockMvc mockMvc; //2

@Autowired

private DemoService demoService;//3

@Autowired

WebApplicationContext wac; //4

@Autowired

MockHttpSession session; //5

@Autowired

MockHttpServletRequest request; //6

@Before //7在测试开始前进行的初始化工作

public void setup() {

mockMvc =

MockMvcBuilders.webAppContextSetup(this.wac).build(); //2

}

@Test

public void testNormalController() throws Exception{

mockMvc.perform(get("/normal")) //8

.andExpect(status().isOk())//9

.andExpect(view().name("page"))//10

.andExpect(forwardedUrl("/WEB-INF/classes/views/page.jsp"))//11

.andExpect(model().attribute("msg", demoService.saySomething()));//12

}

@Test

public void testRestController() throws Exception{

mockMvc.perform(get("/testRest")) //13

.andExpect(status().isOk())

.andExpect(content().contentType("text/plain;charset=UTF-8"))//14

.andExpect(content().string(demoService.saySomething()));//15

}

第三部分.实战Spring Boot

Chapter5.Spring基础

Spring Boot：
它使用”习惯优于配置”（项目中存在大量的配置，此外还内置一个习惯性的配置，让你无须手动进行配置）的理念让你的项目快速运行起来。使用Spring Boot很容易创建一个独立运行（运行jar，内嵌servlet容器），准生产级别的给予Spring框架的项目，使用Spring Boot你可以不用或者只需很少的Spring配置。

Spring Boot核心功能：

1.独立运行的Spring项目

2.内嵌Servlet容器

3.提供starter简化Maven配置
这个确实很方便，不用自己手动添加很多依赖

4.自动配置Spring
Spring Boot会根据在类路径中的jar包，类，为jar包里的类自动配置bean，这样会极大地减少我们要使用的配置。当然，Sping Boot只是考虑了大多数的开发场景，并不是所有的场景，若在实际中需要自动配置Bean，而Spring Boot没有提供支持，那么可以自定义自动配置。（见Spring运行原理）

5.准生产的应用监控
Spring提供基于http，ssh，telnet对运行时的项目进行监控

6.无代码生成和xml配置
Spring 4.x提倡使用java配置和注解配置组合，而Spring Boot不需要任何xml配置即可实现Spring的所有配置。

一个小技巧：
在InteliJ IDEA中创建Spring项目时，选择新建Spring Initializer项目，可以添加各种starter，然后会在maven中自动添加依赖，很方便。

@SpringBootApplication是Spring Boot项目的核心注解，主要目的是开启自动配置。

Chapter6.Spring Boot核心

@SpringBootApplication是个组合注解，源码如下：

@Target({ElementType.TYPE})

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Inherited

@SpringBootConfiguration

@EnableAutoConfiguration

@ComponentScan(

excludeFilters = {@Filter(

type = FilterType.CUSTOM,

classes = {TypeExcludeFilter.class}

)}

)

Spring Boot的配置文件：

Spring Boot使用一个全局的配置文件application.properties或application.yml，放置在/src/main/resources目录或者类路径下的/config下。这里面的配置非常多，参见官方给出的附录。例如：

//将tomcat默认端口号8080改为9090，并将默认的访问路径"/"

//修改为"//hellohost"

server.port=9090

server.context-path=/hellohost

常规属性配置：

我们之前讲过在常规Spring环境下，注入properites文件里的值的方式，通过@PropertySource指明properties文件的位置，然后通过@Value注入值。在Spring Boot里，我们只需在application.properties中定义属性，然后使用@Value注入即可。

类型安全的配置（基于properties）：

上例中使用@Value注入每个配置在实际项目中会显得很麻烦，因为要写@Value注入很多次啊。

下面是一个进化版，能够通过@ConfigurationProperties将properties属性和一个Bean及其属性关联，从而实现类型安全的配置。例如：在application.properties上添加：

1 2	`author.name =zeng` `author.age =` `24`

当然也可以新建一个properties文件，这就需要我们在@ConfigurationProperties的属性locations里面指定properties的位置，且需要在入口类上配置。

类型安全的Bean：

@Component

@ConfigurationProperties(prefix = "author") //1

public class AuthorSettings {

private String name;

private Long age;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public Long getAge() {

return age;

}

public void setAge(Long age) {

this.age = age;

}

通过prefix指定配置的前缀，通过locations制定文件的位置。比如：

1	`@ConfigurationProperties(prefix =` `"author",locations={"classpath:config/author.properties"})`

日志配置：

默认情况下，Spring Boot使用Logback作为日志框架。

# LOGGING

logging.config= # Location of the logging configuration file. For instance `classpath:logback.xml` for Logback

logging.exception-conversion-word=%wEx # Conversion word used when logging exceptions.

logging.file= # Log file name. For instance `myapp.log`

logging.level.*= # Log levels severity mapping. For instance `logging.level.org.springframework=DEBUG`

logging.path= # Location of the log file. For instance `/var/log`

logging.pattern.console= # Appender pattern for output to the console. Only supported with the default logback setup.

logging.pattern.file= # Appender pattern for output to the file. Only supported with the default logback setup.

logging.pattern.level= # Appender pattern for log level (default %5p). Only supported with the default logback setup.

logging.register-shutdown-hook=false # Register a shutdown hook for the logging system when it is initialized.

Spring Boot运行原理：

在前面我们了解到Spring 4.x提供了基于条件来配置Bean的能力，其实Spring Boot的神奇的实现也是基于这一原理的。

关于Spring Boot的运作原理，还是要回归到@SpringBootApplication注解上来，这个注解是一个组合注解，前面已经演示过了，它的核心功能是由@EnableAutoConfiguration注解来提供的。

Chapter7.Spring Boot的Web开发

Spring Boot提供了spring-boot-starter-web为Web开发予以支持，spring-boot-starter-web为我们提供了嵌入的Tomcat以及Spring MVC的依赖。而Web相关的自动配置存储在org.springframework.web下。从这些文件名可以看出：

1.ServerPropertiesAutoConfiguration和ServerPropertes自动配置内嵌的Servlet容器

2.HttpEncodingAutoConfiguration和HttpEncodingProperties用来自动配置http的编码

3.MultipartAutoConfiguration和MultipartProperties用来自自动配置上传文件的属性

4.JacksonHttpMessageConvertersConfiguration用来自动配置mappingJackson2HttpMessageConverter和mappingJackson2XmlHttpMessageConverter。

5.WebMvcAutoConfiguration和WebMvcProperties配置Spring MVC。

Thymeleaf与Spring MVC的集成：

@Bean

public TemplateResolver templateResovler(){

TemplateResovler templateResovler = new ServletContextTemplateResovler();

templateResovler.setPrefix("/WEB-INF/templates");

templateResovler.setSuffix(".html");

templateResovler.setTemplateMode("HTML5");

return templateResovler;

}

@Bean

public SpringTemplateEngine templateEngine(){

SpringTemplateEngine templateEngine = new SpringTemplateEngine();

templateEngine.setTemplateResovler(templateResovler());

return templateEngine;

}

@Bean

public ThymeleafViewResovler thymeleafVewResolver(){

ThymeleafViewResolver thymeleafVewResolver = new ThymeleafViewResovler();

ThymeleafViewResovler.setTemplateEngine(templateEngine());

return ThymeleafViewResovler;

}

在Spring MVC中虽然有引擎，让配置变得不那么麻烦，但还是太繁琐了啊。看看Spring Boot吧。

Thymeleaf与Spring Boot的集成：

上一部分的一切配置在Spring Boot中一切都是不需要的。Spring Boot通过org.springframework.boot.autoconfigure.thymeleaf包对Thymeleaf进行了自动配置。我们只需要在application.properties中进行适当的配置即可：

# THYMELEAF (ThymeleafAutoConfiguration)

spring.thymeleaf.cache=true # Enable template caching.

spring.thymeleaf.check-template=true # Check that the template exists before rendering it.

spring.thymeleaf.check-template-location=true # Check that the templates location exists.

spring.thymeleaf.content-type=text/html # Content-Type value.

spring.thymeleaf.enabled=true # Enable MVC Thymeleaf view resolution.

spring.thymeleaf.encoding=UTF-8 # Template encoding.

spring.thymeleaf.excluded-view-names= # Comma-separated list of view names that should be excluded from resolution.

spring.thymeleaf.mode=HTML5 # Template mode to be applied to templates. See also StandardTemplateModeHandlers.

spring.thymeleaf.prefix=classpath:/templates/ # Prefix that gets prepended to view names when building a URL.

spring.thymeleaf.suffix=.html # Suffix that gets appended to view names when building a URL.

spring.thymeleaf.template-resolver-order= # Order of the template resolver in the chain.

spring.thymeleaf.view-names= # Comma-separated list of view names that can be resolved.

接管Spring Boot的Web配置：

好好读读下面两段话：

如果Spring Boot提供的Spring MVC默认配置不符合你的需求，则可以通过一个配置类（注解有@Configuration）加上@EnableWebMvc注解来实现完全自己控制的MVC配置。这种情况，这种方法不推荐。

当然，在通常情况下，Spring Boot的自动配置是符合我们大多数需求的。在你既需要保留Spring Boot提供的便利，又需要增加自己的额外的配置的时候，可以定义一个配置类并继承WebMvcConfigurerAdapter，无须使用@EnableWebMvc注解。然后按照第4章讲的Spring MVC的配置方法来添加Spring Boot为我们所做的其他配置。

关键点是：可以通过Spring MVC的配置方法来配置Spring Boot。

@Configuration

public class WebMvcConfig extends WebMvcConfigurerAdapter{

@override

public void addViewControllers(ViewControllerRegistry registry){

registry.addViewController("/xx").addViewName("xx");

}

值得指出的是：在这里重写的addViewController方法，并不会覆盖WebMvcAutoConfiguration中的addViewControllers（在源码中，默认的有一个配置，Spring Boot将”/”映射到index.html），这也就意味着我们的配置和Spring Boot的自动配置同时有效，这也是我们推荐添加自己的MVC配置的方式。

WebSocket：

WebSocket为浏览器和服务端提供了双工异步通信的功能，即浏览器可以向服务端发送消息，服务端也可以向浏览器发送消息。

WebSocket是通过一个socket来实现双工异步通信能力的。但是直接使用WebSocket协议会显得非常繁琐，我们会使用它的子协议STOMP，它是一个更高级别的协议，STOMP协议使用一个基于帧（frame）的格式来定义信息，与HTTP的request和response类似（具有类似于@RequestMapping的@MessageMapping）。

1.广播式：
广播式即服务端有消息时，会将消息发送给所有连接了当前endpoint的浏览器。

2.点对点式：
广播式有自己的应用场景，但是广播式不能解决我们一个常见的场景，即消息由谁发送，由谁接收的问题。

基于Bootstrap和AngularJS的现代Web应用：

现代的B/S系统有下面几个特色：

1.单页面应用

单页面应用（single-page application，简称SPA）值的是一种类似于原生客户端软件的更流畅的用户体验页面。

在单页面的应用中，所有的资源（HTML，JavaScript，CSS）都是按需动态加载到页面上的，且不需要服务端控制页面的转向。

2.响应式设计

响应式设计（Responsive web design，简称RWD）指的是不同的设备访问相同的页面的时候，得到不同的页面视图，而得到的视图是适应当前屏幕的。

3.数据导向

数据导向是对于页面导向而言的，页面上的数据获得是通过消费后台的REST服务来实现的，而不是通过服务器渲染的动态界面（如JSP）来实现的，一般数据交换使用的格式是JSON。

AngularJS：

HTML一般是用来申明静态页面的，但是通常情况下我们希望页面是基于数据动态生成的，这也是我们很多服务器端模板引擎出现的原因，而AngularJS可以只通过前端技术就实现动态的页面。

@RestController

@SpringBootApplication

public class Ch77Application {

@RequestMapping(value="/search",produces={MediaType.APPLICATION_JSON_VALUE})

public Person search(String personName){

return new Person(personName, 32, "hefei");

}

public static void main(String[] args) {

SpringApplication.run(Ch77Application.class, args);

}

上面的代码我们模拟一个查询，即接收前台传入的personName，然后返回Person类，因为我们使用的是@RestController，且返回值类型是Person，所以Spring MVC会自动将对象输出为JSON。注意代码中的：

1	`produces={MediaType.APPLICATION_JSON_VALUE}`

Chapter8.Spring Boot的数据访问

Spring Data为我们使用统一的API来对很多数据存储技术（比如关系性和非关系型数据库）进行数据访问操作提供了支持。这是Spring通过提供Spring Data Commons项目来实现的，它是上述各种Spring Data项目的依赖。Spring Data Commons让我们在使用关系型或非关系型数据访问技术时都使用基于Spring的统一标准，该标准包含CURD（创建，获取，更新，删除），查询，排序和分页的相关操作。

秒客网

Spring Boot实战

第一部分.点睛Spring 4.x

Chapter1.Spring基础

Chapter2.Spring常用配置

Chapter3.Spring高级话题

vc-4x">第二部分.点睛Spring MVC 4.x

第三部分.实战Spring Boot

Chapter5.Spring基础

Chapter6.Spring Boot核心

Chapter7.Spring Boot的Web开发

Chapter8.Spring Boot的数据访问

相关文章