Integer statusCode = (Integer) request
.getAttribute(“javax.servlet.error.status_code”);
/
request.setAttribute(“javax.servlet.error.status_code”,500);
map.put(“code”,”user.notexist”);
map.put(“message”,e.getMessage());
//转发到/error
return “forward:/error”;
} #### 3）、将我们的定制数据携带出去； 出现错误以后，会来到/error 请求，会被 BasicErrorController 处理，响应出去可以获取的数据是由 getErrorAttributes 得到的（是 AbstractErrorController（ErrorController）规定的方法）；
1、完全来编写一个 ErrorController 的实现类【或者是编写 AbstractErrorController 的子类】，放在容器中；
2、页面上能用的数据，或者是 json 返回能用的数据都是通过 errorAttributes.getErrorAttributes 得到；
容器中 DefaultErrorAttributes.getErrorAttributes()；默认进行数据处理的；
自定义 ErrorAttributes
//给容器中加入我们自己定义的ErrorAttributes
@Component
public class MyErrorAttributes extends DefaultErrorAttributes { @Override
public Map getErrorAttributes(RequestAttributes requestAttributes, boolean includeStackTrace) {
Map map = super.getErrorAttributes(requestAttributes, includeStackTrace);
map.put(“company”,”xqc”);
return map;
}
}
最终的效果：响应是自适应的，可以通过定制 ErrorAttributes 改变需要返回的内容，
## 8、配置嵌入式 Servlet 容器 SpringBoot 默认使用 Tomcat 作为嵌入式的 Servlet 容器（Tomact）；
问题？ ### 1）、如何定制和修改 Servlet 容器的相关配置； 方法一、修改和 server 有关的配置（ServerProperties【也是 EmbeddedServletContainerCustomizer】）；
server.port=8081
server.context-path=/crud server.tomcat.uri-encoding=UTF-8 //通用的Servlet容器设置
server.xxx
//Tomcat的设置
server.tomcat.xxx
方法二、编写一个

spring-boot-starter-jetty
org.springframework.boot

Undertow


org.springframework.boot
spring-boot-starter-web


spring-boot-starter-tomcat
org.springframework.boot

spring-boot-starter-undertow
org.springframework.boot

4）、嵌入式 Servlet 容器自动配置原理；

EmbeddedServletContainerAutoConfiguration：嵌入式的 Servlet 容器自动配置？
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnWebApplication
@Import(BeanPostProcessorsRegistrar.class)
//导入BeanPostProcessorsRegistrar：Spring注解版；给容器中导入一些组件
//导入了EmbeddedServletContainerCustomizerBeanPostProcessor：
//后置处理器：bean初始化前后（创建完对象，还没赋值赋值）执行初始化工作
public class EmbeddedServletContainerAutoConfiguration {

@Configuration<br />    @ConditionalOnClass({ Servlet.class, Tomcat.class })//判断当前是否引入了Tomcat依赖；<br />    @ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)//判断当前容器没有用户自己定义EmbeddedServletContainerFactory：嵌入式的Servlet容器工厂；作用：创建嵌入式的Servlet容器<br />    public static class EmbeddedTomcat {

    @Bean<br />        public TomcatEmbeddedServletContainerFactory tomcatEmbeddedServletContainerFactory() {<br />            return new TomcatEmbeddedServletContainerFactory();<br />        }

}

/**<br />     * Nested configuration if Jetty is being used.<br />     */<br />    @Configuration<br />    @ConditionalOnClass({ Servlet.class, Server.class, Loader.class,<br />            WebAppContext.class })<br />    @ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)<br />    public static class EmbeddedJetty {

    @Bean<br />        public JettyEmbeddedServletContainerFactory jettyEmbeddedServletContainerFactory() {<br />            return new JettyEmbeddedServletContainerFactory();<br />        }

}

/**<br />     * Nested configuration if Undertow is being used.<br />     */<br />    @Configuration<br />    @ConditionalOnClass({ Servlet.class, Undertow.class, SslClientAuthMode.class })<br />    @ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)<br />    public static class EmbeddedUndertow {

    @Bean<br />        public UndertowEmbeddedServletContainerFactory undertowEmbeddedServletContainerFactory() {<br />            return new UndertowEmbeddedServletContainerFactory();<br />        }

}<br />1）、EmbeddedServletContainerFactory（嵌入式 Servlet 容器工厂）<br />public interface EmbeddedServletContainerFactory {

//获取嵌入式的Servlet容器
EmbeddedServletContainer getEmbeddedServletContainer(
ServletContextInitializer… initializers);

}

2）、EmbeddedServletContainer：（嵌入式的 Servlet 容器）

3）、以TomcatEmbeddedServletContainerFactory为例
@Override
public EmbeddedServletContainer getEmbeddedServletContainer(
ServletContextInitializer… initializers) {
//创建一个Tomcat
Tomcat tomcat = new Tomcat();

//配置Tomcat的基本环节<br />   File baseDir = (this.baseDirectory != null ? this.baseDirectory<br />         : createTempDir("tomcat"));<br />   tomcat.setBaseDir(baseDir.getAbsolutePath());<br />   Connector connector = new Connector(this.protocol);<br />   tomcat.getService().addConnector(connector);<br />   customizeConnector(connector);<br />   tomcat.setConnector(connector);<br />   tomcat.getHost().setAutoDeploy(false);<br />   configureEngine(tomcat.getEngine());<br />   for (Connector additionalConnector : this.additionalTomcatConnectors) {<br />      tomcat.getService().addConnector(additionalConnector);<br />   }<br />   prepareContext(tomcat.getHost(), initializers);

//将配置好的Tomcat传入进去，返回一个EmbeddedServletContainer；并且启动Tomcat服务器<br />   return getTomcatEmbeddedServletContainer(tomcat);<br />}<br />4）、我们对嵌入式容器的配置修改是怎么生效？<br />ServerProperties、EmbeddedServletContainerCustomizer<br />**EmbeddedServletContainerCustomizer**：定制器帮我们修改了 Servlet 容器的配置？<br />怎么修改的原理？<br />5）、容器中导入了**EmbeddedServletContainerCustomizerBeanPostProcessor**<br />//初始化之前<br />@Override<br />public Object postProcessBeforeInitialization(Object bean, String beanName)<br />      throws BeansException {<br />    //如果当前初始化的是一个ConfigurableEmbeddedServletContainer类型的组件<br />   if (bean instanceof ConfigurableEmbeddedServletContainer) {<br />       //<br />      postProcessBeforeInitialization((ConfigurableEmbeddedServletContainer) bean);<br />   }<br />   return bean;<br />}

private void postProcessBeforeInitialization(
ConfigurableEmbeddedServletContainer bean) {
//获取所有的定制器，调用每一个定制器的customize方法来给Servlet容器进行属性赋值；
for (EmbeddedServletContainerCustomizer customizer : getCustomizers()) {
customizer.customize(bean);
}
}

private Collection getCustomizers() {
if (this.customizers == null) {
// Look up does not include the parent context
this.customizers = new ArrayList(
this.beanFactory
//从容器中获取所有这葛类型的组件：EmbeddedServletContainerCustomizer
//定制Servlet容器，给容器中可以添加一个EmbeddedServletContainerCustomizer类型的组件
.getBeansOfType(EmbeddedServletContainerCustomizer.class,
false, false)
.values());
Collections.sort(this.customizers, AnnotationAwareOrderComparator.INSTANCE);
this.customizers = Collections.unmodifiableList(this.customizers);
}
return this.customizers;
}

ServerProperties也是定制器
步骤：
1）、SpringBoot 根据导入的依赖情况，给容器中添加相应的 EmbeddedServletContainerFactory【TomcatEmbeddedServletContainerFactory】
2）、容器中某个组件要创建对象就会惊动后置处理器；EmbeddedServletContainerCustomizerBeanPostProcessor；
只要是嵌入式的 Servlet 容器工厂，后置处理器就工作；
3）、后置处理器，从容器中获取所有的EmbeddedServletContainerCustomizer，调用定制器的定制方法
###5）、嵌入式 Servlet 容器启动原理；
什么时候创建嵌入式的 Servlet 容器工厂？什么时候获取嵌入式的 Servlet 容器并启动 Tomcat；
获取嵌入式的 Servlet 容器工厂：
1）、SpringBoot 应用启动运行 run 方法
2）、refreshContext(context);SpringBoot 刷新 IOC 容器【创建 IOC 容器对象，并初始化容器，创建容器中的每一个组件】；如果是 web 应用创建AnnotationConfigEmbeddedWebApplicationContext，否则：AnnotationConfigApplicationContext
3）、refresh(context);刷新刚才创建好的 ioc 容器；
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();

  // Tell the subclass to refresh the internal bean factory.<br />      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

  // Prepare the bean factory for use in this context.<br />      prepareBeanFactory(beanFactory);

  try {<br />         // Allows post-processing of the bean factory in context subclasses.<br />         postProcessBeanFactory(beanFactory);

     // Invoke factory processors registered as beans in the context.<br />         invokeBeanFactoryPostProcessors(beanFactory);

     // Register bean processors that intercept bean creation.<br />         registerBeanPostProcessors(beanFactory);

     // Initialize message source for this context.<br />         initMessageSource();

     // Initialize event multicaster for this context.<br />         initApplicationEventMulticaster();

     // Initialize other special beans in specific context subclasses.<br />         onRefresh();

     // Check for listener beans and register them.<br />         registerListeners();

     // Instantiate all remaining (non-lazy-init) singletons.<br />         finishBeanFactoryInitialization(beanFactory);

     // Last step: publish corresponding event.<br />         finishRefresh();<br />      }

  catch (BeansException ex) {<br />         if (logger.isWarnEnabled()) {<br />            logger.warn("Exception encountered during context initialization - " +<br />                  "cancelling refresh attempt: " + ex);<br />         }

     // Destroy already created singletons to avoid dangling resources.<br />         destroyBeans();

     // Reset 'active' flag.<br />         cancelRefresh(ex);

     // Propagate exception to caller.<br />         throw ex;<br />      }

  finally {<br />         // Reset common introspection caches in Spring's core, since we<br />         // might not ever need metadata for singleton beans anymore...<br />         resetCommonCaches();<br />      }<br />   }<br />}<br />4）、 onRefresh(); web 的 ioc 容器重写了 onRefresh 方法<br />5）、webioc 容器会创建嵌入式的 Servlet 容器；**createEmbeddedServletContainer**();<br />**6）、获取嵌入式的 Servlet 容器工厂：**<br />EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();<br />从 ioc 容器中获取 EmbeddedServletContainerFactory 组件；**TomcatEmbeddedServletContainerFactory**创建对象，后置处理器一看是这个对象，就获取所有的定制器来先定制 Servlet 容器的相关配置；<br />7）、**使用容器工厂获取嵌入式的 Servlet 容器**：this.embeddedServletContainer = containerFactory .getEmbeddedServletContainer(getSelfInitializer());<br />8）、嵌入式的 Servlet 容器创建对象并启动 Servlet 容器；<br />**先启动嵌入式的 Servlet 容器，再将 ioc 容器中剩下没有创建出的对象获取出来；**<br />**==IOC 容器启动创建嵌入式的 Servlet 容器==**

9、使用外置的 Servlet 容器

嵌入式 Servlet 容器：应用打成可执行的 jar
优点：简单、便携；
缺点：默认不支持 JSP、优化定制比较复杂（使用定制器【ServerProperties、自定义 EmbeddedServletContainerCustomizer】，自己编写嵌入式 Servlet 容器的创建工厂【EmbeddedServletContainerFactory】）；
外置的 Servlet 容器：外面安装 Tomcat—-应用 war 包的方式打包；

步骤

1）、必须创建一个 war 项目；（利用 idea 创建好目录结构）
2）、将嵌入式的 Tomcat 指定为 provided；

org.springframework.boot
spring-boot-starter-tomcat
provided

3）、必须编写一个SpringBootServletInitializer的子类，并调用 configure 方法
public class ServletInitializer extends SpringBootServletInitializer {

@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
//传入SpringBoot应用的主程序
return application.sources(SpringBoot04WebJspApplication.class);
}

}
4）、启动服务器就可以使用；

原理

jar 包：执行 SpringBoot 主类的 main 方法，启动 ioc 容器，创建嵌入式的 Servlet 容器；
war 包：启动服务器，服务器启动 SpringBoot 应用【SpringBootServletInitializer】，启动 ioc 容器；
servlet3.0（Spring 注解版）：
规则：8.2.4 Shared libraries / runtimes pluggability：
1）、服务器启动（web 应用启动）会创建当前 web 应用里面每一个 jar 包里面 ServletContainerInitializer 实例：
2）、ServletContainerInitializer 的实现放在 jar 包的 META-INF/services 文件夹下，有一个名为 javax.servlet.ServletContainerInitializer 的文件，内容就是 ServletContainerInitializer 的实现类的全类名
3）、还可以使用@HandlesTypes，在应用启动的时候加载我们感兴趣的类；
流程：
1）、启动 Tomcat
2）、服务器启动（web 应用启动）会创建当前 web 应用里面每一个 jar 包里面 ServletContainerInitializer 实例：Spring 的 web 模块里面有这个文件：org.springframework.web.SpringServletContainerInitializer
3）、SpringServletContainerInitializer 将@HandlesTypes(WebApplicationInitializer.class)标注的所有这个类型的类都传入到 onStartup 方法的 Set>；为这些 WebApplicationInitializer 类型的类创建实例；
4）、每一个 WebApplicationInitializer 都调用自己的 onStartup；它的实现只有下边三个

5）、相当于我们的 SpringBootServletInitializer 的类会被创建对象，并执行 onStartup 方法
6）、SpringBootServletInitializer 实例执行 onStartup 的时候会 createRootApplicationContext；创建容器
7）、Spring 的应用就启动并且创建 IOC 容器
==启动 Servlet 容器，再启动 SpringBoot 应用==

六、SpringBoot 与数据访问

1、JDBC

org.springframework.boot
spring-boot-starter-jdbc


mysql
mysql-connector-java
runtime

spring:
datasource:
username: root
password: 123456
url: jdbc:mysql://192.168.15.22:3306/jdbc
driver-class-name: com.mysql.jdbc.Driver
效果：
默认是用 org.apache.tomcat.jdbc.pool.DataSource 作为数据源；
数据源的相关配置都在 DataSourceProperties 里面；
自动配置原理：
org.springframework.boot.autoconfigure.jdbc：
1、参考 DataSourceConfiguration，根据配置创建数据源，默认使用 Tomcat 连接池；可以使用 spring.datasource.type 指定自定义的数据源类型；
2、SpringBoot 默认可以支持；
org.apache.tomcat.jdbc.pool.DataSource、HikariDataSource、BasicDataSource、
3、自定义数据源类型
/*
Generic DataSource configuration.
*/
@ConditionalOnMissingBean(DataSource.class)
@ConditionalOnProperty(name = “spring.datasource.type”)
static class Generic {

@Bean
public DataSource dataSource(DataSourceProperties properties) {
//使用DataSourceBuilder创建数据源，利用反射创建响应type的数据源，并且绑定相关属性
return properties.initializeDataSourceBuilder().build();
}

}
4、DataSourceInitializer：ApplicationListener；
作用：
1）、runSchemaScripts();运行建表语句；
2）、runDataScripts();运行插入数据的 sql 语句；
默认只需要将文件命名为：
schema-.sql、data-.sql
默认规则：schema.sql，schema-all.sql；
可以使用
schema:
- classpath:department.sql
指定位置
5、操作数据库：自动配置了 JdbcTemplate 操作数据库

2、整合 Druid 数据源

导入druid数据源
@Configuration
public class DruidConfig {

@ConfigurationProperties(prefix = "spring.datasource")<br />    @Bean<br />    public DataSource druid(){<br />       return  new DruidDataSource();<br />    }

//配置Druid的监控<br />    //1、配置一个管理后台的Servlet<br />    @Bean<br />    public ServletRegistrationBean statViewServlet(){<br />        ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");<br />        Map<String,String> initParams = new HashMap<>();

    initParams.put("loginUsername","admin");<br />        initParams.put("loginPassword","123456");<br />        initParams.put("allow","");//默认就是允许所有访问<br />        initParams.put("deny","192.168.15.21");

    bean.setInitParameters(initParams);<br />        return bean;<br />    }


//2、配置一个web监控的filter<br />    @Bean<br />    public FilterRegistrationBean webStatFilter(){<br />        FilterRegistrationBean bean = new FilterRegistrationBean();<br />        bean.setFilter(new WebStatFilter());

    Map<String,String> initParams = new HashMap<>();<br />        initParams.put("exclusions","*.js,*.css,/druid/*");

    bean.setInitParameters(initParams);

    bean.setUrlPatterns(Arrays.asList("/*"));

    return  bean;<br />    }<br />}

3、整合 MyBatis

    <dependency><br />            <groupId>org.mybatis.spring.boot</groupId><br />            <artifactId>mybatis-spring-boot-starter</artifactId><br />            <version>1.3.1</version><br />        </dependency><br />![](https://cdn.nlark.com/yuque/0/2021/png/21566525/1620484625708-6d87bfc3-206f-4535-bec5-b69472164626.png#align=left&display=inline&height=252&margin=%5Bobject%20Object%5D&originHeight=252&originWidth=949&status=done&style=none&width=949)

步骤：
1）、配置数据源相关属性（见上一节 Druid）
2）、给数据库建表
3）、创建 JavaBean

4）、注解版

//指定这是一个操作数据库的mapper
@Mapper
public interface DepartmentMapper {

@Select("select * from department where id=#{id}")<br />    public Department getDeptById(Integer id);

@Delete("delete from department where id=#{id}")<br />    public int deleteDeptById(Integer id);

@Options(useGeneratedKeys = true,keyProperty = "id")<br />    @Insert("insert into department(departmentName) values(#{departmentName})")<br />    public int insertDept(Department department);

@Update("update department set departmentName=#{departmentName} where id=#{id}")<br />    public int updateDept(Department department);<br />}<br />问题：<br />自定义 MyBatis 的配置规则；给容器中添加一个 ConfigurationCustomizer；<br />@org.springframework.context.annotation.Configuration<br />public class MyBatisConfig {

@Bean<br />    public ConfigurationCustomizer configurationCustomizer(){<br />        return new ConfigurationCustomizer(){

        @Override<br />            public void customize(Configuration configuration) {<br />                configuration.setMapUnderscoreToCamelCase(true);<br />            }<br />        };<br />    }<br />}<br />使用MapperScan批量扫描所有的Mapper接口；<br />@MapperScan(value = "com.xqc.springboot.mapper")<br />@SpringBootApplication<br />public class SpringBoot06DataMybatisApplication {

public static void main(String[] args) {<br />        SpringApplication.run(SpringBoot06DataMybatisApplication.class, args);<br />    }<br />}

5）、配置文件版

mybatis:
config-location: classpath:mybatis/mybatis-config.xml 指定全局配置文件的位置
mapper-locations: classpath:mybatis/mapper/*.xml 指定sql映射文件的位置
更多使用参照
http://www.mybatis.org/spring-boot-starter/mybatis-spring-boot-autoconfigure/

4、整合 SpringData JPA

1）、SpringData 简介

2）、整合 SpringData JPA

JPA:ORM（Object Relational Mapping）；
1）、编写一个实体类（bean）和数据表进行映射，并且配置好映射关系；
//使用JPA注解配置映射关系
@Entity //告诉JPA这是一个实体类（和数据表映射的类）
@Table(name = “tbl_user”) //@Table来指定和哪个数据表对应;如果省略默认表名就是user；
public class User {

@Id //这是一个主键<br />    @GeneratedValue(strategy = GenerationType.IDENTITY)//自增主键<br />    private Integer id;

@Column(name = "last_name",length = 50) //这是和数据表对应的一个列<br />    private String lastName;<br />    @Column //省略默认列名就是属性名<br />    private String email;<br />2）、编写一个 Dao 接口来操作实体类对应的数据表（Repository）<br />//继承JpaRepository来完成对数据库的操作<br />public interface UserRepository extends JpaRepository<User,Integer> {<br />}<br />3）、基本的配置 JpaProperties<br />spring:<br />  jpa:<br />    hibernate:<br />      #     更新或者创建数据表结构<br />      ddl-auto: update<br />    #    控制台显示SQL<br />    show-sql: true

七、启动配置原理

几个重要的事件回调机制
配置在 META-INF/spring.factories
ApplicationContextInitializer
SpringApplicationRunListener
只需要放在 ioc 容器中
ApplicationRunner
CommandLineRunner
启动流程：

1、创建 SpringApplication 对象

initialize(sources);
private void initialize(Object[] sources) {
//保存主配置类
if (sources != null && sources.length > 0) {
this.sources.addAll(Arrays.asList(sources));
}
//判断当前是否一个web应用
this.webEnvironment = deduceWebEnvironment();
//从类路径下找到META-INF/spring.factories配置的所有ApplicationContextInitializer；然后保存起来
setInitializers((Collection) getSpringFactoriesInstances(
ApplicationContextInitializer.class));
//从类路径下找到ETA-INF/spring.factories配置的所有ApplicationListener
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
//从多个配置类中找到有main方法的主配置类
this.mainApplicationClass = deduceMainApplicationClass();
}

2、运行 run 方法

public ConfigurableApplicationContext run(String… args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
FailureAnalyzers analyzers = null;
configureHeadlessProperty();

//获取SpringApplicationRunListeners；从类路径下META-INF/spring.factories
SpringApplicationRunListeners listeners = getRunListeners(args);
//回调所有的获取SpringApplicationRunListener.starting()方法
listeners.starting();
try {
//封装命令行参数
ApplicationArguments applicationArguments = new DefaultApplicationArguments(
args);
//准备环境
ConfigurableEnvironment environment = prepareEnvironment(listeners,
applicationArguments);
//创建环境完成后回调SpringApplicationRunListener.environmentPrepared()；表示环境准备完成

  Banner printedBanner = printBanner(environment);

   //创建ApplicationContext；决定创建web的ioc还是普通的ioc<br />      context = createApplicationContext();

  analyzers = new FailureAnalyzers(context);<br />       //准备上下文环境;将environment保存到ioc中；而且applyInitializers()；<br />       //applyInitializers()：回调之前保存的所有的ApplicationContextInitializer的initialize方法<br />       //回调所有的SpringApplicationRunListener的contextPrepared()；<br />       //<br />      prepareContext(context, environment, listeners, applicationArguments,<br />            printedBanner);<br />       //prepareContext运行完成以后回调所有的SpringApplicationRunListener的contextLoaded（）；

   //s刷新容器；ioc容器初始化（如果是web应用还会创建嵌入式的Tomcat）；Spring注解版<br />       //扫描，创建，加载所有组件的地方；（配置类，组件，自动配置）<br />      refreshContext(context);<br />       //从ioc容器中获取所有的ApplicationRunner和CommandLineRunner进行回调<br />       //ApplicationRunner先回调，CommandLineRunner再回调<br />      afterRefresh(context, applicationArguments);<br />       //所有的SpringApplicationRunListener回调finished方法<br />      listeners.finished(context, null);<br />      stopWatch.stop();<br />      if (this.logStartupInfo) {<br />         new StartupInfoLogger(this.mainApplicationClass)<br />               .logStarted(getApplicationLog(), stopWatch);<br />      }<br />       //整个SpringBoot应用启动完成以后返回启动的ioc容器；<br />      return context;<br />   }<br />   catch (Throwable ex) {<br />      handleRunFailure(context, listeners, analyzers, ex);<br />      throw new IllegalStateException(ex);<br />   }<br />}

3、事件监听机制

配置在 META-INF/spring.factories
ApplicationContextInitializer
public class HelloApplicationContextInitializer implements ApplicationContextInitializer {
@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
System.out.println(“ApplicationContextInitializer…initialize…”+applicationContext);
}
}
SpringApplicationRunListener
public class HelloSpringApplicationRunListener implements SpringApplicationRunListener {

//必须有的构造器<br />    public HelloSpringApplicationRunListener(SpringApplication application, String[] args){

}

@Override<br />    public void starting() {<br />        System.out.println("SpringApplicationRunListener...starting...");<br />    }

@Override<br />    public void environmentPrepared(ConfigurableEnvironment environment) {<br />        Object o = environment.getSystemProperties().get("os.name");<br />        System.out.println("SpringApplicationRunListener...environmentPrepared.."+o);<br />    }

@Override<br />    public void contextPrepared(ConfigurableApplicationContext context) {<br />        System.out.println("SpringApplicationRunListener...contextPrepared...");<br />    }

@Override<br />    public void contextLoaded(ConfigurableApplicationContext context) {<br />        System.out.println("SpringApplicationRunListener...contextLoaded...");<br />    }

@Override<br />    public void finished(ConfigurableApplicationContext context, Throwable exception) {<br />        System.out.println("SpringApplicationRunListener...finished...");<br />    }<br />}<br />配置（META-INF/spring.factories）<br />org.springframework.context.ApplicationContextInitializer=\<br />com.xqc.springboot.listener.HelloApplicationContextInitializer

org.springframework.boot.SpringApplicationRunListener=\
com.xqc.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));
}
}

监视器 Actuator

是 spring 启动框架中的重要功能之一。Spring boot 监视器可帮助您访问生产环境中正在运行的应用程序的当前状态。有几个指标必须在生产环境中进行检查和监控。即使一些外部应用程序可能正在使用这些服务来向相关人员触发警报消息。监视器模块公开了一组可直接作为 HTTP URL 访问的 REST 端点来检查状态。

SpringBoot 打成 jar 和普通的 jar 有什么区别？

Spring Boot 项目最终打包成的 jar 是可执行 jar ，这种 jar 可以直接通过java -jar xxx.jar命令来运行，这种 jar 不可以作为普通的 jar 被其他项目依赖，即使依赖了也无法使用其中的类。
Spring Boot 的 jar 无法被其他项目依赖，主要还是他和普通 jar 的结构不同。普通的 jar 包，解压后直接就是包名，包里就是我们的代码，而 Spring Boot 打包成的可执行 jar 解压后，在 \BOOT-INF\classes目录下才是我们的代码，因此无法被直接引用。如果非要引用，可以在 pom.xml 文件中增加配置，将 Spring Boot 项目打包成两个 jar ，一个可执行，一个可引用。

跨域问题：

跨域可以在前端通过 JSONP 来解决，但是 JSONP 只可以发送 GET 请求，无法发送其他类型的请求，在 RESTful 风格的应用中，就显得非常鸡肋，因此推荐在后端通过（CORS，Cross-origin resource sharing）来解决跨域问题。这种解决方案并非 Spring Boot 特有的，在传统的 SSM 框架中，就可以通过 CORS 来解决跨域问题，只不过之前我们是在 XML 文件中配置 CORS，现在可以通过实现 WebMvcConfigurer 接口然后重写 addCorsMappings 方法解决跨域问题。
@Configuration
public class CorsConfig implements WebMvcConfigurer {

@Override<br />    public void addCorsMappings(CorsRegistry registry) {<br />        registry.addMapping("/**")<br />                .allowedOrigins("*")<br />                .allowCredentials(true)<br />                .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")<br />                .maxAge(3600);<br />    }<br />}<br />项目中前后端分离部署，所以需要解决跨域的问题。

十：安全

CSRF 代表跨站请求伪造。这是一种攻击，迫使最终用户在当前通过身份验证的 Web 应用程序上执行不需要的操作。CSRF 攻击专门针对状态改变请求，而不是数据窃取，因为攻击者无法查看对伪造请求的响应。