SpringBoot 学习笔记

SpringBoot

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

1.1 环境搭建

拷贝ssm工程：

项目结构如下

1.1.1 jdbc配置

<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配置

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource">property>
bean>


<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配置

<context:component-scan base-package="com.by.service">context:component-scan>

1.1.5 springmvc配置

<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.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    
    <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>

    
    <mvc:annotation-driven conversion-service="cs">mvc:annotation-driven>

    
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        
        <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>
            
            <mvc:mapping path="/**"/>
            
            <mvc:exclude-mapping path="/user/**"/>
            <bean class="com.by.interceptor.LoginInterceptor"/>
        mvc:interceptor>
    mvc:interceptors>
beans>

1.1.6 servlet配置

<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.jspwelcome-file>
welcome-file-list>
<context-param>
    <param-name>contextConfigLocationparam-name>
    <param-value>classpath:applicationContext-*.xmlparam-value>
context-param>
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
listener>


<servlet>
    <servlet-name>springmvcservlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
    <init-param>
        <param-name>contextConfigLocationparam-name>
        <param-value>classpath:springmvc.xmlparam-value>
    init-param>
    <load-on-startup>1load-on-startup>
servlet>
<servlet-mapping>
    <servlet-name>springmvcservlet-name>
    <url-pattern>/url-pattern>
servlet-mapping>


<filter>
    <filter-name>CharacterEncodingFilterfilter-name>
    <filter-class>
        org.springframework.web.filter.CharacterEncodingFilter
    filter-class>
    
    <init-param>
        <param-name>encodingparam-name>
        <param-value>UTF-8param-value>
    init-param>
filter>

<filter-mapping>
    <filter-name>CharacterEncodingFilterfilter-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配置文件中的：

  是一样的。

• 属性：

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

• 示例代码

  /**
   * spring的配置类
   */
  @Configuration
  @ComponentScan(basePackages = "com.by")//等价于
  public class SpringConfiguration{
  }
  

1.2.3 @Bean

• 作用：

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

• 属性：

  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配置文件中的：是一样的。

• 属性：

  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;
  
      @Bean
      public Dog dog(){
          Dog dog = new Dog();
          dog.setNam(nam);
          dog.setAge(age);
          return dog;
      }
  }
  

1.2.5 @Import

• 作用：

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

• 属性：

  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")//等价于 
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容器的key
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
        SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(dataSource);
        return sessionFactoryBean;
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setBasePackage("com.by.mapper");
        mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactoryBean");
        return mapperScannerConfigurer;
    }
}

1.3.3 TxConfig

//开启事务注解的支持
@EnableTransactionManagement//等价于 
public class TxConfig {
    
    @Bean
    public 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"})// 
@EnableWebMvc//等同于
public class SpringMVCConfig implements WebMvcConfigurer {
    //视图解析器
    @Bean
    public ViewResolver viewResolver() {
        InternalResourceViewResolver internalResourceViewResolver = new InternalResourceViewResolver();
        internalResourceViewResolver.setPrefix("/WEB-INF/pages/");
        internalResourceViewResolver.setSuffix(".jsp");
        return internalResourceViewResolver;
    }

//    
    @Bean
    public CommonsMultipartResolver multipartResolver(){
        CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
        multipartResolver.setMaxInMemorySize(5242880);
        multipartResolver.setDefaultEncoding("UTF-8");
        return multipartResolver;
    }


    //配置日期转换器
    @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.addConverter(new DateConverter());
    }

    //    
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor()).excludePathPatterns("/user/**").addPathPatterns("/**");
    }

    //    
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/head/**").addResourceLocations("/head/");
    }
}

1.3.5 SpringMvcConfig

@Configuration
@ComponentScan({"com.by.controller", "com.by.exception"})// 
@EnableWebMvc//等同于
public class SpringMVCConfig implements WebMvcConfigurer {
    //视图解析器
    @Bean
    public ViewResolver viewResolver() {
        InternalResourceViewResolver internalResourceViewResolver = new InternalResourceViewResolver();
        internalResourceViewResolver.setPrefix("/WEB-INF/pages/");
        internalResourceViewResolver.setSuffix(".jsp");
        return internalResourceViewResolver;
    }

//    
    @Bean
    public CommonsMultipartResolver multipartResolver(){
        CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
        multipartResolver.setMaxInMemorySize(5242880);
        multipartResolver.setDefaultEncoding("UTF-8");
        return multipartResolver;
    }


    //配置日期转换器
    @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.addConverter(new DateConverter());
    }

    //    
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor()).excludePathPatterns("/user/**").addPathPatterns("/**");
    }

    //    
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/head/**").addResourceLocations("/head/");
    }
}

1.3.6 WebConfig

public class WebConfig extends AbstractAnnotationConfigDispatcherServletInitializer {

    //加载Spring配置类
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{ServiceConfig.class};
    }

    //加载SpringMVC配置类
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMVCConfig.class};
    }

    //设置SpringMVC请求地址拦截规则
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    //设置post请求中文乱码过滤器

    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter encodingFilter = new CharacterEncodingFilter();
        encodingFilter.setEncoding("UTF-8");
        return new Filter[]{encodingFilter};
    }
}

1.3.7 删除xml配置文件

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

1.3.8 修改web.xml

<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.jspwelcome-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.bootgroupId>
    <artifactId>spring-boot-starter-parentartifactId>
    <version>2.3.2.RELEASEversion>
    <relativePath/> 
parent>

2.2.3.2 设置编码格式

<project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>

2.2.3.3添加启动器

    <dependencies>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        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.bootgroupId>
       <artifactId>spring-boot-starter-parentartifactId>
       <version>2.5.4version>
       <relativePath/> 
   parent>
   

2. 添加启动器

   
   <dependency>
       <groupId>org.springframework.bootgroupId>
       <artifactId>spring-boot-starter-webartifactId>
   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")
    @ResponseBody
    public 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.bootgroupId>
                
                <artifactId>spring-boot-maven-pluginartifactId>
            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>warpackaging>

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

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

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-tomcatartifactId>
            
            <scope>providedscope>
        dependency>

步骤3：设置war包的名字

            <plugin>
                <groupId>org.apache.maven.pluginsgroupId>
                <artifactId>maven-war-pluginartifactId>
                <configuration>
                    <warName>hellowarName>
                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 {
    @Override
    protected 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 {

	@Override
	public 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>错误提示页面-ArithmeticExceptiontitle>
head>
<body>
	出错了，请与管理员联系。。。
	<span th:text="${error}">span>
body>
html>

error2.html

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

3.3 整合ajax全局异常处理

3.3.1 创建全局异常处理器

@ControllerAdvice
public class AjaxGlobalExceptionHandler {
 
 
    /**
     * 处理全局异常
     * @param exception   异常
     * @return Map
     */
    @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启动器

		
		<dependency>
			<groupId>org.springframework.bootgroupId>
			<artifactId>spring-boot-starter-testartifactId>
		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 {

	@Autowired
	private 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 {

	@Autowired
	private UserServiceImpl userServiceImpl;
	
	@Test
	public 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 {
    @Override
    public 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 {
    @Autowired
    private LoginInterceptor loginInterceptor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginInterceptor).addPathPatterns("/user/*").excludePathPatterns("/user/login");
    }
}

7 SpringBoot整合日期转换器

7.1 创建日期转换器

@Component
public class DateConverter implements Converter<String,Date> {
    @Override
    public 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 {
    @Autowired
    private DateConverter dateConverter;

    @Override
    public 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.Driver
    url: jdbc:mysql://127.0.0.1:3307/springboot?characterEncoding=UTF-8
    username: root
    password: 123
    type: 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

 <configuration>
  
    <property name="LOG_HOME" value="${catalina.base:-.}/logs/" />  
       
    <appender name="Stdout" class="ch.qos.logback.core.ConsoleAppender">
         
        <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="RollingFile"  class="ch.qos.logback.core.rolling.RollingFileAppender">   
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            
            <FileNamePattern>${LOG_HOME}/server.%d{yyyy-MM-dd}.logFileNamePattern>   
            <MaxHistory>30MaxHistory>
        rollingPolicy>   
        <layout class="ch.qos.logback.classic.PatternLayout">  
            
            <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>10MBMaxFileSize>
       triggeringPolicy>
    appender>     

    
    <root level="DEBUG">   
        <appender-ref ref="Stdout" />   
        <appender-ref ref="RollingFile" />   
    root> 



  


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。
     */
    @Bean
    public 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。
     */
    @Bean
    public 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进行扫描。

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