SpringBoot 学习笔记-EW帮帮网

文章目录

SpringBoot
1 SpringBoot 的纯注解配置（了解）
- 1.1 环境搭建
- 1.2 新注解说明
- 1.3 Spring的纯注解配置
2 Spring Boot入门
- 2.1 Spring Boot的介绍
- - 2.1.1 什么是Spring Boot
  - 2.1.2 Spring Boot 特点
- 2.2 构建 Spring Boot 项目
- 2.3 Spring Boot入门HelloWorld
- 2.4 Spring Boot的全局配置文件
- 2.5 Spring Boot项目的两种发布方式
- - 2.5.1 方式1：通过jar包发布
  - 2.5.2 方式2：通过war包发布
3 springboot整合全局异常处理器
- 3.1 自定义错误页面
- - 3.1.1 controller
  - 3.1.2 错误页面
- 3.2 整合非ajax全局异常处理器
- - 3.2.1创建处理器
  - 3.2.2 错误页面
- 3.3 整合ajax全局异常处理
- - 3.3.1 创建全局异常处理器
4 springboot整合junit
- 4.1 Junit启动器
- 4.2 编写业务代码
- 4.3 整合Junit
5 SpringBoot整合MyBatis
- 5.1 pom.xml
- 5.2 application.properties
- 3、App
6 SpringBoot整合拦截器
- 6.1 创建拦截器
- 6.2 配置拦截器
7 SpringBoot整合日期转换器
- 7.1 创建日期转换器
- 7.2 配置日期转换器
8 Spring Boot多环境配置
- 8.1 需求
- 8.2 运行项目：
- 8.3 单个yml方式
- 8.4 多个yml方式
9 logback日志记录器
- 9.1 logback介绍
- 9.2 logback.xml
10 SpringBoot自动配置原理
- 10.1 @SpringBootApplication
- 10.2@SpringBootConfiguration注解
- 10.3 @EnableAutoConfiguration注解
- - 10.3.1 @AutoConfigurationPackage注解
- 10.3.2 @Import注解
- 10.4 @ComponentScan
- 10.3 @EnableAutoConfiguration注解
- - 10.3.1 @AutoConfigurationPackage注解
- 10.3.2 @Import注解
- 10.4 @ComponentScan

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

    <!--配置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和HandlerAdaptor
    conversion-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;

    @Bean
    public 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容器的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//等价于 <tx:annotation-driven
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"})// <!--配置springMVC扫描的包：把controller和方法放容器-->
@EnableWebMvc//等同于<mvc:annotation-driven></mvc:annotation-driven>
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"})// <!--配置springMVC扫描的包：把controller和方法放容器-->
@EnableWebMvc//等同于<mvc:annotation-driven></mvc:annotation-driven>
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

<?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工程，不要使用骨架

58729390833

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

继承父工程

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

添加启动器

<!--  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")
    @ResponseBody
    public Map hello(){
        Map<String, Object> map = new HashMap();
        map.put("msg","你好");
        return map;
    }
}

2.4 Spring Boot的全局配置文件

application.properties
server.port=7777
server.servlet.context-path=/springboot_helloWorld
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 {
    @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>错误提示页面-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 {

	@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

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

觉得好的话点个赞吧，谢谢啦！
在这里插入图片描述