要搭建一个微服务，运维和部署都变得非常复杂，spring提供了一套解决方案：
springBoot: 快速构建单个服务；
springcloud: 是一系列有序框架的集合，其主要的设施有，服务发现与注册，配置中心，消息总线，负载均衡，断路器，数据监控等，通过Spring Boot 的方式，可以实现一键启动，和部署。
Spring cloud data flow: 为基于微服务的分布式流处理和批处理数据通道提供了一系列模型和最佳实践.
官方网站：
https: / / spring. io/ projects/ spring- boot
Spring - Boot 是由Pivotal 团队提供的全新框架，其设计目的是用来简化新Spring 应用的初始搭建以及开发过程。个人理解来说Spring - Boot 其实不是什么新的框架，它默认配置了很多框架的使用方式，就像maven整合了所有的jar包，Spring - Boot 整合了其他相关联框架。
总结： springboot 全新框架，底层是spring springmvc， 并且提供了很多关联框架。 简化spring项目的开发。
1 、快速构建项目。
2 、对主流开发框架的无配置集成。 内部集成了优秀的框架
3 、项目可独立运行，无须外部依赖Servlet 容器。内置了 tomcat jetty
4 、提供运行时的应用监控。
5 、极大的提高了开发、部署效率。
6 、与云计算的天然集成。
云原生~
1 、独立运行Spring 项目
Spring Boot 可以以jar包形式独立运行，运行一个Spring Boot 项目只需要通过java - jar xx. jar来运行。
2 、内嵌servlet容器
Spring Boot 可以选择内嵌Tomcat 、jetty或者Undertow , 这样我们无须以war包形式部署项目。
3 、提供starter简化Maven 配置[ 重点]
spring提供了一系列的start pom来简化Maven 的依赖加载，例如，当你使用了spring- boot- starter- web，会自动加入如图5 - 1 所示的依赖包。
4 、自动装配Spring 【重点】
Spring Boot 会根据在类路径中的jar包，类、为jar包里面的类自动配置Bean ，这样会极大地减少我们要使用的配置。当然，Spring Boot 只考虑大多数的开发场景，并不是所有的场景，若在实际开发中我们需要配置Bean ，而Spring Boot 灭有提供支持，则可以自定义自动配置。
5 、准生产的应用监控
Spring Boot 提供基于http ssh telnet对运行时的项目进行监控。
6 、无代码生产和xml配置
Spring Boot 不是借助与代码生成来实现的，而是通过条件注解来实现的，这是Spring4 . x提供的新特性。
< parent> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> </ parent> < dependencies> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> </ dependency> </ dependencies> Spring Boot 将所有的功能场景都抽取出来，做成一个个的starters（启动器），只需要在项目里面引入这些starter 相关场景的所有依赖都会导入进来。要用什么功能就导入什么场景的启动器 。
@SpringBootApplication
public class Example {
public static void main ( String [ ] args) {
SpringApplication . run ( Example . class , args) ;
}
}
@SpringBootApplication : 注解说明这个类是SpringBoot 的主配置类，SpringBoot 就应该运行这个类的main方法来启动SpringBoot 应用；并将主配置类（@SpringBootApplication 标注的类）的所在包及下面所有子包里面的所有组件扫描到Spring 容器；
@Controller
public class TestController {
@RequestMapping ( "/hello" )
@ResponseBody
public String helloWorld ( ) {
return "Hello world!" ;
}
}
< build> < plugins> < plugin> < groupId> </ groupId> < artifactId> </ artifactId> </ plugin> </ plugins> </ build>
执行打包命令后，会在target目录下生成项目对应的jar包。
1 、java文件夹目录结构中自动创建好指定包和Spring Boot 启动主程序SpringbootApplication . class ；
2 、resources文件夹中目录结构
static ：保存所有的静态资源； js css images；
templates：保存所有的模板页面，（Spring Boot 默认jar包使用嵌入式的Tomcat ，默认不支持JSP 页面），可以使用模板引擎（freemarker、thymeleaf）；
application. properties：Spring Boot 应用的配置文件；可以修改一些默认设置；
该配置文件能够被自动读取。
Spring Boot 使用一个全局的配置文件，配置文件名是固定的；默认使用以下两种格式：
•application. properties
•application. yml
配置文件的作用：修改SpringBoot 自动配置的默认值；Spring Boot 启动时会根据配置文件自动注册相关的应用组件；
YAML ：以数据为中心，比json、xml等更适合做配置文件；
– 使用缩进表示层级关系
– 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可 – 大小写敏感
- 键值对中间必须要有空格k:(空格)v
YAML 支持的三种数据结构:
server :
port : 8081
注意：字符串默认不用加上单引号或者双引号；
双引号：特殊符号表示转义符本身；
name : "zhangsan \n lisi"：输出；zhangsan 换行 lisi
单引号；特殊字符就表示字符本身；
name : ‘zhangsan \n lisi’：输出；zhangsan \n lisi
person :
name : zhangsan
age : 12
另一种行内写法：
person : { name : zhangsan, age : 12 }
hobbies :
- singing
- dancing
- running
用- （空格）值表示数组中的一个元素
另一种行内写法：
hobbies : [ singing, dancing, running]
yaml参考文档
@Component
@ConfigurationProperties ( prefix = "person" )
public class Person {
private String pname;
private int age;
private boolean success;
private Date birth;
private Car car;
private Map < String , Object > ;
private List < Object > ;
}
总结： @ConfigurationProperties ( prefix = "person" ) + @Component 结合使用
或是
@ConfigurationProperties ( prefix = "person" ) + @EnableConfigurationProperties ( Person . class ) 注解共同使用
注：@EnableConfigurationProperties ( Person . class ) 加在启动类或测试类上
@ConfigurationProperties ( prefix = "person" ) 加在要获取数据的类上
person :
pname : zhangsan
age : 12
birth : 2020/12/12
success : true
car :
cname : 奔驰
cprice : 200.0
lists : [ 唱歌, 跳舞]
maps : { key1 : v1, key2 : v2}
@SpringBootTest
class SpringbootApplicationTests {
@Autowired
private Person person;
@Test
void contextLoads ( ) {
System . out. println ( person) ;
}
}
< dependency> < groupId> </ groupId> < artifactId> </ artifactId> < optional> </ optional> </ dependency> 以KEY=VALue键值对的方式设置值
name=张三
person.name=张三
person.age=12
maps.key1=value1
maps.key2=value2
hobbies=singing,dancing,running
@Component
@ConfigurationProperties ( prefix = "person" )
public class Person {
private String pname;
private int age;
private boolean success;
private Date birth;
private Car car;
private Map < String , Object > ;
private List < Object > ;
}
person.pname=张三
person.age=12
person.birth=2019/12/12
person.success=true
person.car.cname=宝马
person.car.cprice=100.0
person.lists=唱歌,跳舞,跑步
person.maps.k1=value1
person.maps.k2=value2
@SpringBootTest
class SpringbootApplicationTests {
@Autowired
private Person person;
@Test
void contextLoads ( ) {
System . out. println ( person) ;
}
}
@ConfigurationProperties 注解和@Value 注解的区别
1 、@ConfigurationProperties 注解用于根据配置文件批量注入值，springboot默认配置文件application. yml/ application. properties；
2 、@Value 注解用于根据配置文件单个注入值；
区别 @ConfigurationProperties @Value SpEL 不支持 支持：@Value(“${jdbc.url}”) 复杂类型封装 支持 不支持
案例：
@Component
public class Person {
@Value ( "${person.pname}" )
private String pname;
@Value ( "#{12*2}" )
private int age;
private boolean success;
private Date birth;
private Car car;
private Map < String , Object > ;
private List < Object > ;
}
1、springboot全局配置文件中可以使用随机数
${random.value}、${random.int}、${random.long}
${random.int(10)}、${random.int[1024,65536]}
2、springboot全局配置文件中可以使用占位符
通过${属性名}获取已经在配置文件中加载过的属性值；
通过${属性名:默认值}来指定找不到属性时的默认值；
案例：
person.pname=张三
person.age=${random.int}
person.success=true
person.birth=2012/12/12
person.car.cname=${car.cname:奔驰}
person.car.cprice=200.0
person.map.key1=value1
person.map.key2=value2
person.hobbies=唱歌,跳舞,跑步
Profile是Spring对不同环境提供不同配置功能的支持，可以通过激活、指定参数等方式快速切换环境；
1、多文件多环境形式：
格式：application- { profile} .properties/yml
例如：可以在项目中创建如下主配置文件：application- dev.properties、application- test.properties、application- prod.properties、application.properties, 默认使用application.properties, 可以通过配置spring.profiles.active=profile指定使用某个环境的配置文件。
2、yaml支持单文件多环境形式：
spring :
profiles :
active : test
---
spring :
profiles : dev
server :
port : 8081
spring :
config :
activate :
on-profile : dev
server :
port : 8081
---
spring :
profiles : test
server :
port : 8082
通过--- 来区分不同的profile环境。
3、激活方式：
在配置文件中指定 spring.profiles.active=dev
命令行 java - jar springboot- 0.0.1- SNAPSHOT.jar - - spring.profiles.active=dev
jvm参数 - Dspring.profiles.active=dev
springboot默认会从以下位置加载配置文件：application. properties/ application. yml
项目所在磁盘路径file: . /config/
项目所在磁盘路径file: . /
项目类路径classpath: / config/
项目类路径classpath: /
优先级由高到底，高优先级的配置会覆盖低优先级的配置；SpringBoot 会从这四个位置全部加载主配置文件，互补配置；
如果要加载其他位置的配置文件，可以通过-- spring. config. location（只能加到命令行）来指定要加载的配置文件的位置。
springboot启动时会根据配置文件自动配置相应场景的组件xxxAutoConfiguration，web项目启动时会初始化WebMvcAutoConfiguration 组件处理请求相关的操作，其中有默认处理静态资源的方法：
@Override
protected void addResourceHandlers ( ResourceHandlerRegistry registry) {
super . addResourceHandlers ( registry) ;
if ( ! this . resourceProperties. isAddMappings ( ) ) {
logger. debug ( "Default resource handling disabled" ) ;
return ;
}
ServletContext servletContext = getServletContext ( ) ;
addResourceHandler ( registry, "/webjars/**" , "classpath:/META-INF/resources/webjars/" ) ;
addResourceHandler ( registry, this . mvcProperties. getStaticPathPattern ( ) , ( registration) -> {
registration. addResourceLocations ( this . resourceProperties. getStaticLocations ( ) ) ;
if ( servletContext != null ) {
registration. addResourceLocations ( new ServletContextResource ( servletContext, SERVLET_LOCATION ) ) ;
}
} ) ;
}
从该方法中可以发现：
1 、默认情况下：
（1 ）匹配/ webjars我们可以通过webjars以jar包的方式引入静态资源。
js: js库文件下载， copy当中的工程： js vue elementUI：
静态资源坐标参考
< dependency> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> </ dependency> 浏览器访问路径：http: / / localhost: 8080 / webjars/ jquery/ 3.6 .0 / jquery. min. js获取相应的静态资源。
默认静态资源路径：
"classpath:/META‐INF/resources/"
"classpath:/resources/"
"classpath:/static/"
"classpath:/public/"
"/" ：当前项目的根路径
案例：在上述任意路径下创建静态资源hello. html, 浏览器访问路径：http: / / localhost: 8080 / hello. html获取相应的静态资源。
在配置文件中通过属性spring. web. resources. static - locations= 自定义路径，设置自定义静态资源存放路径；
案例：
a、配置文件中设置：spring. web. resources. static - locations= classpath: / hello/
yml文件：
spring:
web:
resources:
static - locations: [ classpath: / hello/ , classpath: / static / ]
b、在自定义路径下添加静态资源hello. html, 浏览器访问路径：http: / / localhost: 8080 / hello. html获取相应的静态资源。
注意：自定义静态资源路径后，默认静态资源路径失效！
@SpringBootApplication
public class SpringbootApplication {
public static void main ( String [ ] args) {
SpringApplication . run ( SpringbootApplication . class , args) ;
}
}
@Target ( ElementType . TYPE )
@Retention ( RetentionPolicy . RUNTIME )
@Documented
@Inherited
@AutoConfigurationPackage
@Import ( AutoConfigurationImportSelector . class )
public @interface EnableAutoConfiguration {
. . .
}
@Override
public String [ ] selectImports ( AnnotationMetadata annotationMetadata) {
if ( ! isEnabled ( annotationMetadata) ) {
return NO_IMPORTS ;
}
AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry ( annotationMetadata) ;
return StringUtils . toStringArray ( autoConfigurationEntry. getConfigurations ( ) ) ;
}
protected AutoConfigurationEntry getAutoConfigurationEntry ( AnnotationMetadata annotationMetadata) {
if ( ! isEnabled ( annotationMetadata) ) {
return EMPTY_ENTRY ;
}
AnnotationAttributes attributes = getAttributes ( annotationMetadata) ;
List < String > = getCandidateConfigurations ( annotationMetadata, attributes) ;
configurations = removeDuplicates ( configurations) ;
Set < String > = getExclusions ( annotationMetadata, attributes) ;
checkExcludedClasses ( configurations, exclusions) ;
configurations. removeAll ( exclusions) ;
configurations = getConfigurationClassFilter ( ) . filter ( configurations) ;
fireAutoConfigurationImportEvents ( configurations, exclusions) ;
return new AutoConfigurationEntry ( configurations, exclusions) ;
}
protected List < String > getCandidateConfigurations ( AnnotationMetadata metadata, AnnotationAttributes attributes) {
List < String > = SpringFactoriesLoader . loadFactoryNames ( getSpringFactoriesLoaderFactoryClass ( ) ,
getBeanClassLoader ( ) ) ;
Assert . notEmpty ( configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
+ "are using a custom packaging, make sure that file is correct." ) ;
return configurations;
}
public static List < String > loadFactoryNames ( Class < ? > , @Nullable ClassLoader classLoader) {
ClassLoader classLoaderToUse = classLoader;
if ( classLoaderToUse == null ) {
classLoaderToUse = SpringFactoriesLoader . class . getClassLoader ( ) ;
}
String factoryTypeName = factoryType. getName ( ) ;
return loadSpringFactories ( classLoaderToUse) . getOrDefault ( factoryTypeName, Collections . emptyList ( ) ) ;
}
private static Map < String , List < String > > loadSpringFactories ( ClassLoader classLoader) {
Map < String , List < String > > = cache. get ( classLoader) ;
if ( result != null ) {
return result;
}
result = new HashMap < > ( ) ;
try {
Enumeration < URL> = classLoader. getResources ( FACTORIES_RESOURCE_LOCATION ) ;
while ( urls. hasMoreElements ( ) ) {
URL url = urls. nextElement ( ) ;
UrlResource resource = new UrlResource ( url) ;
Properties properties = PropertiesLoaderUtils . loadProperties ( resource) ;
for ( Map. Entry < ? , ? > : properties. entrySet ( ) ) {
String factoryTypeName = ( ( String ) entry. getKey ( ) ) . trim ( ) ;
String [ ] factoryImplementationNames =
StringUtils . commaDelimitedListToStringArray ( ( String ) entry. getValue ( ) ) ;
for ( String factoryImplementationName : factoryImplementationNames) {
result. computeIfAbsent ( factoryTypeName, key -> new ArrayList < > ( ) )
. add ( factoryImplementationName. trim ( ) ) ;
}
}
}
result. replaceAll ( ( factoryType, implementations) -> implementations. stream ( ) . distinct ( )
. collect ( Collectors . collectingAndThen ( Collectors . toList ( ) , Collections :: unmodifiableList ) ) ) ;
cache. put ( classLoader, result) ;
}
catch ( IOException ex) {
throw new IllegalArgumentException ( "Unable to load factories from location [" +
FACTORIES_RESOURCE_LOCATION + "]" , ex) ;
}
return result;
}
public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories" ;
获取到配置文件中的自动配置类xxxAutoConfiguration的信息，并将自动配置类中的组件初始化到容器中。
初始化的过程中会加载xxxProperties对象，根据xxxProperties对象中的属性值初始化组件, xxxProperties对象的值可以通过全局配置文件指定。
以Spring Boot 自动配置SpringMVC 为例，Spring Boot 启动时会做以下操作：
@Configuration ( proxyBeanMethods = false )
@ConditionalOnWebApplication ( type = Type . SERVLET )
@ConditionalOnClass ( { Servlet . class , DispatcherServlet . class , WebMvcConfigurer . class } )
@ConditionalOnMissingBean ( WebMvcConfigurationSupport . class )
@AutoConfigureOrder ( Ordered . HIGHEST_PRECEDENCE + 10 )
@AutoConfigureAfter ( { DispatcherServletAutoConfiguration . class , TaskExecutionAutoConfiguration . class ,
ValidationAutoConfiguration . class } )
public class WebMvcAutoConfiguration {
@Bean
@ConditionalOnBean ( ViewResolver . class )
@ConditionalOnMissingBean ( name = "viewResolver" , value = ContentNegotiatingViewResolver . class )
public ContentNegotiatingViewResolver viewResolver ( BeanFactory beanFactory) {
ContentNegotiatingViewResolver resolver = new ContentNegotiatingViewResolver ( ) ;
resolver. setContentNegotiationManager ( beanFactory. getBean ( ContentNegotiationManager . class ) ) ;
resolver. setOrder ( Ordered . HIGHEST_PRECEDENCE ) ;
return resolver;
}
@Bean
@ConditionalOnBean ( View . class )
@ConditionalOnMissingBean
public BeanNameViewResolver beanNameViewResolver ( ) {
BeanNameViewResolver resolver = new BeanNameViewResolver ( ) ;
resolver. setOrder ( Ordered . LOWEST_PRECEDENCE - 10 ) ;
return resolver;
}
@Override
protected void addResourceHandlers ( ResourceHandlerRegistry registry) {
super . addResourceHandlers ( registry) ;
if ( ! this . resourceProperties. isAddMappings ( ) ) {
logger. debug ( "Default resource handling disabled" ) ;
return ;
}
ServletContext servletContext = getServletContext ( ) ;
addResourceHandler ( registry, "/webjars/**" , "classpath:/META-INF/resources/webjars/" ) ;
addResourceHandler ( registry, this . mvcProperties. getStaticPathPattern ( ) , ( registration) -> {
registration. addResourceLocations ( this . resourceProperties. getStaticLocations ( ) ) ;
if ( servletContext != null ) {
registration. addResourceLocations ( new ServletContextResource ( servletContext, SERVLET_LOCATION ) ) ;
}
} ) ;
}
-- -- -- -- -- -- -- -- - 内部类-- -- -- -- -- -- -- -- -- --
@Configuration ( proxyBeanMethods = false )
@Import ( EnableWebMvcConfiguration . class )
@EnableConfigurationProperties ( { WebMvcProperties . class ,
org. springframework. boot. autoconfigure. web. ResourceProperties. class , WebProperties . class } )
@Order ( 0 )
public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer {
private final WebMvcProperties mvcProperties;
private final ListableBeanFactory beanFactory;
private final ObjectProvider < HttpMessageConverters > ;
private final ObjectProvider < DispatcherServletPath > ;
private final ObjectProvider < ServletRegistrationBean < ? > > ;
final ResourceHandlerRegistrationCustomizer resourceHandlerRegistrationCustomizer;
public WebMvcAutoConfigurationAdapter ( WebProperties webProperties, WebMvcProperties mvcProperties,
ListableBeanFactory beanFactory, ObjectProvider < HttpMessageConverters > ,
ObjectProvider < ResourceHandlerRegistrationCustomizer > ,
ObjectProvider < DispatcherServletPath > ,
ObjectProvider < ServletRegistrationBean < ? > > ) {
this . mvcProperties = mvcProperties;
this . beanFactory = beanFactory;
this . messageConvertersProvider = messageConvertersProvider;
this . resourceHandlerRegistrationCustomizer = resourceHandlerRegistrationCustomizerProvider. getIfAvailable ( ) ;
this . dispatcherServletPath = dispatcherServletPath;
this . servletRegistrations = servletRegistrations;
this . mvcProperties. checkConfiguration ( ) ;
}
@Override
public void configureMessageConverters ( List < HttpMessageConverter < ? > > ) {
this . messageConvertersProvider
. ifAvailable ( ( customConverters) -> converters. addAll ( customConverters. getConverters ( ) ) ) ;
}
@Override
public void configureAsyncSupport ( AsyncSupportConfigurer configurer) {
if ( this . beanFactory. containsBean ( TaskExecutionAutoConfiguration . APPLICATION_TASK_EXECUTOR_BEAN_NAME ) ) {
Object taskExecutor = this . beanFactory
. getBean ( TaskExecutionAutoConfiguration . APPLICATION_TASK_EXECUTOR_BEAN_NAME ) ;
if ( taskExecutor instanceof AsyncTaskExecutor ) {
configurer. setTaskExecutor ( ( ( AsyncTaskExecutor ) taskExecutor) ) ;
}
}
Duration timeout = this . mvcProperties. getAsync ( ) . getRequestTimeout ( ) ;
if ( timeout != null ) {
configurer. setDefaultTimeout ( timeout. toMillis ( ) ) ;
}
}
@Override
public void configurePathMatch ( PathMatchConfigurer configurer) {
if ( this . mvcProperties. getPathmatch ( )
. getMatchingStrategy ( ) == WebMvcProperties. MatchingStrategy . PATH_PATTERN_PARSER ) {
configurer. setPatternParser ( new PathPatternParser ( ) ) ;
}
configurer. setUseSuffixPatternMatch ( this . mvcProperties. getPathmatch ( ) . isUseSuffixPattern ( ) ) ;
configurer. setUseRegisteredSuffixPatternMatch (
this . mvcProperties. getPathmatch ( ) . isUseRegisteredSuffixPattern ( ) ) ;
this . dispatcherServletPath. ifAvailable ( ( dispatcherPath) -> {
String servletUrlMapping = dispatcherPath. getServletUrlMapping ( ) ;
if ( servletUrlMapping. equals ( "/" ) && singleDispatcherServlet ( ) ) {
UrlPathHelper urlPathHelper = new UrlPathHelper ( ) ;
urlPathHelper. setAlwaysUseFullPath ( true ) ;
configurer. setUrlPathHelper ( urlPathHelper) ;
}
} ) ;
}
private boolean singleDispatcherServlet ( ) {
return this . servletRegistrations. stream ( ) . map ( ServletRegistrationBean :: getServlet )
. filter ( DispatcherServlet . class :: isInstance ) . count ( ) == 1 ;
}
@Override
public void configureContentNegotiation ( ContentNegotiationConfigurer configurer) {
WebMvcProperties. Contentnegotiation contentnegotiation = this . mvcProperties. getContentnegotiation ( ) ;
configurer. favorPathExtension ( contentnegotiation. isFavorPathExtension ( ) ) ;
configurer. favorParameter ( contentnegotiation. isFavorParameter ( ) ) ;
if ( contentnegotiation. getParameterName ( ) != null ) {
configurer. parameterName ( contentnegotiation. getParameterName ( ) ) ;
}
Map < String , MediaType > = this . mvcProperties. getContentnegotiation ( ) . getMediaTypes ( ) ;
mediaTypes. forEach ( configurer:: mediaType ) ;
}
@Bean
@ConditionalOnMissingBean
public InternalResourceViewResolver defaultViewResolver ( ) {
InternalResourceViewResolver resolver = new InternalResourceViewResolver ( ) ;
resolver. setPrefix ( this . mvcProperties. getView ( ) . getPrefix ( ) ) ;
resolver. setSuffix ( this . mvcProperties. getView ( ) . getSuffix ( ) ) ;
return resolver;
}
@Bean
@ConditionalOnBean ( View . class )
@ConditionalOnMissingBean
public BeanNameViewResolver beanNameViewResolver ( ) {
BeanNameViewResolver resolver = new BeanNameViewResolver ( ) ;
resolver. setOrder ( Ordered . LOWEST_PRECEDENCE - 10 ) ;
return resolver;
}
@Bean
@ConditionalOnBean ( ViewResolver . class )
@ConditionalOnMissingBean ( name = "viewResolver" , value = ContentNegotiatingViewResolver . class )
public ContentNegotiatingViewResolver viewResolver ( BeanFactory beanFactory) {
ContentNegotiatingViewResolver resolver = new ContentNegotiatingViewResolver ( ) ;
resolver. setContentNegotiationManager ( beanFactory. getBean ( ContentNegotiationManager . class ) ) ;
resolver. setOrder ( Ordered . HIGHEST_PRECEDENCE ) ;
return resolver;
}
@Override
public MessageCodesResolver getMessageCodesResolver ( ) {
if ( this . mvcProperties. getMessageCodesResolverFormat ( ) != null ) {
DefaultMessageCodesResolver resolver = new DefaultMessageCodesResolver ( ) ;
resolver. setMessageCodeFormatter ( this . mvcProperties. getMessageCodesResolverFormat ( ) ) ;
return resolver;
}
return null ;
}
@Override
public void addFormatters ( FormatterRegistry registry) {
ApplicationConversionService . addBeans ( registry, this . beanFactory) ;
}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
@Bean
@Override
public FormattingConversionService mvcConversionService ( ) {
Format format = this . mvcProperties. getFormat ( ) ;
WebConversionService conversionService = new WebConversionService ( new DateTimeFormatters ( )
. dateFormat ( format. getDate ( ) ) . timeFormat ( format. getTime ( ) ) . dateTimeFormat ( format. getDateTime ( ) ) ) ;
addFormatters ( conversionService) ;
return conversionService;
}
private Resource getWelcomePage ( ) {
for ( String location : this . resourceProperties. getStaticLocations ( ) ) {
Resource indexHtml = getIndexHtml ( location) ;
if ( indexHtml != null ) {
return indexHtml;
}
}
ServletContext servletContext = getServletContext ( ) ;
if ( servletContext != null ) {
return getIndexHtml ( new ServletContextResource ( servletContext, SERVLET_LOCATION ) ) ;
}
return null ;
}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
@Bean
@ConditionalOnMissingBean ( { RequestContextListener . class , RequestContextFilter . class } )
@ConditionalOnMissingFilterBean ( RequestContextFilter . class )
public static RequestContextFilter requestContextFilter ( ) {
return new OrderedRequestContextFilter ( ) ;
}
}
}
a、自动配置视图解析器ViewResolver （ContentNegotiatingViewResolver 和 BeanNameViewResolver ）, 作用：根据方法返回值得到视图对象，由视图对象决定请求转发或者重定向到指定视图。（注意：此处会创建获取容器中的所有视图解析器，包括自定义的视图解析器）
b、提供静态资源访问路径和webjars访问路径；
c、自动注册Converter 类型转换器, Formatter 格式化器；
d、提供HttpMessageConverters ，用于Http 请求和响应之间的转换，将json或者xml格式字符串和java类型之间做转换；
（注意：如果要自定义类型转换器，也可以通过该接口注册）
@Configuration ( proxyBeanMethods = false )
public class MyConfiguration {
@Bean
public HttpMessageConverters customConverters ( ) {
HttpMessageConverter < ? > = . . .
HttpMessageConverter < ? > = . . .
return new HttpMessageConverters ( additional, another) ;
}
}
内容了解~
e、自动注册消息代码提示处理器MessageCodesResolver
f、支持静态首页index. html访问
g、自动注册web数据参数绑定对象ConfigurableWebBindingInitializer ，如果我们自己注册了该类型对象，那springboot会自动调用我们注册的对象，替换默认对象将请求参数绑定到javabean（了解）。
h、如果要自定义拦截器interceptors，格式化器formatters，视图控制器view controllers等，可以通过创建类型为WebMvcConfigurer 的配置类来实现，不要加注解@EnableWebMvc 。
i、如果要自定义处理器映射器RequestMappingHandlerMapping , 处理器适配器RequestMappingHandlerAdapter , 或者异常处理器ExceptionHandlerExceptionResolver ，可以在容器中创建类型为WebMvcRegistrations 的组件对象来实现。
j、如果想要完全使用自定义配置，不使用springboot默认配置，可以在配置类上加注解@EnableWebMvc 。（不推荐）
参考官方文档：https: / / docs. spring. io/ spring- boot/ docs/ 2.4 .3 / reference/ html/ spring- boot- features. html#boot- features- spring- mvc
a、SpringBoot启动会加载大量的自动配置类
b、根据配置文件和xxxProperties的默认设置初始化自动配置类中的组件
c、可以在自动配置类中查看我们需要的功能是否已经自动配置，如果配置，我们就不用再做配置了；
public class MyIntercepter implements HandlerInterceptor {
@Override
public boolean preHandle ( HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
HttpSession session = request. getSession ( ) ;
String username= ( String ) session. getAttribute ( "username" ) ;
if ( username!= null ) {
System . out. println ( "登录成功不拦截" ) ;
return true ;
} else {
request. getRequestDispatcher ( "/index.html" ) . forward ( request, response) ;
System . out. println ( "未登录拦截" ) ;
return false ;
}
}
@Override
public void postHandle ( HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
}
@Override
public void afterCompletion ( HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
}
}
@Configuration
public class MyConfig implements WebMvcConfigurer {
@Override
public void addInterceptors ( InterceptorRegistry registry) {
registry. addInterceptor ( new MyIntercepter ( ) ) . addPathPatterns ( "/**" ) . excludePathPatterns ( "/" , "/index.html" , "/user/login" ) ;
}
}
< dependency> < groupId> . springframework. boot< / groupId>
< artifactId> - boot- starter- thymeleaf< / artifactId>
< / dependency>
@Configuration
public class MyConfig implements WebMvcConfigurer {
@Override
public void addInterceptors ( InterceptorRegistry registry) {
registry. addInterceptor ( new MyIntercepter ( ) ) . addPathPatterns ( "/**" ) . excludePathPatterns ( "/" , "/index.html" , "/user/login" ) ;
}
@Override
public void addViewControllers ( ViewControllerRegistry registry) {
registry. addViewController ( "/main" ) . setViewName ( "main" ) ;
}
}
thymeleaf是一款用于渲染XML / XHTML / HTML5 内容的模板引擎。类似JSP ， Velocity ，FreeMaker 等，它也可以轻易的与Spring MVC 等Web 框架进行集成作为Web 应用的模板引擎。与其它模板引擎相比，Thymeleaf 最大的特点是能够
直接在浏览器中打开并正确显示模板页面，而不需要启动整个Web 应用
Spring Boot 推荐使用Thymeleaf 、Freemarker 等后现代的模板引擎技术；一但导入相
关依赖，会自动配置ThymeleafAutoConfiguration 、FreeMarkerAutoConfiguration 。
模板引擎工作原理图：
< dependency> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> </ dependency> spring :
thymeleaf :
cache : false
package com. offcn. demo. controller ;
@Controller
public class FirstThymeleafController {
@GetMapping ( "/first" )
public String indexPage ( Model model) {
String message = "Hello, Thymeleaf!" ;
model. addAttribute ( "message" , message) ;
return "index" ;
}
}
在resources/ templates 下新建 index. html
<! doctype html > < htmlxmlns: th= " http://www.thymeleaf.org" > < head> < metacharset = " UTF-8" > < title> </ title> </ head> < body> < h1th: text= " ${message}" > </ h1> </ body> </ html>
package com.offcn.demo.bean;
public class User {
private Integer id;
private String name;
private int age;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package com. offcn. demo. controller ;
import java. util. HashMap ;
import java. util. Map ;
import org. springframework. stereotype. Controller ;
import org. springframework. ui. Model ;
import org. springframework. web. bind. annotation. GetMapping ;
import com. offcn. demo. bean. User ;
@Controller
public class SecondThymeleafController {
@GetMapping ( "/second" )
public String indexPage ( Model model) {
String message = "Hello, Thymeleaf!" ;
User u = new User ( ) ;
u. setId ( 1 ) ;
u. setName ( "优就业" ) ;
u. setAge ( 18 ) ;
Map < String , Object > = new HashMap < > ( ) ;
map. put ( "src1" , "1.jpg" ) ;
map. put ( "src2" , "2.jpg" ) ;
model. addAttribute ( "message" , message) ;
model. addAttribute ( "user" , u) ;
model. addAttribute ( "src" , map) ;
return "index2" ;
}
}
<! doctype html > < htmlxmlns = " http://www.w3.org/1999/xhtml" xmlns: th= " http://www.thymeleaf.org" > < head> < metacharset = " UTF-8" > < title> </ title> </ head> < body> < h1th: text= " ${message}" > </ h1> < imgth: src= " ${src.src1}" /> </ br> < imgth: src= " ${src.src2}" /> </ br> < spanth: text= " ${user.id}" > </ span> < spanth: text= " ${user.name}" > </ span> < spanth: text= " ${user.age}" > </ span> </ body> </ html>
package com. offcn. demo. controller ;
@Controller
public class ThreeThymeleafController {
@GetMapping ( "/three" )
public String indexPage ( Model model) {
List < User > = new ArrayList < User > ( ) ;
User u1 = new User ( ) ;
u1. setId ( 1 ) ;
u1. setName ( "优就业" ) ;
u1. setAge ( 18 ) ;
list. add ( u1) ;
User u2 = new User ( ) ;
u2. setId ( 2 ) ;
u2. setName ( "中公教育" ) ;
u2. setAge ( 28 ) ;
list. add ( u2) ;
User u3 = new User ( ) ;
u3. setId ( 3 ) ;
u3. setName ( "IT先锋" ) ;
u3. setAge ( 88 ) ;
list. add ( u3) ;
User u4 = new User ( ) ;
u4. setId ( 4 ) ;
u4. setName ( "JAVA第一" ) ;
u4. setAge ( 888 ) ;
list. add ( u4) ;
model. addAttribute ( "userList" , list) ;
return "index3" ;
}
}
<! doctype html > < htmlxmlns = " http://www.w3.org/1999/xhtml" xmlns: th= " http://www.thymeleaf.org" > < head> < metacharset = " UTF-8" > < title> </ title> </ head> < body> < tablewidth = " 200" style = " text-align : center; " > < tr> < th> </ th> < th> </ th> < th> </ th> < th> </ th> </ tr> < trth: each= " user,iterStat : ${userList}" > < tdth: text= " ${user.id}" > </ td> < tdth: text= " ${user.name}" > </ td> < tdth: text= " ${user.age}" > </ td> < tdth: text= " ${iterStat.index}" > </ td> </ tr> </ table> </ body> </ html> iterStat 称作状态变量，属性有：
index：当前迭代对象的 index（从 0 开始计算）
count：当前迭代对象的 index（从 1 开始计算）
size：被迭代对象的大小
current：当前迭代变量
even/ odd：布尔值，当前循环是否是偶数/ 奇数（从 0 开始计算）
first：布尔值，当前循环是否是第一个
last：布尔值，当前循环是否是最后一个
package com. offcn. demo. controller ;
@Controller
public class FourThymeleafController {
@GetMapping ( "/four" )
public String indexPage ( Model model) {
model. addAttribute ( "userName" , "优就业" ) ;
model. addAttribute ( "href" , "http://www.ujiuye.com" ) ;
return "index4" ;
}
}
<! doctype html > < htmlxmlns = " http://www.w3.org/1999/xhtml" xmlns: th= " http://www.thymeleaf.org" > < head> < metacharset = " UTF-8" > < title> </ title> </ head> < body> < h1th: text= " ${userName}" > </ h1> < inputtype = " text" name = " names" th: value= " ${userName}" /> </ br> < emth: size= " ${userName}" > </ em> < spanth: text= " ' 欢迎来:'+${userName}+'学习!'" > </ span> </ br> < spanth: text= " |欢迎来:${userName}学习!|" > </ span> </ body> </ html>
package com. offcn. demo. controller ;
@Controller
public class FiveThymeleafController {
@GetMapping ( "/five" )
public String indexPage ( Model model) {
model. addAttribute ( "flag" , "yes" ) ;
model. addAttribute ( "menu" , "admin" ) ;
model. addAttribute ( "manager" , "manager" ) ;
return "index5" ;
}
}
<! doctype html > < htmlxmlns = " http://www.w3.org/1999/xhtml" xmlns: th= " http://www.thymeleaf.org" > < head> < metacharset = " UTF-8" > < title> </ title> </ head> < body> < h1th: if= " ${flag=='yes'}" > </ h1> < h1th: unless= " ${flag=='no'}" > </ h1> < divth: switch= " ${menu}" > < pth: case= " ' admin'" > </ p> < pth: case= " ${manager}" > </ p> </ div> </ body> </ html>
thymeleaf也提供了类似import 的东西，可以将很多代码块抽象成模块，然后在需要的时候引用，非常方便。
fragment介绍
fragment类似于JSP 的tag，在html中文件中，可以将多个地方出现的元素块用fragment包起来使用。
fragment使用
定义fragment, 所有的fragment可以写在一个文件里面，也可以单独存在，例如：
7.8.1 新增模板文件 footer.html
< body> < h1th: fragment= " copy" > © 1999-2022 Offcn.All Rights Reserved
</ h1> </ body> 注意： 在Springboot 中，默认读取thymeleaf文件的路径是：src/ main/ resource/ templates
package com. offcn. demo. controller ;
@Controller
public class SixThymeleafController {
@GetMapping ( "/six" )
public String indexPage ( Model model) {
return "index6" ;
}
}
<! doctype html > < htmlxmlns = " http://www.w3.org/1999/xhtml" xmlns: th= " http://www.thymeleaf.org" > < head> < metacharset = " UTF-8" > < title> </ title> </ head> < body> < divstyle = " color : #82ff6c" th: insert= " ~{footer :: copy}" > </ div> </ br> < divstyle = " color : #82ff6c" th: replace= " ~{footer :: copy}" > </ div> </ br> < divstyle = " color : #82ff6c" th: include= " ~{footer :: copy}" > </ div> </ body> </ html> fragment的引用
th: insert: 保留自己的主标签，保留th: fragment的主标签。
th: replace: 不要自己的主标签，保留th: fragment的主标签。
th: include: 保留自己的主标签，不要th: fragment的主标签。（官方3.0 后不推荐）
#dates 与java. util. Datejava. lang. Stringpackage com. offcn. demo. controller ;
@Controller
public class SevenThymeleafController {
@GetMapping ( "/seven" )
public String indexPage ( Model model) {
Date date = new Date ( ) ;
model. addAttribute ( "date" , date) ;
double price= 128.5678D ;
model. addAttribute ( "price" , price) ;
String str= "Thymeleaf是Web和独立环境的现代服务器端Java模板引擎，能够处理HTML，XML，JavaScript，CSS甚至纯文本。\r\n" +
"Thymeleaf的主要目标是提供一种优雅和高度可维护的创建模板的方式。为了实现这一点，它建立在自然模板的概念上，将其逻辑注入到模板文件中，不会影响模板被用作设计原型。这改善了设计的沟通，弥补了设计和开发团队之间的差距。\r\n" +
"Thymeleaf也从一开始就设计了Web标准 - 特别是HTML5 - 允许您创建完全验证的模板，如果这是您需要的\r\n" ;
model. addAttribute ( "strText" , str) ;
String str2= "JAVA-offcn" ;
model. addAttribute ( "str2" , str2) ;
return "index7" ;
}
}
<! doctype html > < htmlxmlns = " http://www.w3.org/1999/xhtml" xmlns: th= " http://www.thymeleaf.org" > < head> < metacharset = " UTF-8" > < title> </ title> </ head> < body> < spanth: text= " ${#dates.format(date,'yyyy-MM-dd HH:mm:ss')}" > </ span> </ br> < spanth: text= " ' ￥'+${#numbers.formatDecimal(price, 1, 2)}" > </ span> </ br> < pth: text= " ${#strings.abbreviate(strText,60)}" > </ p> < spanth: if= " ${!#strings.isEmpty(str2)}" > </ span> </ br> < spanth: text= " ${#strings.substring(str2,0,4)}" > </ span> </ body> </ html>
Spring Boot 2.2 .0 版本开始引入 JUnit 5 作为单元测试默认库
作为最新版本的JUnit 框架，JUnit5 与之前版本的Junit 框架有很大的不同。由三个不同子项目的几个不同模块组成。
JUnit 5 = JUnit Platform + JUnit Jupiter + JUnit Vintage
JUnit Platform : Junit Platform 是在JVM 上启动测试框架的基础，不仅支持Junit 自制的测试引擎，其他测试引擎也都可以接入。
JUnit Jupiter : JUnit Jupiter 提供了JUnit5 的新的编程模型，是JUnit5 新特性的核心。内部 包含了一个测试引擎，用于在Junit Platform 上运行。
JUnit Vintage : 由于JUint 已经发展多年，为了照顾老的项目，JUnit Vintage 提供了兼容JUnit4 . x, Junit3 . x的测试引擎。
< dependency> < groupId> </ groupId> < artifactId> </ artifactId> < scope> </ scope> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> < scope> </ scope> < exclusions> < exclusion> < groupId> </ groupId> < artifactId> </ artifactId> </ exclusion> </ exclusions> </ dependency> import org. junit. jupiter. api. Test ;
import org. springframework. boot. test. context. SpringBootTest ;
class TestThymeleafApplicationTests {
@Test
void contextLoads ( ) {
}
}
@SpringBootTest springboot整合junit5 的注解。
@SpringBootTest
class TestThymeleafApplicationTests {
@Autowired
private ApplicationContext applicationContext;
@Test
void contextLoads ( ) {
System . out. println ( applicationContext) ;
}
}
< dependency> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> </ dependency> CREATE TABLE ` account` (
` id` int ( 11 ) NOT NULL AUTO_INCREMENT ,
` name` varchar ( 255 ) DEFAULT NULL ,
` money` double ( 10 , 2 ) DEFAULT NULL ,
PRIMARY KEY ( ` id` )
) ENGINE = InnoDB AUTO_INCREMENT = 1005 DEFAULT CHARSET = utf8
public class Account implements Serializable {
private Integer id;
private String name;
private double money;
public Integer getId ( ) {
return id;
}
public void setId ( Integer id) {
this . id = id;
}
public String getName ( ) {
return name;
}
public void setName ( String name) {
this . name = name;
}
public double getMoney ( ) {
return money;
}
public void setMoney ( double money) {
this . money = money;
}
}
@Mapper springboot就能够帮助创建接口的代理类对象。
public interface AccountMapper {
Account findById ( Integer id) ;
}
<?xml version="1.0" encoding="UTF-8" ?>
<! DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd" > < mappernamespace = " com.offcn.AccountMapper" > < selectid = " findById" resultType = " com.offcn.pojo.Account" > </ select> </ mapper> spring :
datasource :
url : jdbc: mysql: //localhost: 3306/test
username : root
password : root
driver-class-name : com.mysql.jdbc.Driver
mybatis :
mapper-locations : classpath: mybatis/mapper/*.xml
type-aliases-package : com.offcn.pojo
configuration :
map-underscore-to-camel-case : true
总结：
boot整合mybatis ， mapper映射文件的地址必须要指定~ ，其他都是可选择~
public interface AccountService {
Account findByIdService ( Integer id) ;
}
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountMapper accountMapper;
@Override
public Account findByIdService(Integer id) {
return accountMapper.findById(id);
}
}
@Controller
@RequestMapping ( "account" )
public class AccountController {
@Autowired
private AccountService accountService;
@GetMapping ( "findById" )
@ResponseBody
public Account findById ( Integer id) {
return accountService. findByIdService ( id) ;
}
}
访问地址： http: / / localhost: 8080 / account/ findById? id= 1001
测试结果：
spring- data- redis针对jedis提供了如下功能：
1. 连接池自动管理，提供了一个高度封装的“RedisTemplate ”类
2. 针对jedis客户端中大量api进行了归类封装, 将同一类型操作封装为operation接口
ValueOperations ：简单K - V 操作
SetOperations ：set类型数据操作
ZSetOperations ：zset类型数据操作
HashOperations ：针对map类型的数据操作
ListOperations ：针对list类型的数据操作
或者是pom. xml文件当中引入启动器依赖
< dependency> < groupId> </ groupId> < artifactId> </ artifactId> </ dependency> spring :
redis :
host : 192.168.126.10
port : 6379
package com. offcn ;
import org. junit. jupiter. api. Test ;
import org. springframework. beans. factory. annotation. Autowired ;
import org. springframework. boot. test. context. SpringBootTest ;
import org. springframework. data. redis. core. RedisTemplate ;
@SpringBootTest
public class BootRedisDemoApplicationTests {
@Autowired
private RedisTemplate < String , String > ;
@Test
void test1 ( ) {
ValueOperations < String , String > = redisTemplate. opsForValue ( ) ;
ops. set ( "username" , "jack" ) ;
String username = ops. get ( "username" ) ;
System . out. println ( username) ;
redisTemplate. delete ( "username" ) ;
}
}
package com. offcn ;
import org. junit. jupiter. api. Test ;
import org. springframework. beans. factory. annotation. Autowired ;
import org. springframework. boot. test. context. SpringBootTest ;
import org. springframework. data. redis. core. RedisTemplate ;
import java. util. Set ;
@SpringBootTest
public class BootRedisDemoApplicationTests {
@Autowired
private RedisTemplate < String , String > ;
@Test
void test2 ( ) {
SetOperations < String , String > = redisTemplate. opsForSet ( ) ;
ops. add ( "set" , "jack" , "marray" , "george" ) ;
Set < String > = ops. members ( "set" ) ;
System . out. println ( set) ;
ops. remove ( "set" , "jack" ) ;
redisTemplate. delete ( "set" ) ;
}
}
@Test
void test3 ( ) {
ListOperations < String , String > = redisTemplate. opsForList ( ) ;
ops. rightPush ( "myList" , "a" ) ;
ops. rightPush ( "myList" , "b" ) ;
ops. rightPush ( "myList" , "c" ) ;
List < String > = ops. range ( "myList" , 0 , - 1 ) ;
System . out. println ( myList) ;
}
@Test
void test4 ( ) {
ListOperations < String , String > = redisTemplate. opsForList ( ) ;
ops. leftPush ( "myList" , "A" ) ;
ops. leftPush ( "myList" , "B" ) ;
ops. leftPush ( "myList" , "C" ) ;
List < String > = ops. range ( "myList" , 0 , - 1 ) ;
System . out. println ( myList) ;
}
@Test
void test5 ( ) {
ListOperations < String , String > = redisTemplate. opsForList ( ) ;
String value = ops. index ( "myList" , 1 ) ;
System . out. println ( value) ;
}
@Test
void test6 ( ) {
ListOperations < String , String > = redisTemplate. opsForList ( ) ;
ops. remove ( "myList" , 1 , "A" ) ;
List < String > = ops. range ( "myList" , 0 , - 1 ) ;
System . out. println ( myList) ;
}
@Test
void test7 ( ) {
HashOperations < String , Object , Object > = redisTemplate. opsForHash ( ) ;
ops. put ( "user" , "username" , "mrzhang" ) ;
ops. put ( "user" , "address" , "beijing" ) ;
ops. put ( "user" , "age" , "18" ) ;
}
@Test
void test8 ( ) {
HashOperations < String , Object , Object > = redisTemplate. opsForHash ( ) ;
Set < Object > = ops. keys ( "user" ) ;
System . out. println ( user) ;
}
@Test
void test9 ( ) {
HashOperations < String , Object , Object > = redisTemplate. opsForHash ( ) ;
List < Object > = ops. values ( "user" ) ;
System . out. println ( user) ;
}
@Test
void test10 ( ) {
HashOperations < String , Object , Object > = redisTemplate. opsForHash ( ) ;
String o = ( String ) ops. get ( "user" , "username" ) ;
System . out. println ( o) ;
}
@Test
void test11 ( ) {
HashOperations < String , Object , Object > = redisTemplate. opsForHash ( ) ;
ops. delete ( "user" , "username" ) ;
}
RedisTemplate 操作时，默认会采用jdkSerializable序列化机制，使得插入的值在redis客户端看来会有乱码，若想解决这一问题，需要手动指定序列化方式。
public class RedisTemplate < K , V > extends RedisAccessor implements RedisOperations < K , V > , BeanClassLoaderAware {
public void afterPropertiesSet ( ) {
super . afterPropertiesSet ( ) ;
boolean defaultUsed = false ;
if ( this . defaultSerializer == null ) {
this . defaultSerializer = new JdkSerializationRedisSerializer ( this . classLoader != null ? this . classLoader : this . getClass ( ) . getClassLoader ( ) ) ;
}
. . .
}
默认序列化器： JdkSerializationRedisSerializer 存对象的时候， 将对象转换成二进制信息存值。
public class Account implements Serializable {
private Integer id;
private String name;
private double money;
public Integer getId ( ) {
return id;
}
public void setId ( Integer id) {
this . id = id;
}
public String getName ( ) {
return name;
}
public void setName ( String name) {
this . name = name;
}
public double getMoney ( ) {
return money;
}
public void setMoney ( double money) {
this . money = money;
}
@Override
public String toString ( ) {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", money=" + money +
'}' ;
}
}
@Configuration
public class RedisConfigurer {
@Bean
public RedisTemplate < String , Account > redisTemplate ( RedisConnectionFactory redisConnectionFactory) {
RedisTemplate < String , Account > = new RedisTemplate ( ) ;
template. setConnectionFactory ( redisConnectionFactory) ;
Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer ( Account . class ) ;
template. setDefaultSerializer ( serializer) ;
return template;
}
}
使用Jackson2JsonRedisSerializer ，需要引入jackson的依赖
如果使用了自定义容器，原有的RedisTemplate 使用将受影响，需要将这个@Bean 上添加一个bean的名字，在使用注入时使用这个名字
@Bean ( "accountTemplate" )
@Resource ( "accountTemplate" )
RedisTemplate redisTemplate;
@SpringBootTest
public class RedisDemo02ApplicationTests {
@Autowired
private RedisTemplate < String , Account > ;
@Test
public void serializableAccount ( ) {
Account account = new Account ( ) ;
account. setId ( 1001 ) ;
account. setName ( "张三丰" ) ;
account. setId ( 98765 ) ;
redisTemplate. opsForValue ( ) . set ( "account" , account) ;
System . out. println ( "序列化成功" ) ;
}
}
注意： 启动dubbo- admin ，方便服务的查询~
< dependencies> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> < type> </ type> < exclusions> < exclusion> < groupId> </ groupId> < artifactId> </ artifactId> </ exclusion> </ exclusions> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> </ dependency> </ dependencies>
public interface OrderService {
public Order loadOrdersService ( Integer id) ;
public List < Order > loadOrdersListService ( ) ;
}
@Component
@Service
public class OrderServiceImpl implements OrderService {
@Override
public Order loadOrdersService ( Integer id) {
Order o= new Order ( ) ;
o. setId ( id) ;
o. setRemark ( "备注...." ) ;
o. setTotal ( 123 ) ;
return o;
}
@Override
public List < Order > loadOrdersListService ( ) {
Order o= new Order ( ) ;
o. setId ( 1001 ) ;
o. setRemark ( "新疆大盘鸡一份" ) ;
o. setTotal ( 12 ) ;
Order o1= new Order ( ) ;
o1. setId ( 1002 ) ;
o1. setRemark ( "东北杀猪菜一份" ) ;
o1. setTotal ( 123 ) ;
List < Order > = new ArrayList < Order > ( ) ;
results. add ( o) ;
results. add ( o1) ;
return results;
}
}
server:
port: 8088
spring:
application:
name: sb8
#dubbo端口和名称
dubbo:
protocol:
name: dubbo
port: 20880
registry:
address: zookeeper://192.168.1.151:2181
timeout: 60000
scan:
base-packages: com.offcn.service.impl
@SpringBootApplication
public class DemoProvederApplication {
public static void main ( String [ ] args) {
SpringApplication . run ( DemoProvederApplication . class , args) ;
}
}
创建boot工程， 引入相关依赖
< dependencies> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> < type> </ type> < exclusions> < exclusion> < groupId> </ groupId> < artifactId> </ artifactId> </ exclusion> </ exclusions> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> </ dependency> </ dependencies> public interface OrderService {
public Order loadOrdersService ( Integer id) ;
public List < Order > loadOrdersListService ( ) ;
}
@Controller
public class OrderController {
@Reference
private OrderService orderService;
@RequestMapping ( "findById" )
@ResponseBody
public Order findById ( Integer id) {
Order order = orderService. loadOrdersService ( id) ;
return order;
}
@RequestMapping ( "findAll" )
@ResponseBody
public List < Order > findAll ( Integer id) {
return orderService. loadOrdersListService ( ) ;
}
}
server:
port: 9000
servlet:
context-path: /
dubbo:
protocol:
name: dubbo
port: 20881
registry:
address: zookeeper://192.168.1.151:2181
timeout: 60000
@SpringBootApplication
public class DemoProvederApplication {
public static void main ( String [ ] args) {
SpringApplication . run ( DemoProvederApplication . class , args) ;
}
}
4941
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
