SpringBoot 学习笔记

SpringBoot

1 SpringBoot 的纯注解配置（了解）

1.1 环境搭建

拷贝ssm工程：

项目结构如下

1.1.1 jdbc配置

<!--引入db.properties-->
<context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
<!--配置数据源-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close"><property name="url" value="${jdbc.url}" /><property name="username" value="${jdbc.username}" /><property name="password" value="${jdbc.password}" /><property name="driverClassName" value="${jdbc.driver}" />
</bean>

1.1.2 mybatis配置

<!--配置sqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="dataSource" ref="dataSource"></property>
</bean><!--配置mybatis要扫描的包，且把mybatis生成的代理类交给spring的IOC容器管理-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"><property name="basePackage" value="com.by.mapper"></property><property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
</bean>

1.1.3 transactional配置

<!--事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"></property>
</bean>
<!--开启事务注解的支持-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

1.1.4 service配置

<!--配置spring要扫描的包-->
<context:component-scan base-package="com.by.service"></context:component-scan>

1.1.5 springmvc配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"xmlns:context="http://www.springframework.org/schema/context"xmlns:mvc="http://www.springframework.org/schema/mvc"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"><!--配置spirngmvc要扫描的包：把controller和方法放容器--><context:component-scan base-package="com.by.controller,com.by.exception"></context:component-scan><!--视图解析器--><bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"><property name="prefix" value="/WEB-INF/pages/"></property><property name="suffix" value=".jsp"></property></bean><!--开启springmvc注解的支持：注册HandlerMapping和HandlerAdaptorconversion-service="cs" 转换名为cs的服务--><mvc:annotation-driven conversion-service="cs"></mvc:annotation-driven><!--配置上传解析器--><bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"><!--单位byte--><property name="maxUploadSize" value="5242880"></property><!--编码格式--><property name="defaultEncoding" value="UTF-8"></property></bean><!--配置静态资源的访问路径和位置--><mvc:resources mapping="/head/**" location="/head/"></mvc:resources><!--配置日期转换器工厂--><bean id="cs" class="org.springframework.context.support.ConversionServiceFactoryBean"><property name="converters"><set><bean class="com.by.converter.DateConverter"></bean></set></property></bean><!--    配置拦截器--><mvc:interceptors><mvc:interceptor><!--mapping  拦截路径/**/--><mvc:mapping path="/**"/><!--不拦截路径 exclude-mapping /user/**--><mvc:exclude-mapping path="/user/**"/><bean class="com.by.interceptor.LoginInterceptor"/></mvc:interceptor></mvc:interceptors>
</beans>

1.1.6 servlet配置

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"version="4.0">
<!--配置监听器：加载application-*.xml-->
<welcome-file-list><welcome-file>login.jsp</welcome-file>
</welcome-file-list>
<context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext-*.xml</param-value>
</context-param>
<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener><!--配置前端控制器：1、接受请求 2、加载springmvc-->
<servlet><servlet-name>springmvc</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:springmvc.xml</param-value></init-param><load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping><servlet-name>springmvc</servlet-name><url-pattern>/</url-pattern>
</servlet-mapping><!-- 过滤器 解决中文乱码问题   -->
<filter><filter-name>CharacterEncodingFilter</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><!-- 设置过滤器中的属性值 --><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param>
</filter>
<!-- 过滤所有请求 -->
<filter-mapping><filter-name>CharacterEncodingFilter</filter-name><url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>

1.1.7 存在的问题

有太多的xml文件需要配置，如果能用注解配置就可以脱离xml文件了

1.2 新注解说明

1.2.1 @Configuration

• 作用：

  用于指定当前类是一个spring配置类，可替换xml配置文件，作用和在spring的xml配置文件是一样的。

• 示例代码

  /*** spring的配置类*/
  @Configuration
  public class SpringConfiguration{
  }
  

1.2.2 @ComponentScan

• 作用：

  用于指定spring在初始化容器时要扫描的包。作用和在spring的xml配置文件中的：

  <context:component-scan base-package="com.by"/>是一样的。

• 属性：

  basePackages：用于指定要扫描的包。和该注解中的value属性作用一样。

• 示例代码

  /*** spring的配置类*/
  @Configuration
  @ComponentScan(basePackages = "com.by")//等价于<context:component-scan>
  public class SpringConfiguration{
  }
  

1.2.3 @Bean

• 作用：

  该注解只能写在方法上，表明使用此方法创建一个对象，并且放入spring容器。作用和在spring的xml配置文件中的：<bean/>是一样的。

• 属性：

  name：给当前@Bean注解方法创建的对象指定一个名称(即bean的id）。

• 示例代码

  public class Dog {private String nam;private Integer age;//set get......
  }    
  

  @Bean
  public Dog dog(){Dog dog = new Dog();dog.setNam("二狗");dog.setAge(18);return dog;
  }
  

1.2.4 @PropertySource

• 作用：

  用于加载*.properties文件中的配置。作用和在spring的xml配置文件中的：<context:property-placeholder location="">是一样的。

• 属性：

  value[]：用于指定properties文件位置。如果是在类路径下，需要写上classpath:

• 示例代码

  #config.properties
  nam=二狗
  age=18
  

  @PropertySource("classpath:config.properties")
  public class SpringConfiguration {@Value("${nam}")private String nam;@Value("${age}")private Integer age;@Beanpublic Dog dog(){Dog dog = new Dog();dog.setNam(nam);dog.setAge(age);return dog;}
  }
  

1.2.5 @Import

• 作用：

  @Import注解是用来导入配置类或者一些需要前置加载的类。作用和在spring的xml配置文件中的：<import resource=""></import>是一样.

• 属性：

  value[]：用于指定其他配置类的字节码。

• 示例代码

  @Configuration
  @ComponentScan(basePackages = "com.by")
  @Import({Configuration_Other.class})
  public class SpringConfiguration {}@PropertySource("classpath:config.properties")
  public class Configuration_Other {}
  

1.3 Spring的纯注解配置

1.3.1 JdbcConfig

@PropertySource("classpath:db.properties")//等价于 <context:property-placeholder 也就是引入配置文件
public class JdbcConfig {//配置数据源@Value("${jdbc.url}")private String url;@Value("${jdbc.username}")private String userName;@Value("${jdbc.password}")private String password;@Value("${jdbc.driver}")private String driver;@Bean(value = "dataSource")//等价于bean标签public DataSource getDataSource(){DruidDataSource dataSource = new DruidDataSource();dataSource.setDriverClassName(driver);dataSource.setUrl(url);dataSource.setUsername(userName);dataSource.setPassword(password);return dataSource;}
}

1.3.2 MybatisConfig

public class MybatisConfig {@Bean//value不赋值，则使用方法名当IOC容器的keypublic SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();sessionFactoryBean.setDataSource(dataSource);return sessionFactoryBean;}@Beanpublic MapperScannerConfigurer mapperScannerConfigurer(){MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();mapperScannerConfigurer.setBasePackage("com.by.mapper");mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactoryBean");return mapperScannerConfigurer;}
}

1.3.3 TxConfig

//开启事务注解的支持
@EnableTransactionManagement//等价于 <tx:annotation-driven
public class TxConfig {@Beanpublic DataSourceTransactionManager dataSourceTransactionManager(DataSource dataSource) {DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();transactionManager.setDataSource(dataSource);return transactionManager;}
}

1.3.4 SpringConfig

@Configuration
@ComponentScan({"com.by.controller", "com.by.exception"})// <!--配置springMVC扫描的包：把controller和方法放容器-->
@EnableWebMvc//等同于<mvc:annotation-driven></mvc:annotation-driven>
public class SpringMVCConfig implements WebMvcConfigurer {//视图解析器@Beanpublic ViewResolver viewResolver() {InternalResourceViewResolver internalResourceViewResolver = new InternalResourceViewResolver();internalResourceViewResolver.setPrefix("/WEB-INF/pages/");internalResourceViewResolver.setSuffix(".jsp");return internalResourceViewResolver;}//    <!--配置上传解析器-->@Beanpublic CommonsMultipartResolver multipartResolver(){CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();multipartResolver.setMaxInMemorySize(5242880);multipartResolver.setDefaultEncoding("UTF-8");return multipartResolver;}//配置日期转换器@Overridepublic void addFormatters(FormatterRegistry registry) {registry.addConverter(new DateConverter());}//    <!--    配置拦截器-->@Overridepublic void addInterceptors(InterceptorRegistry registry) {registry.addInterceptor(new LoginInterceptor()).excludePathPatterns("/user/**").addPathPatterns("/**");}//    <!--配置静态资源的访问路径和位置-->@Overridepublic void addResourceHandlers(ResourceHandlerRegistry registry) {registry.addResourceHandler("/head/**").addResourceLocations("/head/");}
}

1.3.5 SpringMvcConfig

@Configuration
@ComponentScan({"com.by.controller", "com.by.exception"})// <!--配置springMVC扫描的包：把controller和方法放容器-->
@EnableWebMvc//等同于<mvc:annotation-driven></mvc:annotation-driven>
public class SpringMVCConfig implements WebMvcConfigurer {//视图解析器@Beanpublic ViewResolver viewResolver() {InternalResourceViewResolver internalResourceViewResolver = new InternalResourceViewResolver();internalResourceViewResolver.setPrefix("/WEB-INF/pages/");internalResourceViewResolver.setSuffix(".jsp");return internalResourceViewResolver;}//    <!--配置上传解析器-->@Beanpublic CommonsMultipartResolver multipartResolver(){CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();multipartResolver.setMaxInMemorySize(5242880);multipartResolver.setDefaultEncoding("UTF-8");return multipartResolver;}//配置日期转换器@Overridepublic void addFormatters(FormatterRegistry registry) {registry.addConverter(new DateConverter());}//    <!--    配置拦截器-->@Overridepublic void addInterceptors(InterceptorRegistry registry) {registry.addInterceptor(new LoginInterceptor()).excludePathPatterns("/user/**").addPathPatterns("/**");}//    <!--配置静态资源的访问路径和位置-->@Overridepublic void addResourceHandlers(ResourceHandlerRegistry registry) {registry.addResourceHandler("/head/**").addResourceLocations("/head/");}
}

1.3.6 WebConfig

public class WebConfig extends AbstractAnnotationConfigDispatcherServletInitializer {//加载Spring配置类@Overrideprotected Class<?>[] getRootConfigClasses() {return new Class[]{ServiceConfig.class};}//加载SpringMVC配置类@Overrideprotected Class<?>[] getServletConfigClasses() {return new Class[]{SpringMVCConfig.class};}//设置SpringMVC请求地址拦截规则@Overrideprotected String[] getServletMappings() {return new String[]{"/"};}//设置post请求中文乱码过滤器@Overrideprotected Filter[] getServletFilters() {CharacterEncodingFilter encodingFilter = new CharacterEncodingFilter();encodingFilter.setEncoding("UTF-8");return new Filter[]{encodingFilter};}
}

1.3.7 删除xml配置文件

因为已经用注解代替配置文件了，所以可以删除xml配置文件，检测一下是否配置成功

1.3.8 修改web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"version="4.0"><welcome-file-list><welcome-file>login.jsp</welcome-file></welcome-file-list>
</web-app>

1.3.9 测试

删除xml配置文件后仍然正常访问。这样就大大减少了繁琐的xml文件的配置。

2 Spring Boot入门

2.1 Spring Boot的介绍

2.1.1 什么是Spring Boot

Spring Boot是由Pivotal团队提供的全新框架，其中“Boot”的意思就是“引导”，Spring Boot 并不是对 Spring 功能上的增强，而是提供了一种快速开发 Spring应用的方式。

不是对spring功能的增强(spring+springmvc)，而是提供了一种快速开发spring应用的方式(xml—>注解)

2.1.2 Spring Boot 特点

• 零xml配置
• 简化maven配置
• 内嵌tomcat

2.2 构建 Spring Boot 项目

2.2.1 下载SpringBoot项目

1、访问http://start.spring.io/

2、选择构建工具Maven Project、Spring Boot版本以及一些工程基本信息，点击“GENERETE”下载项目压缩包

​ 参考下图所示：

2.2.2 maven构建SpringBoot项目

1、创建maven工程，不要使用骨架

2、填写项目坐标信息

3、设置项目保存位置

2.2.3 pom.xml

参考下载的springboot项目修改pom.xml

2.2.3.1 继承springboot父工程

<parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.3.2.RELEASE</version><relativePath/> <!-- lookup parent from repository -->
</parent>

2.2.3.2 设置编码格式

<!-- 项目源码及编译输出的编码 -->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

2.2.3.3添加启动器

    <dependencies><!--  springboot的web启动器--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency></dependencies>

2.2.3.4 创建启动类

package com.by;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);}
}

2.2.3 SpringBoot 的 Starter

2.2.3.1 Starters命名

• 官方启动器命名：

  • 前缀：spring-boot-starter-
  • 规范：spring-boot-starter-模块名
  • 举例：spring-boot-starter-web、spring-boot-starter-jdbc

• 第三方启动器命名：

  • 后缀：-spring-boot-starter
  • 规范：模块名-spring-boot-starter
  • 举例：mybatis-spring-boot-starter

2.3 Spring Boot入门HelloWorld

2.3.1 pom.xml

1. 继承父工程

    <parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.5.4</version><relativePath/> <!-- lookup parent from repository -->
   </parent>
   

2. 添加启动器

   <!--  springboot的web启动器-->
   <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId>
   </dependency>
   

2.3.2 创建启动类

注意启动类所在的包：必须是controller、service和mapper的上级目录

com/by/SpringBootHelloWorldApp.java

@SpringBootApplication
public class SpringBootHelloWorldApp  {public static void main(String[] args) {//通过反射判断App类上是否添加了@SpringBootApplication注解，若添加则扫描当前类所在的包(即当作启动类)SpringApplication.run(SpringBootHelloWorldApp.class,args);}
}

2.3.3 Controller

@Controller
public class HelloController {@RequestMapping("/hello")@ResponseBodypublic Map hello(){Map<String, Object> map = new HashMap();map.put("msg","你好");return map;}
}

2.4 Spring Boot的全局配置文件

1. application.properties
   server.port=7777
   server.servlet.context-path=/springboot_helloWorld
2. application.yml
   server:
   port: 7777
   servlet:
   context-path: springboot_helloWorld

yml语法：
“.”------->“:回车”
“=”------->“:空格”
空格缩进

2.5 Spring Boot项目的两种发布方式

2.5.1 方式1：通过jar包发布

步骤1：在pom中添加一个SpringBoot的构建的插件

    <build><plugins><plugin><groupId>org.springframework.boot</groupId><!--自动检测项目中的 main 函数--><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build>

步骤2：在maven视图中，选择“package”,在target中会产生xxx.jar包

步骤3：然后在cmd终端发布项目

java -jar xxx.jar

2.5.2 方式2：通过war包发布

步骤1：在pom.xml文件中将jar修改为war

<packaging>war</packaging>

步骤2：设置tomcat启动器依赖范围

maven依赖范围参考：资料/maven依赖作用范围.png

        <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-tomcat</artifactId><!--tomcat启动器依赖范围--><scope>provided</scope></dependency>

步骤3：设置war包的名字

            <plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-war-plugin</artifactId><configuration><warName>hello</warName></configuration></plugin>

步骤4：修改启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;@SpringBootApplication
public class Application extends SpringBootServletInitializer {@Overrideprotected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {return builder.sources(Application.class);}public static void main(String[] args) {SpringApplication.run(Application.class, args);}
}

3 springboot整合全局异常处理器

3.1 自定义错误页面

SpringBoot默认的处理异常的机制：SpringBoot 默认的已经提供了一套处理异常的机制。一旦程序中出现了异常 SpringBoot 会向/error 的 url 发送请求。在 springBoot 中提供了一个叫 BasicErrorController 来处理/error 请求，然后跳转到默认显示异常的页面来展示异常信息

如 果我 们 需 要 将 所 有 的 异 常 同 一 跳 转 到 自 定 义 的 错 误 页 面 ， 需 要 再src/main/resources/

templates 目录下创建 error.html 页面。注意：名称必须叫 error

3.1.1 controller

/*** SpringBoot处理异常方式一：自定义错误页面*/
@Controller
public class DemoController {@RequestMapping("/show")public String showInfo(){String str = null;str.length();return "index";}@RequestMapping("/show2")public String showInfo2(){int a = 10/0;return "index";}
}

3.1.2 错误页面

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>错误提示页面</title>
</head>
<body>出错了，请与管理员联系。。。<span th:text="${error}"></span>
</body>
</html>

3.2 整合非ajax全局异常处理器

3.2.1创建处理器

/*** 通过实现HandlerExceptionResolver接口做全局异常处理*/
@Component
public class GlobalExceptionResolver implements HandlerExceptionResolver {@Overridepublic ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler,Exception ex) {ModelAndView mv = new ModelAndView();//判断不同异常类型，做不同视图跳转if(ex instanceof ArithmeticException){mv.setViewName("error1");}else if(ex instanceof NullPointerException){mv.setViewName("error2");}mv.addObject("error", ex.toString());return mv;}
}

3.2.2 错误页面

error1.html

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>错误提示页面-ArithmeticException</title>
</head>
<body>出错了，请与管理员联系。。。<span th:text="${error}"></span>
</body>
</html>

error2.html

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>错误提示页面-NullPointerException</title>
</head>
<body>出错了，请与管理员联系。。。<span th:text="${error}"></span>
</body>
</html>

3.3 整合ajax全局异常处理

3.3.1 创建全局异常处理器

@ControllerAdvice
public class AjaxGlobalExceptionHandler {/*** 处理全局异常* @param exception   异常* @return Map<String, Object>*/@ResponseBody@ExceptionHandler(value = Exception.class)public Map<String, Object> errorHandler(Exception exception) {Map<String, Object> map = new HashMapMap<>();map.put("status", 500);map.put("msg", exception.getMessage());return map;}
}

4 springboot整合junit

4.1 Junit启动器

		<!--junit启动器 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId></dependency>

4.2 编写业务代码

4.2.1 dao

@Repository
public class UserDaoImpl {public void saveUser(){System.out.println("insert into users.....");}
}

4.2.2 service

@Service
public class UserServiceImpl {@Autowiredprivate UserDaoImpl userDaoImpl;public void addUser(){this.userDaoImpl.saveUser();}
}

4.2.3 app

@SpringBootApplication
public class App {public static void main(String[] args) {SpringApplication.run(App.class, args);}
}

4.3 整合Junit

/***  main方法：*		ApplicationContext ac=new *       			ClassPathXmlApplicationContext("classpath:applicationContext.xml");*  junit与spring整合：*      @RunWith(SpringJUnit4ClassRunner.class)：让junit与spring环境进行整合*   	@Contextconfiguartion("classpath:applicationContext.xml")  */
@RunWith(SpringJUnit4ClassRunner.class) 
@SpringBootTest(classes={App.class})
public class UserServiceTest {@Autowiredprivate UserServiceImpl userServiceImpl;@Testpublic void testAddUser(){this.userServiceImpl.addUser();}
}

5 SpringBoot整合MyBatis

5.1 pom.xml

添加依赖：

spring-boot-starter-web、
mybatis-spring-boot-starter、
mysql-connector-java、
druid、
spring-boot-starter-test

5.2 application.properties

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3307/springboot?characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=123
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

3、App

@SpringBootApplication
@MapperScan("com.by.mapper")
public class App{.......
}

6 SpringBoot整合拦截器

6.1 创建拦截器

@Component
public class LoginInterceptor implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {Object user = request.getSession().getAttribute("user");if (user != null){return true;}response.sendRedirect("/");return false;}
}

6.2 配置拦截器

@Component
public class SpringMvcConfig implements WebMvcConfigurer {@Autowiredprivate LoginInterceptor loginInterceptor;@Overridepublic void addInterceptors(InterceptorRegistry registry) {registry.addInterceptor(loginInterceptor).addPathPatterns("/user/*").excludePathPatterns("/user/login");}
}

7 SpringBoot整合日期转换器

7.1 创建日期转换器

@Component
public class DateConverter implements Converter<String,Date> {@Overridepublic Date convert(String string) {String[] patterns = new String[]{"yyyy-MM-dd","yyyy-MM-dd hh:mm:ss","yyyy/MM/dd","yyyy/MM/dd hh:mm:ss","MM-dd-yyyy","dd-MM-yyyy"};try {return DateUtils.parseDate(string,patterns);} catch (ParseException e) {e.printStackTrace();}return null;}
}

7.2 配置日期转换器

@Component
public class SpringMvcConfig implements WebMvcConfigurer {@Autowiredprivate DateConverter dateConverter;@Overridepublic void addFormatters(FormatterRegistry registry) {registry.addConverter(dateConverter);}
}

8 Spring Boot多环境配置

• Spring Boot多环境配置
• logback日志记录器

Spring Boot的针对不同的环境创建不同的配置文件，

语法结构：application-{profile}.properties

profile:代表的就是一套环境

8.1 需求

application-dev.yml 开发环境 端口8090

application-test.yml 测试环境 端口8091

application-prod.yml 生产环境 端口8092

8.2 运行项目：

在application.yml 中激活指定的配置文件：

#激活指定的配置文件
spring.profiles.active=dev

8.3 单个yml方式

yml支持多文档块的方式：

spring:profiles:active: prod #激活dev环境
---
#开发环境
spring:profiles: dev #环境名称
server:port: 8090 #端口号
---
#开发环境
spring:profiles: test #环境名称
server:port: 8091 #端口号
---
#开发环境
spring:profiles: prod #环境名称
server:port: 8092 #端口号

8.4 多个yml方式

一个application.yml主文件，在主文件里选定要使用的文件，application-dev.yml,application-test.yml,application-prod.yml是不同的环境

application.yml

spring:profiles:active: dev #这里选定的是dev环境，自动匹配application-dev.yml的配置datasource:driver-class-name: com.mysql.jdbc.Driverurl: jdbc:mysql://127.0.0.1:3307/springboot?characterEncoding=UTF-8username: rootpassword: 123type: com.alibaba.druid.pool.DruidDataSource

application-dev.yml，这里指定端口号为8081

server:port: 8081

application-test.yml

server:port: 8082

application-prod.yml

server:port: 8083

9 logback日志记录器

9.1 logback介绍

logback是log4j团队创建的开源日志组件，与log4j类似但是比log4j更强大，是log4j的改良版本。主要优势在于：

a) 更快的实现，logback内核重写过，是的性能有了很大的提升，内存占用也更小。

b) logback-classic对slf4j进行了更好的集成

c) 自动重新加载配置文件，当配置文件修改后，logback-classic能自动重新加载配置文件

d) 配置文件能够处理不同的情况，开发人员在不同的环境下（开发，测试，生产）切换的时候，不需要创建多个

​ 文件，可以通过标签来实现
e) 自动压缩已经打出来的日志文件：RollingFileAppender在产生新文件的时候，会自动压缩已经打印出来的日志

​ 文件。而且这个压缩的过程是一个异步的过程。

9.2 logback.xml

<?xml version="1.0" encoding="UTF-8" ?><configuration>
<!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径-->  <property name="LOG_HOME" value="${catalina.base:-.}/logs/" />  <!-- 控制台输出 -->   <appender name="Stdout" class="ch.qos.logback.core.ConsoleAppender"><!-- 日志输出编码 -->  <layout class="ch.qos.logback.classic.PatternLayout">   <!--日志输出格式：%d表示日期时间，%thread表示线程名，%-5level：级别从左显示5个字符宽度%logger{50} 表示class的全名最长50个字符，否则按照句点分割%msg：日志消息%n是换行符--> <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n   </pattern>   </layout>   </appender>   <!-- 按照每天生成日志文件 -->   <appender name="RollingFile"  class="ch.qos.logback.core.rolling.RollingFileAppender">   <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"><!--日志文件输出的文件名--><FileNamePattern>${LOG_HOME}/server.%d{yyyy-MM-dd}.log</FileNamePattern>   <MaxHistory>30</MaxHistory></rollingPolicy>   <layout class="ch.qos.logback.classic.PatternLayout">  <!--日志输出格式：%d表示日期时间，%thread表示线程名，%-5level：级别从左显示5个字符宽度%logger{50} 表示class的全名最长50个字符，否则按照句点分割%msg：日志消息%n是换行符--> <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n   </pattern>   </layout> <!--日志文件最大的大小--><triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy"><MaxFileSize>10MB</MaxFileSize></triggeringPolicy></appender>     <!-- 日志输出级别 --><root level="DEBUG">   <appender-ref ref="Stdout" />   <appender-ref ref="RollingFile" />   </root> <!--日志异步到数据库 -->  
<!--     <appender name="DB" class="ch.qos.logback.classic.db.DBAppender">日志异步到数据库 <connectionSource class="ch.qos.logback.core.db.DriverManagerConnectionSource">连接池 <dataSource class="com.mchange.v2.c3p0.ComboPooledDataSource"><driverClass>com.mysql.jdbc.Driver</driverClass><url>jdbc:mysql://127.0.0.1:3306/databaseName</url><user>root</user><password>root</password></dataSource></connectionSource></appender> --></configuration>

10 SpringBoot自动配置原理

10.1 @SpringBootApplication

springboot是基于spring的新型的轻量级框架，最厉害的地方当属**自动配置。**那我们就可以根据启动流程和相关原理来看看，如何实现传奇的自动配置

@SpringBootApplication//标注在某个类上，表示这个类是SpringBoot的启动类
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);}
}

从上面代码可以看出，Annotation定义（@SpringBootApplication）和类定义（SpringApplication.run）最为耀眼，所以要揭开SpringBoot的神秘面纱，我们要从这两位开始就可以了。

@SpringBootConfiguration//表示当前类是一个配置类
@EnableAutoConfiguration //开启SpringBoot自动装配功能
@ComponentScan(excludeFilters = {// 扫描路径设置@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),@Filter(type = FilterType.CUSTOM, classes =AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
...
}    

10.2@SpringBootConfiguration注解

包括了@Configuration，配合@Bean代替xml配置文件的形式注入bean：

a）xml配置文件的形式注入bean

<bean id="mockService" class="..MockServiceImpl">
...
</bean>

b）注解配置形式注入bean

@Configuration
public class MockConfiguration{/**任何一个标注了@Bean的方法，其返回值将作为一个bean定义注册到Spring的IoC容器，方法名将默认成该 *bean定义的id。*/@Beanpublic MockService mockService(){return new MockServiceImpl();}
}

10.3 @EnableAutoConfiguration注解

@EnableAutoConfiguration：开启SpringBoot自动装配功能

@AutoConfigurationPackage//controller、service----->IOC容器
@Import(EnableAutoConfigurationImportSelector.class)//自动配置
public @interface EnableAutoConfiguration {
...
}

10.3.1 @AutoConfigurationPackage注解

@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {}

AutoConfigurationPackages.Registrar.class将启动类（@SpringBootApplication标注的类）的所在包及子包里面所有组件扫描到Spring容器；

10.3.2 @Import注解

EnableAutoConfigurationImportSelector读取META-INF/spring.factories的值，将这些值作为配置类加载到IOC容器中，帮助我们进行自动配置工作。

10.4 @ComponentScan

我们可以通过basePackages等属性来细粒度的定制@ComponentScan自动扫描的范围，如果不指定，则默认Spring框架实现会从@ComponentScan所在类的package进行扫描。
括了@Configuration，配合@Bean代替xml配置文件的形式注入bean：

a）xml配置文件的形式注入bean

<bean id="mockService" class="..MockServiceImpl">
...
</bean>

b）注解配置形式注入bean

@Configuration
public class MockConfiguration{/**任何一个标注了@Bean的方法，其返回值将作为一个bean定义注册到Spring的IoC容器，方法名将默认成该 *bean定义的id。*/@Beanpublic MockService mockService(){return new MockServiceImpl();}
}

10.3 @EnableAutoConfiguration注解

@EnableAutoConfiguration：开启SpringBoot自动装配功能

@AutoConfigurationPackage//controller、service----->IOC容器
@Import(EnableAutoConfigurationImportSelector.class)//自动配置
public @interface EnableAutoConfiguration {
...
}

10.3.1 @AutoConfigurationPackage注解

@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {}

AutoConfigurationPackages.Registrar.class将启动类（@SpringBootApplication标注的类）的所在包及子包里面所有组件扫描到Spring容器；

[外链图片转存中…(img-s2HkQKE7-1719491759535)]

10.3.2 @Import注解

[外链图片转存中…(img-JX1QIRRT-1719491759535)]

[外链图片转存中…(img-Dw8I9gU3-1719491759536)]

[外链图片转存中…(img-t5djiSwd-1719491759536)]

EnableAutoConfigurationImportSelector读取META-INF/spring.factories的值，将这些值作为配置类加载到IOC容器中，帮助我们进行自动配置工作。

10.4 @ComponentScan

我们可以通过basePackages等属性来细粒度的定制@ComponentScan自动扫描的范围，如果不指定，则默认Spring框架实现会从@ComponentScan所在类的package进行扫描。

觉得好的话点个赞吧，谢谢啦！