SpringBoot笔记
SpringBoot官方文档
一、SpringBoot的常用注解
@ConfigurationProperties、@PropertySource、@ImportResource的区别
1.@ConfigurationProperties:
@ConfigurationProperties:告诉SpringBoot将本类中的所有属性与配置文件中的相关属性进行绑定;
如：@ConfigurationProperties(prefix = "person") 就是将配置文件中前缀为person下边的属性与该注解所在类中的属性进行绑定
2.@PropertySource:
@PropertySource:加载指定的配置文件
如：@PropertySource("classpath:person.properties")
3.@ImportResource:
@ImportResource:导入Spring的配置文件xxx.xml，让配置文件中的内容生效;
如:@ImportResource(location={"classpath:bean.xml"})（作用在启动类上）
4.@Configuration:
@Configuration：指明当前类是一个配置类；用来代替之前的Spring配置文件.xml
二、Profile多环境支持
1.多文件
约定文件名：application-{profile}.properties 使用spring-profiles.active={profile}激活对应的环境
application-dev.properties
application-prod.properties
2.yml多文档块
server:
port: 8080
spring:
profiles:
active: prod
---
server:
port: 8081
spring:
profiles: dev
---
server:
port: 8082
spring:
profiles: prod
三、配置文件加载位置
SpringBoot启动会扫描一下位置的application.properties或application.yml文件作为SpringBoot的默认配置文件。
file:./config/
file:./
classpath:/config/
classpath:/
优先级由高到低，高优先级的配置会覆盖低优先级的配置；SpringBoot会从这四个位置全部加载主配置文件，故会形成一个互补配置。
四、外部配置加载顺序
1.命令行参数
如：java -jar xxx.jar --server.port=8087
由jar包外向jar包内
优先加载带profile的
2.jar包外部的application-{profile}.properties或application.ym|(带spring.profile)配置文件
3.jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件
再来加载不带profile的
4.jar包外部的application.properties或application.yml(不带spring.profile)配置文件
5.jar包内部的application.properties或application.yml(不带spring.profile)配置文件
五、自动配置原理（面试必问题）
application.properties配置文件参考
@EnableAutoConfiguration
->@Import({AutoConfigurationImportSelector.class})
->getCandidateConfigurations(annotationMetadata, attributes);
->SpringFactoriesLoader.loadFactoryNames();
->classLoader.getResources(“META-INF/spring.factories”)
①配置原理：
1.SpringBoot启动时加载主配置类，开启了自动配置功能 @EnableAutoConfiguration
2.@EnableAutoConfiguration的作用：
●利用@EnableAutoConfigurationImportSelector给容器中导入一些组件？
●List configurations = this.getCandidateConfigurations(annotationMetadata, attributes);获取候选的配置
●SpringFactoriesLoader.loadFactoryNames()扫描所有jar包类路径下 META-INF/spring.factoryies，把扫描到的这些文件的内容包装成properties对象，从properties中获取到EnableAutoConfiguration.class类（类名）对应的值，然后把它们添加在容器中
将类路径下 META-INF/spring.factories里面配置的所有EnableAutoConfiguration的值加入到了容器中；
每一个xxxAutoConfiguration类都是容器中的一个组件，都加入到容器中；用他们来做自动配置
3.每一个配置类进行自动配置功能
4.以HttpEncodingAutoConfiguration为例解释自动配置原理：
@Configuration
@EnableConfigurationProperties({ServerProperties.class})//启动指定类的ConfigurationProperties功能；将配置文件中对应的值和HttpEncodingProperties绑定起来；并把这个类加入到ioc容器中
@ConditionalOnWebApplication//Spring底层@Conditional注解，根据不同的条件，如果满足指定的条件，整个配置类中的配置就会生效 判断当前类是不是Web应用，如果是则生效；
@ConditionalOnClass({CharacterEncodingFilter.class})//判断当前项目有没有这个类
@ConditionalOnProperty(
prefix = "server.servlet.encoding",
value = {"enabled"},
matchIfMissing = true
)//判断配置文件中是否存在某个配置 如：server.servlet.encoding.enable ； 如果不存在，判断也是成立的
public class HttpEncodingAutoConfiguration {
private final Encoding properties;//
//只有一个有参构造方法的情况下，参数的值就会从容器中拿
public HttpEncodingAutoConfiguration(ServerProperties properties) {
this.properties = properties.getServlet().getEncoding();
}
@Bean//给容器中添加一个组件，这个组件的某些值需要从properties中获取
@ConditionalOnMissingBean//判断容器中没有这个组件才会加入该组件
public CharacterEncodingFilter characterEncodingFilter() {
CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
filter.setEncoding(this.properties.getCharset().name());
filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.web.servlet.server.Encoding.Type.REQUEST));
filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.web.servlet.server.Encoding.Type.RESPONSE));
return filter;
}
一但这个自动配置类生效，这个配置类就会给容器中添加组件，这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的；
精髓：
1)、SpringBoot启动会加载大量的自动配置类
2）、看我们需要的功能有没有SpringBoot默认写好的自动配置类
3）、我们再来看这个自动配置类中到底配置了那些组件；
4）、给容器中自动配置类添加组件的时候，会从properties类中获取某些属性。我们就可在配置文件中指定这些属性的值；
xxxAutoConfiguration自动配置类
给容器中添加组件
xxxProperties封装配置文件中相关属性
②细节：
@Conditional派生注解
作用：必须是@Conditional指定的条件成立，才给容器中添加组件，配置里面的内容才生效。
| @Conditional扩展注解 | 作用（判断是否满足当前指定条件） |
|---|---|
| @ConditionalOnJava | 系统的java版本是否符合要求 |
| @ConditionalOnBean | 容器中存在指定的Bean |
| @ConditionalOnMissingBean | 容器中不存在指定的Bean |
| @ConditionalOnExpression | 满足SpEL表达式指定 |
| @ConditionalOnClass | 系统中有指定的类 |
| @ConditionalOnMissingClass | 系统中没有指定的类 |
| @ConditionalOnSingleCandidate | 容器中只有一个指定的Bean，或者这个Bean是首选Bean |
| @ConditionalOnProperty | 系统中指定的属性是否有指定的值 |
| @ConditionalOnResource | 类路径下是否存在指定资源文件 |
| @ConditionalOnWebApplication | 当前是Web环境 |
| @ConditionalOnNotWebApplication | 当前不是Web环境 |
| @ConditionalOnJndi | JNDI存在指定项 |
自动配置类必须在一定条件下才能生效
故该怎么知道哪些自动配置类是否生效？
只需在配置文件中开启debug=true 来让控制台打印自动配置报告
六、Spring Boot与日志
1.市面上常用的日志框架：
JUL、JCL、Jboss-logging、logback、log4j、log4j2、slf4j…
| 日志门面（日志的抽象层） | 日志实现 |
|---|---|
SLF4j(Simple Logging Facade for Java) Jboss-logging | log4j JUL (java.util.logging) log4j2 Logback |
左边选个日志门面、右边选一个来实现；
日志门面：SLF4J;
日志实现：Logback;
SpringBoot:底层是Spring框架，Spring框架默认使用JCL；
SpringBoot选用SLF4j和Logback;
2.SLF4j使用
1> 如何在系统中使用SLF4J
以后开发的时候,日记方法的调用，不应该来直接调用日志的实现类，而是调用日志抽象层里面的方法；
给系统里面导入slf4j的jar和logback的实现；
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class HelloWorld {
public static void main(String[] args) {
Logger logger = LoggerFactory.getLogger(HelloWorld.class);
logger.info("Hello World");
}
}
每一个日志的实现框架都有自己的配置文件，使用slf4j后，配置文件还是使用日志实现框架自己本身的配置文件
2 >遗留问题
SpringBoot使用的是slf4j+logback，但其他框架本身也可能在使用别的日志框架，如Spring(commons-logging)、Hibernate(jboss-logging)、Mybatis…故需要统一使用slf4j进行输出
3.SpringBoot日志间的关系
如何让系统中的日志都统一到slf4j:
1.将系统的中其他日志框架先排出去
2.用中间包来替换原有的日志框架
3.再导入slf4j其他的实现
总结：
1）、SpringBoot底层也是使用slf4j+logback的方式进行日志记录
2）、SpringBoot把其他的日志都替换成了slf4j
3）、中间替换包（log4j-to-slf4j、jul-to-slf4j）
一句话：SpringBoot能适应所有的日志，而且底层使用slf4j的方式记录日志，引入其他框架的时候，只需要把这个框架依赖的日志框架排除掉。
4.日志使用
1.默认配置
//记录器
Logger logger = LoggerFactory.getLogger(getClass());
@Test
void contextLoads() {
//日志的级别: trace<debug<info<warn<error 由低到高，低于当前级别的则不显示，默认为info级别，可自定义在配置文件中指定级别
logger.trace("这是trace日志");
logger.debug("这是debug日志");
logger.info("这是info日志");
logger.warn("这是warn日志");
logger.error("这是error日志");
}
2.日志输出格式：
%d表示时间、
%thread表示线程名、
%-5level表示级别从左显示5个字符宽度、
%logger{50}表示logger名字最长50个字符，否则按照句点分割
%msg日志消息、
%n 换行
如:%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} -%msg%n
SpringBoot修改日志配置：
#指定级别 （可具体到哪个包）
logging.level.com=trace
#不指定路径则在当前项目下生成日志文件，也可以指定路径
logging.file=
#在当前磁盘的根路径下创建spring文件夹和里面的log文件夹；使用spring.log作为默认文件
logging.file.path=/spring/log
#在控制台输出的日志格式
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} -%msg%n
#指定文件中输出的日志格式
logging.pattern.file=
3.logback.xml配置样例
<?xml version="1.0" encoding="UTF-8"?>
<!--
scan：当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。
scanPeriod：设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒当scan为true时，此属性生效。默认的时间间隔为1分钟。
debug：当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。
-->
<configuration scan="false" scanPeriod="60 seconds" debug="false">
<!-- 定义日志的根目录 -->
<property name="LOG_HOME" value="/app/log" />
<!-- 定义日志文件名称 -->
<property name="appName" value="atguigu-springboot"></property>
<!-- ch.qos.logback.core.ConsoleAppender 表示控制台输出 -->
<appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
<!--
日志输出格式：
%d表示日期时间，
%thread表示线程名，
%-5level：级别从左显示5个字符宽度
%logger{50} 表示logger名字最长50个字符，否则按照句点分割。
%msg：日志消息，
%n是换行符
-->
<layout class="ch.qos.logback.classic.PatternLayout">
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
</layout>
</appender>
<!-- 滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件 -->
<appender name="appLogAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">
<!-- 指定日志文件的名称 -->
<file>${LOG_HOME}/${appName}.log</file>
<!--
当发生滚动时，决定 RollingFileAppender 的行为，涉及文件移动和重命名
TimeBasedRollingPolicy： 最常用的滚动策略，它根据时间来制定滚动策略，既负责滚动也负责出发滚动。
-->
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!--
滚动时产生的文件的存放位置及文件名称 %d{yyyy-MM-dd}：按天进行日志滚动
%i：当文件大小超过maxFileSize时，按照i进行文件滚动
-->
<fileNamePattern>${LOG_HOME}/${appName}-%d{yyyy-MM-dd}-%i.log</fileNamePattern>
<!--
可选节点，控制保留的归档文件的最大数量，超出数量就删除旧文件。假设设置每天滚动，
且maxHistory是365，则只保存最近365天的文件，删除之前的旧文件。注意，删除旧文件是，
那些为了归档而创建的目录也会被删除。
-->
<MaxHistory>365</MaxHistory>
<!--
当日志文件超过maxFileSize指定的大小是，根据上面提到的%i进行日志文件滚动 注意此处配置SizeBasedTriggeringPolicy是无法实现按文件大小进行滚动的，必须配置timeBasedFileNamingAndTriggeringPolicy
-->
<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<maxFileSize>100MB</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>
</rollingPolicy>
<!-- 日志输出格式： -->
<layout class="ch.qos.logback.classic.PatternLayout">
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [ %thread ] - [ %-5level ] [ %logger{50} : %line ] - %msg%n</pattern>
</layout>
</appender>
<!--
logger主要用于存放日志对象，也可以定义日志类型、级别
name：表示匹配的logger类型前缀，也就是包的前半部分
level：要记录的日志级别，包括 TRACE < DEBUG < INFO < WARN < ERROR
additivity：作用在于children-logger是否使用 rootLogger配置的appender进行输出，
false：表示只用当前logger的appender-ref，true：
表示当前logger的appender-ref和rootLogger的appender-ref都有效
-->
<!-- hibernate logger -->
<logger name="com.atguigu" level="debug" />
<!-- Spring framework logger -->
<logger name="org.springframework" level="debug" additivity="false"></logger>
<!--
root与logger是父子关系，没有特别定义则默认为root，任何一个类只会和一个logger对应，
要么是定义的logger，要么是root，判断的关键在于找到这个logger，然后判断这个logger的appender和level。
-->
<root level="info">
<appender-ref ref="stdout" />
<appender-ref ref="appLogAppender" />
</root>
</configuration>
log4j.properties配置样例
### set log levels ###
log4j.rootLogger = debug , stdout , D , E
### 输出到控制台 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = %d{ABSOLUTE} %5p %c{ 1 }:%L - %m%n
#### 输出到日志文件 ###
#log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
#log4j.appender.D.File = logs/log.log
#log4j.appender.D.Append = true
#log4j.appender.D.Threshold = DEBUG ## 输出DEBUG级别以上的日志
#log4j.appender.D.layout = org.apache.log4j.PatternLayout
#log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
#
#### 保存异常信息到单独文件 ###
#log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
#log4j.appender.D.File = logs/error.log ## 异常日志文件名
#log4j.appender.D.Append = true
#log4j.appender.D.Threshold = ERROR ## 只输出ERROR级别以上的日志!!!
#log4j.appender.D.layout = org.apache.log4j.PatternLayout
#log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
七.Web开发
1.SpringBoot对静态资源的映射规则
private final ResourceProperties resourceProperties;//设置和静态资源有关的参数，如缓存时间
public void addResourceHandlers(ResourceHandlerRegistry registry) {
if (!this.resourceProperties.isAddMappings()) {
logger.debug("Default resource handling disabled");
} else {
Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();
if (!registry.hasMappingForPattern("/webjars/**")) {
this.customizeResourceHandlerRegistration(registry.addResourceHandler(new String[]{"/webjars/**"}).addResourceLocations(new String[]{"classpath:/META-INF/resources/webjars/"}).setCachePeriod(this.getSeconds(cachePeriod)).setCacheControl(cacheControl));
}
String staticPathPattern = this.mvcProperties.getStaticPathPattern();
if (!registry.hasMappingForPattern(staticPathPattern)) {
this.customizeResourceHandlerRegistration(registry.addResourceHandler(new String[]{staticPathPattern}).addResourceLocations(WebMvcAutoConfiguration.getResourceLocations(this.resourceProperties.getStaticLocations())).setCachePeriod(this.getSeconds(cachePeriod)).setCacheControl(cacheControl));
}
}
}
//映射欢迎页
@Bean
public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext, FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(new TemplateAvailabilityProviders(applicationContext), applicationContext, this.getWelcomePage(), this.mvcProperties.getStaticPathPattern());
welcomePageHandlerMapping.setInterceptors(this.getInterceptors(mvcConversionService, mvcResourceUrlProvider));
welcomePageHandlerMapping.setCorsConfigurations(this.getCorsConfigurations());
return welcomePageHandlerMapping;
}
1) 所有/webjars/**,都去classpath:/META-INF/resources/webjars/找资源
webjars：以jar包的方式引入静态资源 （即在pom.xml文件中引入资源的依赖https://www.webjars.org/ 或https://mvnrepository.com/ ）
2）“/**”：访问当前项目所有资源（静态济源文件夹）
"classpath:/META-INF/resources/",
"classpath:/resources/",
"classpath:/static/",
"classpath:/public/"
"/" ：当前项目所有的根路径
3）欢迎页；静态资源文件夹下的所有index.html页面被"/**"映射。
4）所有的**/favicon.ico 都是在静态资源文件下找。
2.模板引擎
SpringBoot推荐Thmeleaf,功能强大，语法简单。
1）引入thymeleaf
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
2）Thymeleaf使用&语法
@ConfigurationProperties(
prefix = "spring.thymeleaf"
)
public class ThymeleafProperties {
private static final Charset DEFAULT_ENCODING;
public static final String DEFAULT_PREFIX = "classpath:/templates/";
public static final String DEFAULT_SUFFIX = ".html";
private boolean checkTemplate = true;
private boolean checkTemplateLocation = true;
private String prefix = "classpath:/templates/";
private String suffix = ".html";
...
}
1.表达式：
Simple expressions:（表达式语法）
Variable Expressions: ${...}：获取变量值；OGNL；
1）、获取对象的属性、调用方法
2）、使用内置的基本对象：
#ctx : the context object.
#vars: the context variables.
#locale : the context locale.
#request : (only in Web Contexts) the HttpServletRequest object.
#response : (only in Web Contexts) the HttpServletResponse object.
#session : (only in Web Contexts) the HttpSession object.
#servletContext : (only in Web Contexts) the ServletContext object.
${session.foo}
3）、内置的一些工具对象：
#execInfo : information about the template being processed.
#messages : methods for obtaining externalized messages inside variables expressions, in the same way as they would be obtained using #{…} syntax.
#uris : methods for escaping parts of URLs/URIs
#conversions : methods for executing the configured conversion service (if any).
#dates : methods for java.util.Date objects: formatting, component extraction, etc.
#calendars : analogous to #dates , but for java.util.Calendar objects.
#numbers : methods for formatting numeric objects.
#strings : methods for String objects: contains, startsWith, prepending/appending, etc.
#objects : methods for objects in general.
#bools : methods for boolean evaluation.
#arrays : methods for arrays.
#lists : methods for lists.
#sets : methods for sets.
#maps : methods for maps.
#aggregates : methods for creating aggregates on arrays or collections.
#ids : methods for dealing with id attributes that might be repeated (for example, as a result of an iteration).
Selection Variable Expressions: *{...}：选择表达式：和${}在功能上是一样；
补充：配合 th:object="${session.user}：
<div th:object="${session.user}">
<p>Name: <span th:text="*{firstName}">Sebastian</span>.</p>
<p>Surname: <span th:text="*{lastName}">Pepper</span>.</p>
<p>Nationality: <span th:text="*{nationality}">Saturn</span>.</p>
</div>
Message Expressions: #{...}：获取国际化内容
Link URL Expressions: @{...}：定义URL；
@{/order/process(execId=${execId},execType='FAST')}
Fragment Expressions: ~{...}：片段引用表达式
<div th:insert="~{commons :: main}">...</div>
Literals（字面量）
Text literals: 'one text' , 'Another one!' ,…
Number literals: 0 , 34 , 3.0 , 12.3 ,…
Boolean literals: true , false
Null literal: null
Literal tokens: one , sometext , main ,…
Text operations:（文本操作）
String concatenation: +
Literal substitutions: |The name is ${name}|
Arithmetic operations:（数学运算）
Binary operators: + , - , * , / , %
Minus sign (unary operator): -
Boolean operations:（布尔运算）
Binary operators: and , or
Boolean negation (unary operator): ! , not
Comparisons and equality:（比较运算）
Comparators: > , < , >= , <= ( gt , lt , ge , le )
Equality operators: == , != ( eq , ne )
Conditional operators:条件运算（三元运算符）
If-then: (if) ? (then)
If-then-else: (if) ? (then) : (else)
Default: (value) ?: (defaultvalue)
Special tokens:
No-Operation: _
3.SpringMVC自动配置原理
Spring Boot Reference Guide
Spring Boot自动配置好了SpringMVC
1.以下是SpringBoot对SpringMVC的默认:
-
Inclusion of
ContentNegotiatingViewResolverandBeanNameViewResolverbeans.- 自动配置了ViewResolver（视图解析器：根据方法的返回值得到视图对象（View），视图对象决定如何渲染（转发？重定向？））
- ContentNegotiatingViewResolver：组合所有的视图解析器
- 如何定制:我们可以自己给容器中添加一个视图解析器；自动的将其组合起来；
-
Support for serving static resources, including support for WebJars (see below).静态资源文件夹路径，webjars。
-
Automatic registration of
Converter,GenericConverter,Formatterbeans.- 自动注册了
Converter：类型转换器GenericConverter,Formatter：格式化器- 自己添加的格式化转换器，我们只需要放在容器中即可；
-
Support for
HttpMessageConverters(see below).- HttpMessageConverter ：SpringMVC用来转换请求和响应的；
- HttpMessageConverters：是从容器中确定；获取所有的HttpMessageConverter ；
- 自己给容器中添加HttpMessageConverter ，只需将自己的组件注册到容器中（@Bean，@Component）
-
Automatic registration of
MessageCodesResolver(see below).定义错误代码生成规则 -
Static
index.htmlsupport.静态首页访问 -
Custom
Faviconsupport (see below). -
Automatic use of a
ConfigurableWebBindingInitializerbean (see below).- 我们可以配置一个ConfigurableWebBindingInitializer添加到容器来替换默认的；
If you want to keep Spring Boot MVC features, and you just want to add additional MVC configuration (interceptors, formatters, view controllers etc.) you can add your own @Configuration class of type WebMvcConfigurerAdapter, but without @EnableWebMvc. If you wish to provide custom instances of RequestMappingHandlerMapping, RequestMappingHandlerAdapter or ExceptionHandlerExceptionResolver you can declare a WebMvcRegistrationsAdapter instance providing such components.
If you want to take complete control of Spring MVC, you can add your own @Configuration annotated with @EnableWebMvc.
2.扩展SpringMVC
编写一个配置类（@Configuration）是WebMvcConfigurerAdapter类型；不能标注@EnableWebMvc;
既保留了所有的自动配置，也能用我们扩展的配置；
/**
* 使用WebMvcConfigurerAdapter可以来扩展SpringMvc的功能
*/
//@EnableWebMvc//能全权接管SpringMvc
@Configuration
public class MyMvcConfig implements WebMvcConfigurer {
//注册拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) {
// SpringBoot2.0+ 会拦截静态资源
registry.addInterceptor(new LoginHandlerInterceptor()).addPathPatterns("/**")
.excludePathPatterns("/index.html", "/", "/user/login", "/asserts/**", "/webjars/**");
}
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/static/**", "/asserts/**").addResourceLocations(ResourceUtils.CLASSPATH_URL_PREFIX + "/static");
}
//所有的组件会一起起作用
@Override
public void addViewControllers(ViewControllerRegistry registry) {
//登录页视图解析
registry.addViewController("/").setViewName("login");
registry.addViewController("/index.html").setViewName("login");
//主页视图解析
registry.addViewController("/purchase_order.html").setViewName("main");
}
}
原理：
1)、WebMvcAutoConfiguration是SpringMvc的自动配置类
2)、在做其他自动配置时，会导入：@Import(EnableWebMvcConfiguration.class)
public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration {
private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
//从容器中获取所有的WebMvcConfigurer
@Autowired(required = false)
public void setConfigurers(List<WebMvcConfigurer> configurers) {
if (!CollectionUtils.isEmpty(configurers)) {
this.configurers.addWebMvcConfigurers(configurers);
}
}
//一个参考实现
//protected void addViewControllers(ViewControllerRegistry registry) {
//this.configurers.addViewControllers(registry);
// }
}
3)、容器中所有的WebMvcConfiguration都会一起起作用；
4)、我们的配置类也会被调用
效果：SpringMVC的自动配置和我们自己扩展的自动配置都会起作用；
3.全面接管SpringMVC
SpringBoot对SpringMVC的自动配置不需要了，所有的都是自己配置的；只需要在配置类上添加@EnableWebMvc注解
4.如何修改SpringBoot的默认配置
模式：
1）SpringBoot在自动配置很多组建的时候，先看容器中有没有用户自己配置的（@Bean、@Component）如果有就用用户自己配置的，如果没有才自动配置；如果有写组件有多个（如：ViewResolver）将用户配置的和默认的组个起来；
5.RestfulCRUD
1.Thymeleaf公共页面元素抽取
1、抽取公共片段
<div th:fragment="copy">
© 2011 The Good Thymes Virtual Grocery
</div>
2、在需要的地方引入公共片段
<body>
...
<div th:insert="~{footer :: copy}"></div>
</body>
~{templatename::selector} 模板名：：选择器
~{templatename::fragmentname} 模板名：：片段名
3、默认效果
insert的功能片段在div标签中
三种引入功能片段的th属性：
**th:insert ** ：将整个公共片段插入到声明引入的元素中
th:replace ：将声明引入的元素替换为公共片段
th:include ：将被引入的片段的内容包含近这个标签中
<footer th:fragment="copy">
© 2011 The Good Thymes Virtual Grocery
</footer>
//三种引入方式
<div th:insert="footer :: copy"></div>
<div th:replace="footer :: copy"></div>
<div th:include="footer :: copy"></div>
//效果
<div>
<footer>
© 2011 The Good Thymes Virtual Grocery
</footer>
</div>
<footer>
© 2011 The Good Thymes Virtual Grocery
</footer>
<div>
© 2011 The Good Thymes Virtual Grocery
</div>
6.错误处理机制
1、SpringBoot默认的错误处理机制
1）、默认：浏览器返回一个默认的网页
2）、客户端会返回 Json格式数据
参照ErrorMvcAutoConfiguration：错误处理的自动配置
给容器中添加了一下组件：
DefaultErrorAttributes：帮我们在页面共享信息
@Override
public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes,
boolean includeStackTrace) {
Map<String, Object> errorAttributes = new LinkedHashMap<String, Object>();
errorAttributes.put("timestamp", new Date());
addStatus(errorAttributes, requestAttributes);
addErrorDetails(errorAttributes, requestAttributes, includeStackTrace);
addPath(errorAttributes, requestAttributes);
return errorAttributes;
}
BasicErrorController：处理默认/error请求
@Controller
@RequestMapping({"${server.error.path:${error.path:/error}}"})
public class BasicErrorController extends AbstractErrorController {
@RequestMapping(produces = {"text/html"})//产生html类型数据；浏览器发送的请求被这个方法处理
public ModelAndView errorHtml(HttpServletRequest request, HttpServletResponse response) {
HttpStatus status = this.getStatus(request);
Map<String, Object> model = Collections.unmodifiableMap(this.getErrorAttributes(request, this.getErrorAttributeOptions(request, MediaType.TEXT_HTML)));
response.setStatus(status.value());
ModelAndView modelAndView = this.resolveErrorView(request, response, status, model);
return modelAndView != null ? modelAndView : new ModelAndView("error", model);
}
@RequestMapping//产生json数据；客户端发送的请求被这个方法处理
public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
HttpStatus status = this.getStatus(request);
if (status == HttpStatus.NO_CONTENT) {
return new ResponseEntity(status);
} else {
Map<String, Object> body = this.getErrorAttributes(request, this.getErrorAttributeOptions(request, MediaType.ALL));
return new ResponseEntity(body, status);
}
}
ErrorPageCustomizer：
public class ErrorProperties {
@Value("${error.path:/error}")
private String path = "/error";//系统出现错误后来到/error请求进行处理
DefaultErrorViewResolver：
public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status, Map<String, Object> model) {
ModelAndView modelAndView = this.resolve(String.valueOf(status.value()), model);
if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {
modelAndView = this.resolve((String)SERIES_VIEWS.get(status.series()), model);
}
return modelAndView;
}
private ModelAndView resolve(String viewName, Map<String, Object> model) {
//默认SpringBoot去找error/404这个页面
String errorViewName = "error/" + viewName;
//模板引擎可以解析这个页面就用模板引擎解析
TemplateAvailabilityProvider provider = this.templateAvailabilityProviders.getProvider(errorViewName, this.applicationContext);
//模板引擎可用的情况下返回到errorViewName指定的视图地址,模板引擎不能用就在静态资源文件夹下找errorViewName对应的页面 error/404.html
return provider != null ? new ModelAndView(errorViewName, model) : this.resolveResource(errorViewName, model);
}
步骤：
一但系统出现4xx或5xx之类的错误，ErrorPageCustomizer就会生效（定制错误的响应规则），继而发送/error请求，继而被BasicErrorController处理
响应页面；去哪个页面是由DefaultErrorViewResolver解析得到的
protected ModelAndView resolveErrorView(HttpServletRequest request, HttpServletResponse response, HttpStatus status, Map<String, Object> model) {
Iterator var5 = this.errorViewResolvers.iterator();
ModelAndView modelAndView;
do {
if (!var5.hasNext()) {
return null;
}
ErrorViewResolver resolver = (ErrorViewResolver)var5.next();
modelAndView = resolver.resolveErrorView(request, status, model);
} while(modelAndView == null);
return modelAndView;
}
2.如何定制错误响应
1）、如何定制错误的页面：
有模板引擎的情况下：error/状态码：将错误页面命名为 错误状态码.html放在模板引擎文件夹里的error文件夹下，发生此状态码错误就会来到对应的页面；
我们可以使用4xx和5xx作为错误页面的文件名来匹配这种类型的所有错误，精确状态码页面优先。
页面能获取的信息：
timestamp：时间戳
status：状态码
error：错误提示
exception：异常对象
message：异常消息
errors：JSR303数据校验的错误都在这里
**无模板引擎的情况：**模板引擎找不到错误页面，静态资源文件夹下找
以上都没有错误页面，就默认来到SpringBoot默认的错误页面提示
2）、如何定制错误的 Json数据：
①：自定义异常处理&返回定制json数据（不能自适应效果）
@ControllerAdvice //异常处理注解
public class MyExceptionController {
//SpringBoot不能自动识别是客户端访问还是浏览器访问，返回的全部时Json数据
// @ResponseBody
//@ExceptionHandler(Exception.class)//处理所有的异常,也可以处理特定的异常
//public Map<String,Object> myException_1(Exception e){
// Map<String,Object> map = new HashMap<>();
// map.put("code","自己定义的异常" );
// map.put("message",e.getMessage() );
// return map;
}
②：转发到/error进行自适应响应效果处理
@ControllerAdvice //异常处理注解
public class MyExceptionController {
//可以根据客户端或浏览器 自适应返回数据类型
@ExceptionHandler(Exception.class)//处理所有的异常,也可以处理特定的异常
public String myException_2(Exception e, HttpServletRequest request){
Map<String,Object> map = new HashMap<>();
//传入自己的状态码
request.setAttribute("javax.servlet.error.status_code", 400);
map.put("code","自己定义的异常" );
map.put("message",e.getMessage() );
return "forward:/error";
}
}
③：携带自定义错误信息数据
出现错误后回来到/error请求，会被BasicErrorController处理，向应出去可以获取的数据是由getErrorAttributes得到的（是AbstractErrorController(ErrorController)规定的方法）
1.完全来编写一个ErrorController的实现类【或者是编写AbstractErrorController的子类】，放在容器中
2.页面上能用的数据，或者是json返回能用的数据都是通过errorAttributes.getAttributes得到，容器中DefaultErrorAttributes.getAttributes(),默认进行处理的；
自定义ErrorAttributes
/**
* 能够在浏览器或者客户端访问时显示自定义的错误信息
*/
@Component
public class MyErrorAttributes extends DefaultErrorAttributes {
@Override
public Map<String, Object> getErrorAttributes(WebRequest webRequest, ErrorAttributeOptions options) {
Map<String,Object> map = super.getErrorAttributes(webRequest, options);
map.put("company","com");
//我们的异常处理器携带的数据
Map<String,Object> ext = (Map<String, Object>) webRequest.getAttribute("ext", 0);
map.put("ext",ext );
return map;
}
}
最终结果：响应是自适应的，可以通过定制ErrorAttributes改变需要返回的内容
7.配置嵌入式Servlet容器
SpringBoot默认使用内嵌式Tomcat.
1）、如何定制和修改Servlet容器的相关配置
①：修改和server有关的配置（serverProperties）
server.port=8080
server.servlet.context-path=/curd
server.tomcat.uri-encoding=UTF-8
#通用的Servlet容器设置
server.xxx
#Tomcat的设置
server.tomcat.xxx
②：编写一个WebServerFactoryCustomizer（嵌入式Servlet定制器）来修改servlet容器的配置
/**
* 2.0+的SpringBoot中EmbeddedServletContainerCustomizer已经不存在，被WebServerFactoryCustomizer替代了
* @return
*/
@Bean
public WebServerFactoryCustomizer<ConfigurableWebServerFactory> webServerFactoryWebServerFactoryCustomizer(){
return new WebServerFactoryCustomizer<ConfigurableWebServerFactory>() {
//定制嵌入式的Servlet规则
@Override
public void customize(ConfigurableWebServerFactory factory) {
factory.setPort(9999);
}
};
}
2）、注册Servlet三大组件【servlet、Filter、Listener】
由于SpringBoot默认是以jar包的形式启动嵌入式的Servlet容器来启动SpringBoot的web应用，没有web.xml文件
注册三大件用一下方法：
ServletRegistrationBean
// SpringBoot注册Web三大组件(servlet、filter、listener)
//1.注册Servlet
@Bean
public ServletRegistrationBean myServlet() {
ServletRegistrationBean registrationBean = new ServletRegistrationBean(new MyServlet(), "/myServlet");
return registrationBean;
}
FilterRegistrationBean
//2.注册Filter
@Bean
public FilterRegistrationBean myFilter() {
FilterRegistrationBean registrationBean = new FilterRegistrationBean<>();
registrationBean.setFilter(new MyFilter());
registrationBean.setUrlPatterns(Arrays.asList("/hello", "/myServlet"));
return registrationBean;
}
ServletListenerRegistrationBean
//3.注册Listener
@Bean
public ServletListenerRegistrationBean myListener() {
ServletListenerRegistrationBean<MyListener> registrationBean = new ServletListenerRegistrationBean<>(new MyListener());
return registrationBean;
}
SpringBoot自动配置SpringMVC时，自动注册了SpringMVC的前端控制器：DispatcherServlet
@Bean( name = {"dispatcherServletRegistration"} )
@ConditionalOnBean(value = {DispatcherServlet.class},name = {"dispatcherServlet"})
public DispatcherServletRegistrationBean dispatcherServletRegistration(DispatcherServlet dispatcherServlet, WebMvcProperties webMvcProperties, ObjectProvider<MultipartConfigElement> multipartConfig) {
DispatcherServletRegistrationBean registration = new DispatcherServletRegistrationBean(dispatcherServlet, webMvcProperties.getServlet().getPath());
//默认拦截 "/" 所有请求，包括静态资源，但是不拦截JSP，"/*"拦截JSP
registration.setName("dispatcherServlet");
registration.setLoadOnStartup(webMvcProperties.getServlet().getLoadOnStartup());
multipartConfig.ifAvailable(registration::setMultipartConfig);
return registration;
}
3）、替换为其它嵌入式Servlet容器
默认支持：
Tomcat(默认使用):
Jetty:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<artifactId>spring-boot-starter-tomcat</artifactId>
<groupId>org.springframework.boot</groupId>
</exclusion>
</exclusions>
</dependency>
<!--引入其他的Servlet容器-->
<dependency>
<artifactId>spring-boot-starter-jetty</artifactId>
<groupId>org.springframework.boot</groupId>
</dependency>
</dependency>
Undertow:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<artifactId>spring-boot-starter-tomcat</artifactId>
<groupId>org.springframework.boot</groupId>
</exclusion>
</exclusions>
</dependency>
<!--引入其他的Servlet容器-->
<dependency>
<artifactId>spring-boot-starter-jetty</artifactId>
<groupId>org.springframework.boot</groupId>
</dependency>
</dependency>
8.使用外置Servlet容器
嵌入式Servlet应打成Jar包
优点：简单、便捷
缺点：默认不支持JSP、优化定制比较复杂
外置的Servlet容器：外面安装Tomcat 应用打成War包
步骤：
1、创建一个War项目
2、将嵌入式Tomcat指定为provided
<dependency>
<artifactId>spring-boot-starter-tomcat</artifactId>
<groupId>org.springframework.boot</groupId>
<scope>provided</scope>
</dependency>
3、必须编写一个SpringBootServletInitializer的子类，并调用configure方法
public class ServletInitializer extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
//传入SpringBoot应用主程序
return builder.sources(SpringBootRestfulcrudApplication.class);
}
}
4、启动Tomcat服务器即可使用。
原理：
jar包：执行SpringBoot主启动类的main方法，启动ioc容器，创建嵌入式的Servlet容器。
war包：启动服务器，服务器启动SpringBoot应用（SpringBootServletInitializer），启动ioc容器。
八、SpringBoot与Docker
1、简介
Docker是一个开源的应用容器引擎；
Docker支持将软件编译成一个镜像，然后在镜像中配置好各种软件，将镜像发布出去，其他使用者可以直接使用这个镜像。运行中的这个镜像称为容器，容器启动是非常快的。
2、核心概念
docker主机(host)：安装了Docker程序的机器（Docker直接安装在操作系统上）
docker客户端(Client)：连接docker主机进行操作
docker仓库(Registry)：用来保存各种打包好的软件镜像
docker镜像(Images)：软件打包好的镜像；放在docker仓库中
docker容器(Container)：镜像启动后的实例称为一个容器；容器是独立运行的一个或一组应用
使用Docker的步骤：
1）、安装Docker
2）、去Docker仓库找到这个软件对应的镜像
3）、使用Docker运行这个镜像，这个镜像就会生成一个Docker容器
4）、对容器启动的停止就是对软件的启动停止
3、安装Docker
1）、安装Linux虚拟机
1、VMWare、VirtualBox(轻量)
2、导入虚拟机文件
3、双击启动导入的虚拟机（用户名：root 密码：123456）
4、使用客户端连接Linux服务器进行命令操作
5、设置虚拟机网络 (桥接网络>根据实机选择网络选择界面名称>接入网线)
6、重启虚拟机网卡
service network restart
7、查看虚拟机IP地址
ip addr
2）、在Linux虚拟机上安装Docker
1、查看Centos版本（要求Centos版本内核高于3.10）
# uname -r
2、安装docker
# yum install docker
3、启动docker
# systemctl start docker
注：如果启动时报错：Job for docker.service failed because the control process exited with error code. See "systemctl status docker.service" and "journalctl -xe" for details.
解决：vi进入 /etc/sysconfig/docker
OPTIONS='--selinux-enabled --log-driver=journald --signature-verification=false'改为OPTIONS='--selinux-enabled=false --log-driver=journald --signature-verification=false'即可。
4、查看docker版本
# docker -v
Docker version 1.13.1, build 7d71120/1.13.1
5、开机自启docker
# systemctl enable docker
Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.
4、Docker常用命令&操作
1）、镜像操作
| 操作 | 命令 | 说明 |
|---|---|---|
| 检索 | docker search xxx 如 docker search mysql | 与docker hub官网一样，可以检索镜像的信息，如镜像的Tag |
| 拉取 | docker pull 镜像名 : tag | tag是可选的，tag表示标签，多为软件的版本，默认是latest |
| 列表 | docker images | 查看本地所有镜像 |
| 删除 | docker rmi image-id | 删除指定的本地镜像 |
docker hub官网搜索镜像
2）、容器操作
软件镜像（xxx.exe）----运行镜像----产生一个容器（正在运行的软件）
步骤：
1、搜索镜像
[root@localhost ~]# docker search tomcat
2、拉取镜像
[root@localhost ~]# docker pull tomcat //拉取的tomcat镜像不要新版本
3、根据镜像启动容器
[root@localhost ~]# docker run --name mytomcat -d containerName // -d代表后台运行
f4991f8cf0bf0573f9549929aa98985b7148afd71bbe9c1f37c70aaa00acf461
4、停止运行中的容器
# docker stop 容器的id/docker container stop 容器ID
5、查看运行中的容器
# docker ps
6、查看所有的容器
# docker ps -a
7、启动容器
# docker start 容器的id/docker container start 容器ID
8、删除一个容器
# docker rm 容器的id
9、启动一个做了端口映射的tomcat
# docker run -d -it -p 8888:8080 tomcat;
-p:主机的端口映射到容器的一个端口 #（主机端口8888：映射虚拟机容器中的端口8080）
#注：docker容器运行必须有一个前台进程， 如果没有前台进程执行，容器认为空闲，容器运行的命令如果不是那些一直挂起的命令（eg. 运行top，tail等），就会自行退出，
# docker run -d -it -p 8080:8080 tomcat /bin/bash
10、查看日志
# docker logs containerName/containerId
更多docker命令参考
3）、安装MySQL示例
拉取mysql镜像
# docker pull mysql:5.7.38
错误启动演示：
# docker run -d mysql:5.7.38
使用docker ps查看没有后台运行的容器
查看日志docker logs mysql容器的id
Database is uninitialized and password option is not specified
You need to specify one of the following:
- MYSQL_ROOT_PASSWORD
- MYSQL_ALLOW_EMPTY_PASSWORD
- MYSQL_RANDOM_ROOT_PASSWORD 这三个参数必须指定一个
正确启动演示：
# docker run -e MYSQL_ROOT_PASSWORD=root -d mysql:5.7.38 未做端口映射
# docker run -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root -d mysql:5.7.38 做了端口映射
其他带参高级操作：
# docker run --name some-mysql -v /conf/mysql:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
-v /conf/mysql:/etc/mysql/conf.d 把主机的/conf/mysql挂载到mysql容器的/etc/mysql/conf.d文件夹里面，改mysql的配置文件放在/conf/mysql下
# docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
指定mysql的一些参数
九、SpringBoot与数据访问
1、JDBC
导入依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
2.0+版本的SpringBoot默认使用的数据源：com.zaxxer.hikari.HikariDataSource
数据源的相关配置都在DataSourceProperties.class中
自动配置原理：
和数据源有关的配置都在这个包下：
org.springframework.boot.autoconfigure.jdbc
1）、参考DataSourceConfiguration.class，根据配置创建数据源，默认使用Hikari连接池，可以使用spring.datasource.type指定自定义的数据源类型；
2）、SpringBoot默认支持以下数据源
org.apache.tomcat.jdbc.pool.DataSource、HikariDataSource、BasicDataSource
3）、也可以使用以下方法自定义数据源类型
@Configuration(proxyBeanMethods = false)
@ConditionalOnMissingBean({DataSource.class})
@ConditionalOnProperty(name = {"spring.datasource.type"})
static class Generic {
Generic() {
}
@Bean
DataSource dataSource(DataSourceProperties properties) {
return properties.initializeDataSourceBuilder().build();
}
}
使用DataSourceBuilder来创建数据源，其中有一个build()方法，通过BeanUtils进行反射创建相应的type的数据源，并且绑定相关属性
4）、还有一处配置：DataSourceAutoConfiguration ，代表数据源的自动配置。
由于2.0版本以上的SpringBoot源码变动，DataSourceAutoConfiguration 中没有DataSourceInitializer 。不过，有一个DataSourceInitializerInvoker，是一个ApplicationListener监听器，其中则有。
其作用：
2.0版本以上是
1、createSchema()：运行建表语句
2、initSchema()：运行插入数据的SQL语句
二者都调用runScripts()方法，但2.0版本以上要在配置文件中加入
# 初始化模式
spring.datasource.initialization-mode=always
其有三个值：always为始终执行初始化，embedded只初始化内存数据库（默认值）,如h2等，never为不执行初始化
是应为2.0版本有个isEnabled()方法，用来判断类型的。
2.0版本以下：
1、runSchemaScripts()：运行建表语句
2、runDataScripts()：运行插入数据的sql语句。
默认只需将文件命名为：
schame-*.sql、data-*.sql
默认规则：schame.sql或schema-all.sql
如果不是用默认规则，则需要在配置文件中使用spring.datasource.schema=xxx
指定sql脚本文件的路径,如spring.datasource.schema=classpath:department.sql
在运行建表语句时，先通过getScripts（）方法获取sql脚本文件。可以通过resources指定文件的位置，如果找不到，就去找类路径下找fallback，而fallback就是schema
5）、操作数据库：自动配置了jdbcTemplate操作数据库
注：每次启动项目都会重新执行建表语，可以删除sql脚本文件，也可在配置文件中将spring.datasource.initialization-mode改为never
2、整合Druid数据源
添加Druid数据源依赖：
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.8</version>
</dependency>
给容器中注入Druid数据源：
@Configuration
public class DruidConf {
@Bean
@ConfigurationProperties(prefix = "spring.datasource")//绑定数据元的其他配置
public DataSource druid(){
return new DruidDataSource() ;
}
/**
* 配置druid监控
* 配置一个管理后台的Servlet：statViewServlet
* @return
*/
@Bean
public ServletRegistrationBean statViewServlet(){
ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
Map<String,Object> map = new HashMap<>();
map.put("loginUsername", "admin");
map.put("loginPassword", "123456");
map.put("allow", ""); //""或null为访问所有
map.put("deny","192.168.2.175" );//拒绝访问
//为此注册设置初始化参数。调用此方法将替换任何现有的初始化参数。
bean.setInitParameters(map);
return bean;
}
/**
* 配置一个监控Web的filter：webStatFilter
* @return
*/
@Bean
public FilterRegistrationBean webStatFilter(){
FilterRegistrationBean bean = new FilterRegistrationBean(new WebStatFilter());
Map<String,Object> map = new HashMap<>();
//释放这些请求
map.put("exclusions", "*.js,*.css,/druid/*");
bean.setInitParameters(map);
//拦截所有请求
bean.setUrlPatterns(Arrays.asList("/*"));
return bean;
}
}
application.properties
# 应用名称
spring.application.name=spring-boot-data-jdbc
# 应用服务 WEB 访问端口
server.port=8080
# 数据库驱动：
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# 数据源名称
spring.datasource.name=defaultDataSource
# 初始化模式
spring.datasource.initialization-mode=never
# 数据库脚本文件路径
spring.datasource.schema=classpath:department.sql
# 数据库连接地址
spring.datasource.url=jdbc:mysql://192.168.2.175:3306/jdbc?serverTimezone=UTC
# 自定义数据源
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
# 数据源其他配置
spring.datasource.initialSize=5
spring.datasource.minIdle=5
spring.datasource.maxActive=20
spring.datasource.maxWait=60000
spring.datasource.timeBetweenEvictionRunsMillis=60000
spring.datasource.minEvictableIdleTimeMillis=300000
spring.datasource.validationQuery=SELECT 1 FROM DUAL
spring.datasource.testWhileIdle=true
spring.datasource.testOnBorrow=false
spring.datasource.testOnReturn=false
spring.datasource.poolPreparedStatements=true
# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
spring.datasource.filters=stat,wall,log4j2
spring.datasource.maxPoolPreparedStatementPerConnectionSize=20
spring.datasource.useGlobalDataSourceStat=true
spring.datasource.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
#是否启用StatViewServlet（监控页面）默认值为false（考虑到安全问题默认并未启动，如需启用建议设置密码或白名单以保障安全）
#spring.datasource.druid.stat-view-servlet.enabled=true
# 数据库用户名&密码：
spring.datasource.username=root
spring.datasource.password=root
Druid监控
3、整合MyBatis
1）、引入MyBatis依赖
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.4</version>
</dependency>
2）、注解版
注解版不能配置xxx.xml，所以注解版的配置需要使用MybatisAutoConfiguration类中的ConfigurationCustomizer定制一个MyBatis配置类加入到容器中
@Configuration
public class MybatisConf {
@Bean
public ConfigurationCustomizer configurationCustomizer(){
return new ConfigurationCustomizer() {
@Override
public void customize(org.apache.ibatis.session.Configuration configuration) {
configuration.setMapUnderscoreToCamelCase(true);//开启驼峰命名法
}
};
}
}
注：如果mapper包下的mapper太多，可以在SpringBoot启动类上使用@MapperScan注解扫描mapper包。
3）、配置文件版
创建一个Mybatis全局配置文件：mybatis-conf.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<settings>
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
</configuration>
在SpringBoot配置文件application.properties中增加以下配置：
# 指定MyBatis全局配置文件路径
mybatis.config-location=classpath:mybatis/mybatis-conf.xml
#指定mapper映射文件路径
mybatis.mapper-locations=classpath:mybatis/mapper/*.xml
创建mapper.xml映射文件：
<?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">
<mapper namespace="com.atcpl.springboot.mapper.Mappers">
<select id="queryEmpById" resultType="com.atcpl.springboot.entity.Employee">
select * from employee where id = #{id}
</select>
</mapper>
注： ，namespace的值为mapper接口文件的全类名。
<select id=" “>，id的值为mapper接口中抽象方法的方法名。
更多配置参考Mybatis官方文档
4、整合SpringData JPA
1）、SpringData简介
2）、整合SpringData JPA
jpa：ORM（Object Relational Mapping）
步骤：
①：编写一个实体类（bean）和数据表进行映射,并且配置好映射关系
/**
* 使用JPA注解配置映射关系
*/
@Entity //告诉JPA这是一个实体类 （与数据表映射的类）
@Table(name = "user_table") // @Table指定和哪个数据表对应；默认是实体类类名小写user
public class User {
@Id // @Id 主键
@GeneratedValue(strategy = GenerationType.IDENTITY) // 主键自增
private Integer id;
@Column(name = "email",length = 25) // 这是和数据表对应的一个列； name指定字段名 length指定长度
private String email;
@Column //字段名默认为属性名
private String userName;
}
②：创建一个Dao接口来操作实体类对应的数据表（Repository）
/**
* 这是一个Dao接口，来操作实体类对应的数据表（Repository）
* JpaRepository<T,ID> :
* 泛型T:代表要操作的实体类
* 泛型ID：实体类主键
*/
public interface UserRepository extends JpaRepository<User,Integer> {
}
③：JPA的基本配置
spring:
jpa:
hibernate:
# 更新或者创建数据表结构
ddl-auto: update
# 在控制台显示sql
show-sql: true
所有的JPA配置都在JpaProperties.class类中。
findOne()与findById():
调用findByid方法，返回实体类的Optional，再调用isPresent进行判断是否不为空，若是就调用get获取对象，然后判断对象是否存在，删除
Optional<Permission> permissions = permissionDao.findById(id);
if (permissions.isPresent()){
Permission permission = permissions.get();
if (permission != null){
permissionDao.delete(permission);
}
}
调用findById()方法和orElse(null)方法，获取实体类对象，然后再判断实体类是否为空
permissionDao.findById(id).ifPresent(permission -> {
if (permission != null){
permissionDao.delete(permission);
}
});
十、启动配置原理
几个重要的事件回调机制
配置在META-INF/spring.factories
ApplicationContextInitializer
SpringApplicationRunListener
只需要放在ioc容器中
ApplicationRunner
CommandLineRunner
启动原理：
1、创建SpringApplication对象
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
this.resourceLoader = resourceLoader;
Assert.notNull(primarySources, "PrimarySources must not be null");
//保存主配置类
this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
//判断当前应用是否为Web应用
this.webApplicationType = WebApplicationType.deduceFromClasspath();
//从类路径下找到META‐INF/spring.factories配置的所有ApplicationContextInitializer；然后保存起来
setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
//从类路径下找到ETA‐INF/spring.factories配置的所有ApplicationListener
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
//从多个配置类中找到有main方法的主配置类
this.mainApplicationClass = deduceMainApplicationClass();
}
private Class<?> deduceMainApplicationClass() {
try {
StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
for (StackTraceElement stackTraceElement : stackTrace) {
if ("main".equals(stackTraceElement.getMethodName())) {
return Class.forName(stackTraceElement.getClassName());
}
}
}
catch (ClassNotFoundException ex) {
// Swallow and continue
}
return null;
}
2、调用run()方法
public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
configureHeadlessProperty();
//从类路径META-INF/spring.factories下获取SpringApplicationRunListeners
SpringApplicationRunListeners listeners = getRunListeners(args);
//回调所有的获取SpringApplicationRunListener.starting()方法
listeners.starting();
try {
//封装命令行参数
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
//准备环境
ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
//创建环境完成后回调SpringApplicationRunListener.environmentPrepared()；表示环境准备完成
configureIgnoreBeanInfo(environment);
//打印banner图，就是控制台中那个大Spring
Banner printedBanner = printBanner(environment);
//创建ApplicationContext；决定创建web的ioc还是普通的ioc
context = createApplicationContext();
//做异分析报告
exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
new Class[] { ConfigurableApplicationContext.class }, context);
//准备上下文环境;将environment保存到ioc中；而且applyInitializers()方法回调之前保存的所有的ApplicationContextInitializer的initialize方法；listeners.contextPrepared(context)则回调所有的SpringApplicationRunListener的contextPrepared()；
//prepareContext运行完成以后回调所有的SpringApplicationRunListener的contextLoaded（）；
prepareContext(context, environment, listeners, applicationArguments, printedBanner);
//刷新容器；ioc容器初始化（如果是web应用还会创建嵌入式的Tomcat）；
//扫描，创建，加载所有组件的地方；（配置类，组件，自动配置）
refreshContext(context);
//从ioc容器中获取所有的ApplicationRunner和CommandLineRunner进行回调
//ApplicationRunner先回调，CommandLineRunner再回调
afterRefresh(context, applicationArguments);
stopWatch.stop();
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
}
listeners.started(context);
callRunners(context, applicationArguments);
}
catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, listeners);
throw new IllegalStateException(ex);
}
try {
listeners.running(context);
}
catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, null);
throw new IllegalStateException(ex);
}
//整个SpringBoot应用启动完成以后返回启动的ioc容器；
return context;
}
3、事件监听机制
配置在META-INF/spring.factories
ApplicationContextInitializer
public class HelloApplicationContextInitializer implements
ApplicationContextInitializer<ConfigurableApplicationContext> {
@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
System.out.println("ApplicationContextInitializer...initialize..."+applicationContext);
}
}
SpringApplicationRunListener
public class HelloSpringApplicationRunListener implements SpringApplicationRunListener {
//必须有的构造器
public HelloSpringApplicationRunListener(SpringApplication application, String[] args){
}
@Override
public void starting() {
System.out.println("SpringApplicationRunListener...starting...");
}
@Override
public void environmentPrepared(ConfigurableEnvironment environment) {
Object o = environment.getSystemProperties().get("os.name");
System.out.println("SpringApplicationRunListener...environmentPrepared.."+o);
}
@Override
public void contextPrepared(ConfigurableApplicationContext context) {
System.out.println("SpringApplicationRunListener...contextPrepared...");
}
@Override
public void contextLoaded(ConfigurableApplicationContext context) {
System.out.println("SpringApplicationRunListener...contextLoaded...");
}
@Override
public void finished(ConfigurableApplicationContext context, Throwable exception){
System.out.println("SpringApplicationRunListener...finished...");
}
}
配置（META-INF/spring.factories）
org.springframework.context.ApplicationContextInitializer=\
com.atguigu.springboot.listener.HelloApplicationContextInitializer
org.springframework.boot.SpringApplicationRunListener=\
com.atguigu.springboot.listener.HelloSpringApplicationRunListener
只需要放在ioc容器中
ApplicationRunner
@Component
public class HelloApplicationRunner implements ApplicationRunner {
@Override
public void run(ApplicationArguments args) throws Exception {
System.out.println("ApplicationRunner...run....");
}
}
CommandLineRunner
@Component
public class HelloCommandLineRunner implements CommandLineRunner {
@Override
public void run(String... args) throws Exception {
System.out.println("CommandLineRunner...run..."+ Arrays.asList(args));
}
}
十一、自定义Starter
starter：又叫场景启动器
1、这个场景需要使用到的依赖是什么？
2、如何编写自动配置
@Configuration //指定这个类是一个配置类
@ConditionalOnXXX //在指定条件成立的情况下自动配置类生效
@AutoConfigureAfter //指定自动配置类的顺序
@Bean //给容器中添加组件
@ConfigurationPropertie结合相关xxxProperties类来绑定相关的配置
@EnableConfigurationProperties //让xxxProperties生效加入到容器中
自动配置类要能加载
将需要启动就加载的自动配置类，配置在META‐INF/spring.factories
3、模式
启动器只用来做依赖导入；
专门来写一个自动配置模块；
启动器依赖自动配置；别人只需要引入启动器（starter）
启动器命名规约：
- 官方命名空间
- 前缀：“spring-boot-starter-”
- 模式：“spring-boot-starter-模块名”
- 如：spring-boot-starter-web、spring-boot-starter-jdbc
- 自定义命名空间
- 后缀：“-spring-boot-starter”
- 模式：模块-spring-boot-starter
- 如：mybatis-spring-boot-starter
即：自定义启动器名-spring-boot-starter
xtLoaded…");
}
@Override
public void finished(ConfigurableApplicationContext context, Throwable exception){
System.out.println(“SpringApplicationRunListener…finished…”);
}
}
**配置（META-INF/spring.factories）**
```properties
org.springframework.context.ApplicationContextInitializer=\
com.atguigu.springboot.listener.HelloApplicationContextInitializer
org.springframework.boot.SpringApplicationRunListener=\
com.atguigu.springboot.listener.HelloSpringApplicationRunListener
只需要放在ioc容器中
ApplicationRunner
@Component
public class HelloApplicationRunner implements ApplicationRunner {
@Override
public void run(ApplicationArguments args) throws Exception {
System.out.println("ApplicationRunner...run....");
}
}
CommandLineRunner
@Component
public class HelloCommandLineRunner implements CommandLineRunner {
@Override
public void run(String... args) throws Exception {
System.out.println("CommandLineRunner...run..."+ Arrays.asList(args));
}
}
十一、自定义Starter
starter：又叫场景启动器
1、这个场景需要使用到的依赖是什么？
2、如何编写自动配置
@Configuration //指定这个类是一个配置类
@ConditionalOnXXX //在指定条件成立的情况下自动配置类生效
@AutoConfigureAfter //指定自动配置类的顺序
@Bean //给容器中添加组件
@ConfigurationPropertie结合相关xxxProperties类来绑定相关的配置
@EnableConfigurationProperties //让xxxProperties生效加入到容器中
自动配置类要能加载
将需要启动就加载的自动配置类，配置在META‐INF/spring.factories
3、模式
启动器只用来做依赖导入；
专门来写一个自动配置模块；
启动器依赖自动配置；别人只需要引入启动器（starter）
启动器命名规约：
- 官方命名空间
- 前缀：“spring-boot-starter-”
- 模式：“spring-boot-starter-模块名”
- 如：spring-boot-starter-web、spring-boot-starter-jdbc
- 自定义命名空间
- 后缀：“-spring-boot-starter”
- 模式：模块-spring-boot-starter
- 如：mybatis-spring-boot-starter
即：自定义启动器名-spring-boot-starter
