Spring Boot实战
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表达式语言。
示例:
1
2
3
4
5
6
7
8
9
|
//注入普通字符串 @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等。例如:
1
2
3
4
|
//每个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类)。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
//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目录下)下。
1
2
3
4
5
6
7
8
9
10
|
@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更简洁,而且也更推荐。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
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控制器:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
@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控制器:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
@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的配置支持,这样我们就可以重写这个类的方法,完成我们的常用配置。
静态资源映射:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
@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:
我们在配置页面转向的时候使用下面的代码:
1
2
3
4
|
@RequestMapping ( "/index" ) public Stirng hello(){ return "hello" ; } |
如果只是单纯的转向,没有其他的业务逻辑的话,这样写很麻烦,我们可以通过重写addViewControllers来简化配置:
1
2
3
4
|
@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来进行测试。
演示测试:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
@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是个组合注解,源码如下:
1
2
3
4
5
6
7
8
9
10
11
12
|
@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下。这里面的配置非常多,参见官方给出的附录。例如:
1
2
3
4
|
//将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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
@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作为日志框架。
1
2
3
4
5
6
7
8
9
10
|
# 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的集成:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
@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中进行适当的配置即可:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
# 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。
1
2
3
4
5
6
7
8
|
@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可以只通过前端技术就实现动态的页面。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
@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 boot实战(第十三篇)自动配置原理分析
前言 spring Boot中引入了自动配置,让开发者利用起来更加的简便.快捷,本篇讲利用RabbitMQ的自动配置为例讲分析下Spring Boot中的自动配置原理. 在上一篇末尾讲述了Spring ...
- spring boot实战(第十二篇)整合RabbitMQ
前言 最近几篇文章将围绕消息中间件RabbitMQ展开,对于RabbitMQ基本概念这里不阐述,主要讲解RabbitMQ的基本用法.Java客户端API介绍.spring Boot与RabbitMQ整 ...
- 《spring boot 实战》读书笔记
前言:虽然已经用spring boot开发过一套系统,但是之前都是拿来主义,没有系统的,全面的了解过这套框架.现在通过学习<spring boot实战>这本书,希望温故知新.顺便实现自己的 ...
- Spring Boot实战系列-----------邮件发送
快速导航 添加Maven依赖 配置文件增加邮箱相关配置 Service.Test项目代码构建 五种邮件发送类型讲解 文本邮件 html邮件 附件邮件 html内嵌图片邮件 模板邮件 问题汇总 添加ma ...
- Spring Boot 实战与原理分析视频课程
Spring Boot 实战与原理分析视频课程 链接:https://pan.baidu.com/share/init?surl=PeykcoeqZtd1d9lN9V_F-A 提取码: 关注公众号[G ...
- spring boot实战(第一篇)第一个案例
版权声明:本文为博主原创文章,未经博主允许不得转载. 目录(?)[+] spring boot实战(第一篇)第一个案例 前言 写在前面的话 一直想将spring boot相关内容写成一个系列的 ...
- [转] Spring Boot实战之Filter实现使用JWT进行接口认证
[From] http://blog.csdn.net/sun_t89/article/details/51923017 Spring Boot实战之Filter实现使用JWT进行接口认证 jwt(j ...
- 9.Spring Boot实战之配置使用Logback进行日志记录
转自:https://blog.csdn.net/meiliangdeng1990/article/details/54300227 Spring Boot实战之配置使用Logback进行日志记录 在 ...
- Spring Boot实战之定制URL匹配规则
本文首发于个人网站:Spring Boot实战之定制URL匹配规则 构建web应用程序时,并不是所有的URL请求都遵循默认的规则.有时,我们希望RESTful URL匹配的时候包含定界符". ...
- Spring Boot实战之定制type Formatters
本文首发于个人网站:Spring Boot实战之定制type Formatters 前面我们有篇文章介绍了PropertyEditors,是用来将文本类型转换成指定的Java类型,不过,考虑到Prop ...
随机推荐
- Flutter上拉加载下拉刷新---flutter_easyrefresh
前言 Flutter默认不支持上拉加载,下拉刷新也仅仅支持Material的一种样式.Android开发使用过SmartRefreshLayout的小伙伴都知道这是一个强大的刷新UI库,集成了很多出色 ...
- Django Rest framework 框架之认证使用和源码执行流程
用这个框架需要先安装: pip3 install djangorestframework 如果写了一个CBV的东西,继承了View. # 继承Django里面View class APIView(Vi ...
- 解决方法:CentOS7用yum安装软件显示错误:cannot find a valid baseurl for repo: base/7/x86_64
在Linux学习中,发现使用yum安装软件出现以下的错误: 百度了各种方法,很多人也发现光是修改REBOOT=yes也没用,多次进行挂载.修改网卡配置文件.重置IP地址.重启网络.创建又删除配置文件的 ...
- 建议2---编写pythonic代码
(1)要避免劣化代码 1)避免只用大小写来区分不同的对象.如a是一个数值类型变量,A是String类型,虽在编码过程容易区分二者的含义,但这样做毫无益处,它不会给其他阅读代码的人带来多少便利. 2)避 ...
- linux安装php7.2.7
1.下载php 官网下载:#wget http://cn2.php.net/get/php-7.2.7.tar.gz/from/a/mirror.(ps:应该是这么下载的,但是我下载的都是一个mirr ...
- Django--CRM-客户列表展示, 分页
一 . 客户列表展示 为了插入数据方便,我们可以用django里面的admin插入数据 创建超级用户 把语言改成中文 结果: 列表展示 展示不同字段的方式: # 有需要的可以写 def__str__( ...
- python之路--BOM和DOM
一. 介绍 之前学的JS的一些简单的语法并没有和浏览器有任何的交互. 我们要想制作一些我们经常看到的网页的一些交互,我们需要继续学习BOM和DOM相关知识. JavaScript 分为 ECMAScr ...
- Yii2的save()方法容易出错的地方
如果save()返回true, 但是数据没有保存成功,则应该是开启了事务且已经回滚 如果save()返回false, 则使用$model->errors查看错误原因 可以设置$model的场景, ...
- 刪除nodejs
https://www.cnblogs.com/fighxp/p/7410235.html https://www.cnblogs.com/fighxp/p/7411608.html
- C# 23种设计模式汇总
创建型模式工厂方法(Factory Method)在工厂方法模式中,工厂方法用来创建客户所需要的产品,同时还向客户隐藏了哪种具体产品类将被实例化这一细节.工厂方法模式的核心是一个抽象工厂类,各种具体工 ...