SpringBoot进阶
没想到把，SpringBoot虽然简化了开发流程，但要学的东西还有很多
1. Spring Boot简介
- 采用约定大于配置，简化Spring开发步骤与复杂的部署流程
- 快速创立可独立运行的Spring项目以及集成主流框架
- 嵌入式Servlet容器，无需打war包
- starter自动依赖与版本控制
- 大量的自动配置，可修改默认值
- 需要xml，无代码生成，开箱即用
- 准生产环境的运行时应用监控
- 与其他框架天然集成
- 整合Spring技术栈的大框架
2. 入门解析
1.创建maven工程jar
2.导入父项目与依赖
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.9.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
3.创建主程序
// 标注主程序类，说明是Springboot应用
@SpringBootApplication
public class HelloWorld {
public static void main(String[] args) {
// 让Spring应用启动，需要传入主程序类，和其参数
SpringApplication.run(HelloWorld.class,args);
}
}
4.编写controller
@RestController
public class HelloController {
@RequestMapping(value = "/hello")
public String hello(){
return "hello world";
}
}
5.测试
来到主程序运行main方法
6.打包部署（记住名字不能有空格）
<!-- 将应用打包成可执行jar包的插件，package命令 -->
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
7.分析pom.xml
spring-boot-starter-parent：还有一个父项目spring-boot-dependencies，里面规定了依赖版本号： <属性标签s> <properties> <!-- Dependency versions --> <activemq.version>5.14.5</activemq.version> <antlr2.version>2.7.7</antlr2.version> <appengine-sdk.version>1.9.59</appengine-sdk.version> <artemis.version>1.5.5</artemis.version> <aspectj.version>1.8.13</aspectj.version> 。。。。。 </properties>
8.导入的依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
spring-boot-starter-web：springBoot的场景启动器，里面很多依赖如：spring-web、spring-webmvc、jackson、hibernate-validator、spring-boot-starter-tomcat、spring-boot-starter
场景启动器：将功能场景抽取出来，做成starters启动器，只要项目中导入对应的启动器，那么相关场景的依赖就会自动导入
9.主程序类，入口类
@SpringBootApplication
public class HelloWorld {
public static void main(String[] args) {
// 让Spring应用启动，需要传入主程序类，和其参数
SpringApplication.run(HelloWorld.class,args);
}
}
@SpringBootApplication：说明是Springboot的主配置类，那么就会运行main方法来启动应用
10.@SpringBootApplication的内部注解
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
excludeFilters = {@Filter(
type = FilterType.CUSTOM,
classes = {TypeExcludeFilter.class}
), @Filter(
type = FilterType.CUSTOM,
classes = {AutoConfigurationExcludeFilter.class}
)}
)
@SpringBootConfiguration：表示配置类，配置类也是容器的一个组件即@Component，（内部是用Spring的@Configuration）
11.@EnableAutoConfiguration：开启自动配置功能，其内部又有：
@AutoConfigurationPackage
@Import({EnableAutoConfigurationImportSelector.class})
12.@AutoConfigurationPackage： 将主配置类@SpringBootApplication标注的类及同级下面所有子包所有子包组件扫描
内部是@Import({Registrar.class})，spring的导入组件注解，Registrar.class内部有个方法
// 注册bean的定义信息，即导组件
// metadata注解标注的原信息
public void registerBeanDefinitions(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) {
AutoConfigurationPackages.register
(registry,
// 这里可以获取主配置类的上级包名
(new AutoConfigurationPackages.PackageImport(metadata)).getPackageName());
}
13.@Import({EnableAutoConfigurationImportSelector.class})：
导入组件的选择器EnableAutoConfigurationImportSelector.class，内容是：
// 内部继承父类，父类中有个方法
// 将所需导入的组件以全类名的方式返回，组件会被导入容器中
// 方法内部会导入非常多的自动配置类xxxAutoConfiguration，就是导入场景所需的全部组件，并配置好
public String[] selectImports(AnnotationMetadata annotationMetadata) {
XXXX
}
有了自动配置类，就免去我们手动配置的麻烦， SpringBoot启动时，从类路径下spring-boot-autofigure包中的META-INF/spring.factories中获取EnableAutoConfiguration的值（各种配置类的全限定类名），作为自动配置类导入容器中，那么自动配置类生效帮我们自动配置，其真正配置类也在这个包下
3. 快速创建Spring应用（创建向导）
Spring Initializer
- 主程序生成好了
-
resources中包括
- static保存所有的静态资源
- templates保存模板页面
- application.properties：springboot的配置文件，这里可修改默认的
4. 配置文件（名字固定）
- application.properties（默认使用，优先级高）
- application.yml
4.1 yml格式
server:
port: 8080
"" : 特殊字符不会转义
'' : 特殊字符会转义
对象、Map：
friends:
lastName: howl
age: 20
friends: {lastName: howl,age: 20}
数组：
pets:
- cat
- dog
pets: [dog,cat,pig]
4.2 配置文件yml获取组件的值
// 组件必须的
@Component
@ConfigurationProperties(prefix = "person") // 默认从主配置文件获取
public class Person{
private int age;
xxxxxx
}
person: age: 20 name: Howl
<!-- 导入配置文件处理器，配置文件yml绑定属性时会有提示 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
properties也一样
乱码：idea使用utf-8,要在编译器里面设置，编译转换ascii码 person.age=20 person.name=哈哈哈
4.3 从配置文件中获取值
@Value(Spring注解)
4.4 读取外部文件与xml配置文件
@PropertySource(value = "classpath:person.yml")
@ImportResources(locations = {"classpath:bean.xml"}) //读取是spring的<bean>标签的文件，放在主程序入口处
4.5 注解实现配置类
@Configuration
public class Myconfig {
@Bean
public HelloWorld helloService(){
return new HelloWorld();
}
}
4.6 配置文件随机数与占位符
${random.value}
person.age=20
person.name=${person.age:默认值}_Howl
4.7 多环境支持
4.7.1 多profile文件
主配置文件编写时，文件规定可以是 application-{profile}.properties/yml
eg：配置文件命名为:
application-dev.properties
application-prod.properties
主配置文件中加入：
spring.profiles.active=dev激活dev的配置文件
4.7.2 yml文档块
server:
port: 8081
spring:
profiles:
active: dev
---
server:
port: 8082
spring:
profiles: dev
---
server:
port: 8083
spring:
profiles:prod
4.7.3 配置文件加载位置
application.properties application.yml 优先级由高到低，优先采用高的，但也会互补 /config / classpath:/config classpath:/
5. 自动配置原理
1）SpringBoot启动的时候加载主配置类，开启了自动配置功能：@EnableAutoConfiguration
2）@EnableAutoConfiguration 作用：（去aotuconfigure包的META-INF中获取全限定类名，再将对应的类加载进来）
- 利用@Import的 AutoConfigurationImportSelector.class选择器给容器导入一些组件
- 这个选择器中的selectImports()方法负责加载
3）每一个加载的自动配置类进行自动配置功能
4）举例一个配置类的内部的注解（根据不用条件判断配置类是否生效）
@Configuration
4.1 @EnableConfigurationProperties({CacheProperties.class}) // .class是个properties映射成bean对象（但头部没有加@Component注解），要使其生效即要加入bean容器
@ConditionalOnClass({CacheManager.class}) // 内部是Spring注解@Conditional，满足条件配置类生效
其还有有参构造器，将对应的XXXproerties注入到内部变量中：
4.1）所有在配置i文件能配置的属性都是在XXXProperties类中封装着，配置文件能配置什么，就看对应的XXXProperties
5）所以我们能在主配置文件中配置什么，完全是是看xxxproperties的
Debug模式
# 主配置文件中 # 开启SpringBoot的debug模式，会显示启用的自动配置类 debug=true
6. 日志框架
| 日志抽象层（类似于JDBC） | 日志实现 |
|---|---|
|
SLF4j、 |
JUL(Java.util.logging)、Log4j、Log4j2、Logback |
Spring框架默认JCL（导包common-logging）
SpringBoot选用SLF4j和logback
应该调用日志抽象层
使用
导入SLF4j抽象层和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");
}
}
Logger logger = LoggerFactory.getLogger(this.getClass());
logger.trace("这时trace日志");
logger.debug("这时debug日志");
//日志级别
logger.info("这时info日志");
logger.warn("这时warn日志");
logger.error("这时error日志");
查看默认配置
去springboot第一个包中查看properties文件， 去去springboot-autoConfiguration看配置类
高级特性
自己写的logback.xml中可以加 <springProfile name="dev"> </springProfile name="dev"> 表示只在某个环境生效
7. Web开发
eg:数据库jdbc开发：去Springboot- autoConfigtuation包下看DataSourceAutoConfiguration，头上有注解@EnableConfigurationProperties({DataSourceProperties.class})开启properties映射对象生效，DataSourceProperties是个映射properties的bean类
我们需要熟悉自动配置原理，然后才可以很好地书写配置文件
静态资源的映射规则
在webMvcAutoConfiguration
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/**")) {
// Webjars/**下的资源请求都去 classpath:/META-INF/resources/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));
}
}
}
webjars：以jar包方式引入静态资源（juery、BootStrap等打包成jar，用maven导入）
访问Webjars/**下的资源请求都去 classpath:/META-INF/resources/webjars/ 找资源，
导包后直接写名字访问就行eg: /webjars/jquery
1）addResourceHandlers
java哪些编写代码的文件和资源文件夹下的文件编译后都放在target的classes下，classes才是类路径。根路径是个特例，不在资源文件夹下，但编译后放在classes内
- /** 默认去classpath找；Springboot的resourcers是默认的classpath
"classpath:/META-INF/resources/", "classpath:/resources/", "classpath:/static/", "classpath:/public/" "/": 当前项目的根路径，
3）欢迎页配置
欢迎页；静态资源文件夹下的所有Index
@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));
return welcomePageHandlerMapping;
}
// 方法引用在静态资源下找index.html，那个方法引用不用看了
return Arrays.stream(locations).map(this::getIndexHtml).filter(this::isReadable).findFirst();
所以： localhost:8080/ 默认找资源类路径下的 index.html文件
图标也一样；静态资源下找 /favicon.ico
8. 模板引擎thymeleaf
1)加入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
资源放在classpath:/templates/下，就自动渲染html
2)导入thymeleaf的名称空间、有语法提示
<html lang="en" xmlns:th="http://www.thymeleaf.org">
3)语法
th:text
th:each 这个标签每次遍历都会生成
${} 获取值
*{}
9. SpringMVC 自动配置
- 配置了ViewResolver视图解析器
- 配置了webjars解析
- support 静态资源文件路径、webjars
- support 静态首页访问 index.html
- support favicon.ico
- 自动注册了Converter、Formatter的beans
- Support th:each
10. 修改SpringBoot的默认配置
模式：
1）自动配置组件时（组合使用，互补），先看容器中有没有用户自己配置的@Component，@Bean，如果有就用用户配置，如果没有才自己创建自动配置
@ConditionalOnMissingBean({FormContentFilter.class})
public OrderedFormContentFilter formContentFilter() {
return new OrderedFormContentFilter();
}
2)扩展SpringMVC（eg:Interceptors、formatters）
编写一个配置类加上注解@Configuration，实现WebMvcConfigurer接口要重写的配置即可（接口有方法体了），这里不能加@EnableWebMvc（加了就是自己的生效，自动配置失效）
原理
在做其他自动配置时回导入 EnableWebMvcConfiguration.class,其父类是重点
public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration implements ResourceLoaderAware {
}
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
// 从容器中获取所有的WebMvcConfigurer就是自己写的全托管配置类，然后把其赋值内部的configurers
@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);
}
// 进去configurers.addViewControllers(registry);
// delegates内部遍历，注入类WebMvcConfigurer
// 把自己配的WebMvcConfigurer遍历里面的viewController全调用起作用
// 这里遍历就包括了自己覆盖的，已经没有覆盖的
public void addViewControllers(ViewControllerRegistry registry) {
Iterator var2 = this.delegates.iterator();
while(var2.hasNext()) {
WebMvcConfigurer delegate = (WebMvcConfigurer)var2.next();
delegate.addViewControllers(registry);
}
}
}
3）全面接管@EnableWebMvc，所有都是我们自己配
原理就是@EnableWebMvc注解里面导入了WebMvcConfiguration.class类
而我们的总的Mvc自动配置类上要先判断，否则不生效 ConditionOnMissingBean(WebMvcConfiguration.class)
4)SpringBoot中会有很多很多的xxxCustomizer帮助我们进行定制配置
11. 拦截器实现登录拦截
实现 HandlerInterceptor 接口，并在自己的配置类中注册
public class LoginHandlerInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
HttpSession session = request.getSession();
Object user = session.getAttribute("user");
if(user == null){
request.getRequestDispatcher("/").forward(request,response);
return false;
}
return true;
}
}
@Configuration
public class MyMvcConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
// 已经boot做好了静态资源放行
registry.addInterceptor(new LoginHandlerInterceptor())
.addPathPatterns("/**")
.excludePathPatterns("/","/user/login");
}
@Override
public void addViewControllers(ViewControllerRegistry registry) {
// 浏览器发送/howl请求，也来到success页面
registry.addViewController("/howl").setViewName("success");
}
}
12. Restful
| 普通 | Restful | |
|---|---|---|
| 查询 | /user/get | /user --GET |
| 添加 | /user/create | /user --POST |
| 修改 | /user/update | /user/{id} --PUT |
| 删除 | /user/delete | /user/{id} --DELETE |
实际操作
URI: /资源名称/资源表示 HTTP请求方式区分对资源的CURD
| 请求url | 请求方式 | |
|---|---|---|
| 查询所有用户 | /users | GET |
| 查询某个用户 | /user/{id} | GET |
| 添加用户 | /user | POST |
| 修改用户 | /user | PUT |
| 删除用户 | /user{id} | DELETE |
// 查询所有
@GetMapping(value = "/users")
public String list(){
return employeeDao.getAll().toString();
}
// 查询单个
@GetMapping(value = "/user/{id}")
public String listById(@PathVariable(value = "id") Integer id){
return id + " 单个用户查询";
}
// 添加
@PostMapping(value = "/user")
public String addUser(){
return "这里是添加员工";
}
@PutMapping(value = "/user")
public String updateUser(){
return "这里是put更新用户";
}
@DeleteMapping(value = "/user/{id}")
public String deleteUser(@PathVariable(value = "id") Integer id){
return "这里是删除用户" + id;
}
13. 错误处理
1）错误页面
错误处理的自动配置：ErrorMvcAutoConfiguration
给容器添加了
DefaultErrorAttributes、
BasicErrorController：处理默认的/error请求
ErrorPageCustomizer：系统出现错误来到error请求进行处理
步骤：一旦系统出现4xx或5xx的错误，ErrorPageCustomizer会生效（定制错误的相应规则）
2）定制错误的json数据
@RestControllerAdvice
public class MyEceptionHandler {
@ExceptionHandler(UserException.class)
public String HandleException(Exception e){
return e.getMessage();
}
}
14. 嵌入式Servlet容器
SpringBoot默认使用的是嵌入式的Servlet容器（Tomcat）
1)定制和修改Servlet容器的相关配置
server.port=8081 server.servlet.context-path=/curd server.tomcat.uri-encoding=UTF-8 # 通用的Servlet容器设置 server.xxx server.tomcat.xxx
编写一个WebServerFactoryCustomizer：嵌入式的Servlet容器的定制器，来修改Servlet容器的配置
@Bean
public WebServerFactoryCustomizer<ConfigurableWebServerFactory> webServerFactoryCustomizer() {
// 其实就是返回本类的实现类给他
return new WebServerFactoryCustomizer<ConfigurableWebServerFactory>() {
@Override
// 传参是一个容器
public void customize(ConfigurableWebServerFactory factory) {
//设置tomcat的端口号
factory.setPort(9091);
}
};
}
重点
2）注册Servlet、Filter、Listener
ServletRegistrationBean
FilterRegistrationBean
SerlvetListenerRegistrationBean
Springboot默认是以jar包方式启动嵌入式的Servlet容器来启动应用，没有web.xml文件
编写Servlet
public class MySerlvet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req,resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.getWriter().write("Hello World");
}
}
使用官方提供的注册
package com.howl.springboot.config;
@Configuration
public class MyServerConfig {
@Bean
public ServletRegistrationBean myServlet(){
return new ServletRegistrationBean(new MySerlvet(),"/myServlet");
}
@Bean
public FilterRegistrationBean myFilter(){
FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
filterRegistrationBean.setFilter(new MyFileter());
filterRegistrationBean.setUrlPatterns(Arrays.asList("/myServlet"));
return filterRegistrationBean;
}
@Bean
public ServletListenerRegistrationBean myListener(){
return new ServletListenerRegistrationBean<MyListener>(new MyListener());
}
}
重点：使用其他的嵌入式Servlet容器（上面11点有提及怎么配置）
Jetty（长连接），聊天
Undertow(不支持JSP)，非阻塞的，并发性能好
在pom.xml中，spring-boot-starter-web中默认加了spring-boot-starter-tomcat，所以我们要去除他，在加上spring-boot-starter-jetty
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jetty</artifactId>
</dependency>
1) 嵌入式Servlet容器自动配置原理
autoConfigtuar.web.embedded下有个EmbeddedWebServerFactoryCustomizerAutoConfiguration（嵌入式容器工厂的定制器自动配置），其内部是有各种@ConditionalOnClass({Tomcat.class, UpgradeProtocol.class})条件判断，看容器中有哪个容器类类型才生效哪个配置返回一个TomcatWebServerFactoryCustomizer（Tomcat容器的定制器，传入ServerProperties.class）
注意：EmbeddedWebServerFactoryCustomizerAutoConfiguration（嵌入式容器工厂的定制器自动配置）
有@EnableConfigurationProperties({ServerProperties.class})注解，即与映射的配置文件绑定，即主配置文件中可修改
自动配置类中以tomcat为例
@Configuration
@ConditionalOnClass({Tomcat.class, UpgradeProtocol.class})
public static class TomcatWebServerFactoryCustomizerConfiguration {
public TomcatWebServerFactoryCustomizerConfiguration() {}
@Bean
public TomcatWebServerFactoryCustomizer tomcatWebServerFactoryCustomizer(Environment environment, ServerProperties serverProperties) {
// 将定制器返回，下面进入定制器
return new TomcatWebServerFactoryCustomizer(environment, serverProperties);
}
}
2）嵌入式容器启动原理
@SpringBootApplication
public class SpringbootWebApplication {
public static void main(String[] args) {
SpringApplication.run(SpringbootWebApplication.class, args);
}
}
SpringApplication类run方法中
先： context = this.createApplicationContext();创建IOC容器（有其他类型，举例WebApplication应用就创建WebApplication容器，下面有说明）
再this.refreshContext(context)刷新容器(这里就创建嵌入式容器，包括各种bean对象)
refreshContext一直往里走有这个方法，给子容器来实现
this.onRefresh();
// 而这个方法是给子容器实现的
protected void onRefresh() throws BeansException {
}
子容器重写该方法：就会创建嵌入式的Servlet容器
子容器的抽象类下面的实现类，Tomcat是使用SerlvetWebServerApplicaitonContext
总得来说：SpringBoot启动时，根据主程序入口的类类型来创建相应的容器，然后刷新容器refresh()（创建各种bean对象），此时也是创建嵌入式容器的。相关容器的子类实现类中，onRefresh方法实现了（方法中调用this.createWebServer()来创建并返回ServletWebServerFactory，再根据工厂来获取嵌入式容器）
ServletWebServerFactory factory = this.getWebServerFactory(); //内部其实就是从IOC容器中获取这个组件
IOC容器启动的时候会创建嵌入式容器
深入看看创建容器（createApplicationContext），简化
protected ConfigurableApplicationContext createApplicationContext() {
Class<?> contextClass = this.applicationContextClass;
switch (this.webApplicationType) {
case SERVLET:
contextClass = Class.forName("org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext");
break;
case REACTIVE:
contextClass = Class.forName("org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext");
break;
default:
contextClass = Class.forName("org.springframework.context.annotation.AnnotationConfigApplicationContext");
}
}
return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
}
15. 使用外置的Servlet容器
嵌入式简单便捷、优化定制比较复杂，使用定制器或properties等来改变
外置的Serlvlet容器：外面安装Tomcat服务器--应用打包war包打包
- 必须创建war包
- 将嵌入式Tomcat指定为provided
- 必须编写一个ServletInitializer，并调用configure方法
- 启动服务器
外置Servlet容器的启动原理，
jar包：执行Spring主类的main方法，启动IOC容器，过程中创建Servlet容器
war包：启动服务器，服务器启动Springboot应用（ServletInitializer），接着上面的流程
servlet3.0中有个规范：
规则：
- 服务器启动会创建当前web应用里面每一个jar包里面的ServlerConttaininerInitializer实例
- ServlerConttaininerInitializer的实现放在jar包的META-INF/services文件夹下，有个文件内容是指向ServlerConttaininerInitializer的实现类的全限定类名
- 使用注解@handlesTypes，在应用启动的时候加载我们感兴趣的类
流程
1）启动Tomcat
2）按照规则就会去创建jar下的实例，规则1
3）ServlerConttaininerInitializer将注解标注的类创建实例
4）每一个SpringBootServletInitializer就是多出来的ServletInitializer类的父类被创建，然后调用configure方法，其参数是主程序类，内部使用builder创建Spring应用最后run启动了
16. SpringBoot与数据访问
导入依赖
整合基本JDBC，在主配置文件中加入即可，默认使用class com.zaxxer.hikari.HikariDataSource数据源
spring.datasource.username=root spring.datasource.password= spring.datasource.url=jdbc:mysql://localhost:3306/test spring.datasource.driver-class-name=com.mysql.jdbc.Driver
自动配置包下jdbc.DataSourceConfiguration中，默认支持：dbcp2、hikari、tomcat。还可以看到一个属性：spring.datasource.type
17. 整合druid数据源
引入依赖
<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.21</version>
</dependency>
<!-- 德鲁伊依赖log4j我有什么办法 -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
配置数据源具体数值
spring:
datasource:
username: root
password:
url: jdbc:mysql://127.0.0.1:3306/spring?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useAffectedRows=true
driver-class-name: com.mysql.cj.jdbc.Driver
type: com.alibaba.druid.pool.DruidDataSource
maxActive: 20
initialSize: 1
maxWait: 60000
minIdle: 1
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 30000
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
poolPreparedStatements: true
maxOpenPreparedStatements: 20
filters: stat,wall,log4j
因为自己加的druid是第三方数据源，所以要自己配置上去
@Configuration
public class DruidConfig {
@Bean
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource druid() {
return new DruidDataSource();
}
// 配置监控
// 1.配置管理后台的Servlet
// 2.配置一个监控的filter
@Bean
public ServletRegistrationBean statViewServlet(){
ServletRegistrationBean bean = new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*");
Map<String,String> map = new HashMap<>();
map.put("loginUsername", "root");
map.put("loginPassword", "root");
map.put("allwo","");
bean.setInitParameters(map);
return bean;
}
@Bean
public FilterRegistrationBean WebStatFilter(){
FilterRegistrationBean<Filter> bean = new FilterRegistrationBean<>(new WebStatFilter());
Map<String,String> map = new HashMap<>();
map.put("exclusions","*.js,*.css,/druid/*");
bean.setUrlPatterns(Arrays.asList("/*"));
bean.setInitParameters(map);
return bean;
}
}
18. 整合Mybatis
向导开发，自动导入依赖
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.2</version>
</dependency>
搞定数据源Druid，省略
注解版
@Mapper
public interface DepartmentMapper {
@Select("SELECT * FROM department WHERE id=#{id}")
public Department getDeptById(Integer id);
@Delete("DELETE FROM department WHERE id=#{id}")
public int deleteById(Integer id);
@Options(useGeneratedKeys = true,keyProperty = "id")
@Insert("INSERT INTO department (`departmentName`) VALUES (#{departmentName})")
public int insertDept(Department department);
public int updateDept(Department department);
}
@RestController
public class DeptController {
@Autowired
DepartmentMapper departmentMapper;
@GetMapping("/dept/{id}")
public Department getDeptment(@PathVariable("id") Integer id){
return departmentMapper.getDeptById(id);
}
@GetMapping("/dept")
public Department insertDept(Department department){
departmentMapper.insertDept(department);
return department;
}
}
主程序入口
@MapperScan(value = "com.howl.springboot.mapper")
重点配置文件(要在主配置文件中配置)
mybatis: config-location: classpath:mybatis/mybatis-config.xml mapper-locations: classpath:mybatis/mapper/*
19. 最后一点SpringBoot启动原理
- 创建SpringApplication对象
保存主配置类 判断是否web应用 从类路径下找applicationContextInitializer然后保存起来 从类路径下找applicationContextListener然后保存起来 从多个配置类中找到main方法的主配置类
- 运行run方法
获取SpringapplicationRunListeners：从类路径下META-INF下spring.factories 回调所有的获取获取SpringapplicationRunListeners.starting()方法 封装命令行参数 准备环境：IOC环境，eg:profile 创建环境后回调SpringapplicationRunListeners.environmentprepared():表示环境准备完成 创建IOC容器 准备上下文： environment保存到IOC中 而且要执行applyInitalizers()方法（上面创建应用的时候就拿到了所有的Initializer），回调里面全部方法 回调所有的Listeners的contextPrepared(); 回调所有的Listeners的contextLoaded（）方法 刷新容器：IOC容器初始化，加载组件（配置类、@bean）,还有嵌入式容器 从IOC获取所有的ApplicationRunner和CommandRunner
参考来自
https://www.bilibili.com/video/BV1bb411A7bD
正文到此结束
- 本文标签： Document 处理器 db list cache tar final bug UI CTO ACE 定制 Logback 实例 bean servlet REST 长连接 sql build update session CSS 部署 遍历 message 端口 value plugin 开发 springboot jquery Word 编译 druid 空间 Select Service jetty 插件 MQ cat dataSource java HashMap Bootstrap 解析 ActiveMQ tab rand key mapper js dependencies validator 配置 删除 服务器 stream 代码 DOM Property pom SpringMVC Collection 数据库 DBCP spring EnableAutoConfiguration IDE HTML Logging classpath 并发 XML ORM https 参数 Spring Boot 安装 http root Statement RESTful HTML文件 BeanDefinition maven BeanUtils IO find provider mysql 乱码 数据 App Listeners 测试 log4j2 json ioc tomcat mybatis id map lib web JDBC 管理
- 版权声明： 本文为互联网转载文章，出处已在文章中说明(部分除外)。如果侵权，请联系本站长删除，谢谢。
- 本文海报： 生成海报一 生成海报二
热门推荐
相关文章
近期评论
-
5分钟 注册下载 登录 提一个问题，就可以找博主领取5块红包了，很简单
-
-
-
来看看，最近更新了一波，顺着友联过来的，几年过去了，网站越搞越好，厉害
-
哥太牛了
-
是呀，看您的IP显示在美国，还以为您移民了
-
-
-
-
Loading...
![[HBLOG]公众号](https://www.liuhaihua.cn/img/qrcode_gzh.jpg)
