springboot学习笔记（二）

最新推荐文章于 2023-07-26 15:33:53 发布

java亮小白1997

最新推荐文章于 2023-07-26 15:33:53 发布

阅读量317

点赞数 2

分类专栏： Spring 文章标签： spring

本文链接：https://blog.csdn.net/javaScript1997/article/details/113201896

版权

Spring 专栏收录该内容

14 篇文章 2 订阅

订阅专栏

第三章

一、日志框架

市面上的日志框架；

JUL、JCL、Jboss-logging、logback、log4j、log4j2、slf4j…

日志门面（日志的抽象层）	日志实现
~~JCL（Jakarta Commons Logging）~~ SLF4j（Simple Logging Facade for Java） ~~jboss-logging~~	Log4j JUL（java.util.logging） Log4j2 Logback

左边选一个门面（抽象层）、右边来选一个实现；

日志门面： SLF4J；

日志实现：Logback；

SpringBoot：底层是Spring框架，Spring框架默认是用JCL；‘

SpringBoot选用 SLF4j和logback；

1.1 SLF4j使用

1.1.1如何在系统中使用SLF4j

以后开发的时候，日志记录方法的调用，不应该来直接调用日志的实现类，而是调用日志抽象层里面的方法；
给系统里面导入slf4j的jar和 logback的实现jar

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelloWorld {
  public static void main(String[] args) {
    Logger logger = LoggerFactory.getLogger(HelloWorld.class);
    logger.info("Hello World");
  }
}

在这里插入图片描述
每一个日志的实现框架都有自己的配置文件。使用slf4j以后，配置文件还是做成日志实现框架自己本身的配置文件；

1.1.2 遗留问题

a（slf4j+logback）: Spring（commons-logging）、Hibernate（jboss-logging）、MyBatis、xxxx
在这里插入图片描述

统一日志记录，即使是别的框架和我一起统一使用slf4j进行输出？
如何让系统中所有的日志都统一到slf4j；

1、将系统中其他日志框架先排除出去；

2、用中间包来替换原有的日志框架；

3、我们导入slf4j其他的实现

1.1.3 SpringBoot日志关系

<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter</artifactId>
</dependency>

SpringBoot使用它来做日志功能：

<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-logging</artifactId>
</dependency>

底层依赖关系
在这里插入图片描述
总结：

1）、SpringBoot底层也是使用slf4j+logback的方式进行日志记录

2）、SpringBoot也把其他的日志都替换成了slf4j；

3）、中间替换包？

@SuppressWarnings("rawtypes")
public abstract class LogFactory {

    static String UNSUPPORTED_OPERATION_IN_JCL_OVER_SLF4J = "http://www.slf4j.org/codes.html#unsupported_operation_in_jcl_over_slf4j";

    static LogFactory logFactory = new SLF4JLogFactory();

在这里插入图片描述
4）、如果我们要引入其他框架？一定要把这个框架的默认日志依赖移除掉？

Spring框架用的是commons-logging；

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-core</artifactId>
	<exclusions>
		<exclusion>
			<groupId>commons-logging</groupId>
			<artifactId>commons-logging</artifactId>
		</exclusion>
	</exclusions>
</dependency>

SpringBoot能自动适配所有的日志，而且底层使用slf4j+logback的方式记录日志，引入其他框架的时候，只需要把这个框架依赖的日志框架排除掉即可；

1.1.4 日志使用

1、默认配置

SpringBoot默认帮我们配置好了日志；

	//记录器
    Logger logger = LoggerFactory.getLogger(getClass());

	@Test
	void contextLoads() {

	    //日志的级别：
        //由高到低 trace<debug<info<warn<error
        //可以调整输出的日志级别；日志就只会在这个级别以后的高级别生效
        logger.trace("这是trace日志");
        logger.debug("这是debug日志");
        //SpringBoot默认给我们使用的是info级别的，没有指定级别的使用流用SpringBoot默认规定
        logger.info("这是info日志");
        logger.warn("这是warn日志");
        logger.error("这是error日志");
    }

 日志输出格式：
		%d表示日期时间，
		%thread表示线程名，
		%-5level：级别从左显示5个字符宽度
		%logger{50} 表示logger名字最长50个字符，否则按照句点分割。 
		%msg：日志消息，
		%n是换行符
    -->
    %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n

SpringBoot修改日志的默认配置

logging.level.cn.tx.springboot=trace;

# 当前项目下生成SpringBoot.log的日志
# 可以指定完整的路径
logging.file.name=E:/spingboot.log

# 在当前磁盘的根路径下 创建spring文件夹和里面的log文件夹;使用spring.log作为默认文件
#logging.file.path=/spring/log

# 在控制台输出的日志的格式
logging.pattern.console=%d{yyyy-MM-dd} [%thread] %-5level %logger{50} - %msg%n

# 指定文件中日志输出的格式
logging.pattern.file=%d{yyyy-MM-dd} === [%thread] === %-5level === %logger{50} === %msg%n

2、指定配置

给类路径下放上每个日志框架自己的配置文件即可；SpringBoot就不使用它默认配置的了
在这里插入图片描述
logback.xml：直接就被日志框架识别了；
logback-spring.xml：日志框架就不直接加载日志的配置项，由SpringBoot解析日志配置，可以使用SpringBoot的高级Profile功能

<layout class="ch.qos.logback.classic.PatternLayout">
     <springProfile name="dev">
         <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] ----> %-5level %logger{50} - %msg%n</pattern>
     </springProfile>
     <springProfile name="!dev">
         <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ==== [%thread] ==== %-5level %logger{50} - %msg%n</pattern>
     </springProfile>
 </layout>

否则报错
加粗样式

3、切换日志框架

可以按照slf4j的日志适配图，进行相关的切换；
slf4j+log4j的方式：

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  <exclusions>
    <exclusion>
      <artifactId>logback-classic</artifactId>
      <groupId>ch.qos.logback</groupId>
    </exclusion>
    <exclusion>
      <artifactId>log4j-over-slf4j</artifactId>
      <groupId>org.slf4j</groupId>
    </exclusion>
  </exclusions>
</dependency>

<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-log4j12</artifactId>
</dependency>

切换为log4j2

  <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <artifactId>spring-boot-starter-logging</artifactId>
                    <groupId>org.springframework.boot</groupId>
                </exclusion>
            </exclusions>
        </dependency>

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

二、web开发

2.1简介

使用SpringBoot：
1）、创建SpringBoot应用，选中我们需要的模块；
2）、SpringBoot已经默认帮我们配置好了，只需要在配置文件中指定少量配置就可以运行起来；
3）、自己编写业务代码；

自动配置原理？
这个场景SpringBoot帮我们配置了什么？能不能修改？能修改哪些配置？能不能扩展？xxx

xxxxAutoConfiguration：帮我们给容器中自动配置组件；
xxxxProperties：配置类来封装配置文件的内容；

2.2 SpringBoot对静态资源的映射规则

protected void addResourceHandlers(ResourceHandlerRegistry registry) {
            super.addResourceHandlers(registry);
            if (!this.resourceProperties.isAddMappings()) {
                logger.debug("Default resource handling disabled");
            } else {
                ServletContext servletContext = this.getServletContext();
                this.addResourceHandler(registry, "/webjars/**", "classpath:/META-INF/resources/webjars/");
                this.addResourceHandler(registry, this.mvcProperties.getStaticPathPattern(), (registration) -> {
                    registration.addResourceLocations(this.resourceProperties.getStaticLocations());
                    if (servletContext != null) {
                        registration.addResourceLocations(new Resource[]{new ServletContextResource(servletContext, "/")});
                    }

                });
            }
        }

1）、所有/webjars/**，都去classpath:/META-INF/resources/webjars/找资源

webjars：以jar包的方式引入静态资源；
链接: webjars
在这里插入图片描述
http://localhost:8081/webjars/jquery/3.5.1/jquery.js

<!--引入jQuery的webjars----在访问的时候只需要写webjars下面资源的名称即可-->
<dependency>
	<groupId>org.webjars</groupId>
	<artifactId>jquery</artifactId>
	<version>3.5.1</version>
</dependency>

2）、访问当前项目的任何资源，（静态资源的文件夹）

“classpath:/META-INF/resource/”，
“classpath:/resource/”，
“classpath:/static/”，
“classpath:/public/”，
“/”：当前项目的根路径

3）、欢迎页：静态资源文件夹下的所有index.html页面，被"/**"映射

@Bean
        public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext, FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
            WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(new TemplateAvailabilityProviders(applicationContext), applicationContext, this.getWelcomePage(), this.mvcProperties.getStaticPathPattern());
            welcomePageHandlerMapping.setInterceptors(this.getInterceptors(mvcConversionService, mvcResourceUrlProvider));
            welcomePageHandlerMapping.setCorsConfigurations(this.getCorsConfigurations());
            return welcomePageHandlerMapping;
        }

4）、所有的 /favicon.ico 都是在静态资源文件下找【图标修改】

三、模板引擎

JSP、Velocity、Freemarker、Thymeleaf
在这里插入图片描述
SpringBoot推荐的Thymeleaf；

语法更简单，功能更强大；

3.1 引入thymeleaf

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-thymeleaf</artifactId>
          	2.1.6
		</dependency>
切换thymeleaf版本
<properties>
		<thymeleaf.version>3.0.9.RELEASE</thymeleaf.version>
		<!-- 布局功能的支持程序  thymeleaf3主程序  layout2以上版本 -->
		<!-- thymeleaf2   layout1-->
		<thymeleaf-layout-dialect.version>2.2.2</thymeleaf-layout-dialect.version>
  </properties>

3.2 Thymeleaf使用

@ConfigurationProperties(prefix = "spring.thymeleaf")
public class ThymeleafProperties {

	private static final Charset DEFAULT_ENCODING = Charset.forName("UTF-8");

	private static final MimeType DEFAULT_CONTENT_TYPE = MimeType.valueOf("text/html");

	public static final String DEFAULT_PREFIX = "classpath:/templates/";

	public static final String DEFAULT_SUFFIX = ".html";

只要我们把HTML页面放在classpath:/templates/，thymeleaf就能自动渲染；

使用步骤：

1、导入thymeleaf的名称空间

<html lang="en" xmlns:th="http://www.thymeleaf.org">

2、使用thymeleaf语法；

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>成功！</h1>
    <!--th:text 将div里面的文本内容设置为 -->
    <div th:text="${hello}">这是显示欢迎信息</div>
</body>
</html>

3、语法规则

1）、th:text；改变当前元素里面的文本内容；

th：任意html属性；来替换原生属性的值
在这里插入图片描述
2）、表达式

Simple expressions:（表达式语法）
    Variable Expressions: ${...}：获取变量值；OGNL；
    		1）、获取对象的属性、调用方法
    		2）、使用内置的基本对象：
    			#ctx : the context object.
    			#vars: the context variables.
                #locale : the context locale.
                #request : (only in Web Contexts) the HttpServletRequest object.
                #response : (only in Web Contexts) the HttpServletResponse object.
                #session : (only in Web Contexts) the HttpSession object.
                #servletContext : (only in Web Contexts) the ServletContext object.
                
                ${session.foo}
            3）、内置的一些工具对象：
#execInfo : information about the template being processed.
#messages : methods for obtaining externalized messages inside variables expressions, in the same way as they would be obtained using #{…} syntax.
#uris : methods for escaping parts of URLs/URIs
#conversions : methods for executing the configured conversion service (if any).
#dates : methods for java.util.Date objects: formatting, component extraction, etc.
#calendars : analogous to #dates , but for java.util.Calendar objects.
#numbers : methods for formatting numeric objects.
#strings : methods for String objects: contains, startsWith, prepending/appending, etc.
#objects : methods for objects in general.
#bools : methods for boolean evaluation.
#arrays : methods for arrays.
#lists : methods for lists.
#sets : methods for sets.
#maps : methods for maps.
#aggregates : methods for creating aggregates on arrays or collections.
#ids : methods for dealing with id attributes that might be repeated (for example, as a result of an iteration).

    Selection Variable Expressions: *{...}：选择表达式：和${}在功能上是一样；
    	补充：配合 th:object="${session.user}：
   <div th:object="${session.user}">
    <p>Name: <span th:text="*{firstName}">Sebastian</span>.</p>
    <p>Surname: <span th:text="*{lastName}">Pepper</span>.</p>
    <p>Nationality: <span th:text="*{nationality}">Saturn</span>.</p>
    </div>
    
    Message Expressions: #{...}：获取国际化内容
    Link URL Expressions: @{...}：定义URL；
    		@{/order/process(execId=${execId},execType='FAST')}
    Fragment Expressions: ~{...}：片段引用表达式
    		<div th:insert="~{commons :: main}">...</div>
    		
Literals（字面量）
      Text literals: 'one text' , 'Another one!' ,…
      Number literals: 0 , 34 , 3.0 , 12.3 ,…
      Boolean literals: true , false
      Null literal: null
      Literal tokens: one , sometext , main ,…
Text operations:（文本操作）
    String concatenation: +
    Literal substitutions: |The name is ${name}|
Arithmetic operations:（数学运算）
    Binary operators: + , - , * , / , %
    Minus sign (unary operator): -
Boolean operations:（布尔运算）
    Binary operators: and , or
    Boolean negation (unary operator): ! , not
Comparisons and equality:（比较运算）
    Comparators: > , < , >= , <= ( gt , lt , ge , le )
    Equality operators: == , != ( eq , ne )
Conditional operators:条件运算（三元运算符）
    If-then: (if) ? (then)
    If-then-else: (if) ? (then) : (else)
    Default: (value) ?: (defaultvalue)
Special tokens:
    No-Operation: _

3.3 SpringMVC自动配置

1.SpringBoot自动配置好了SpringMVC

以下是SpringBoot对SpringMVC的默认：
1.1、自动配置了ViewResolver(视图解析器：根据方法的返回值得到视图对象[View],视图对象决定如何渲染[转发？重定向？])
1.2、ContentNegotiatingViewResolver：组合所有的视图解析器的；
1.3、如何定制：我们可以自己给容器中添加一个视图解析器；自动的将其组合进来；
2.静态资源文件夹路径，webjars;
3.Static静态首页访问
4.favicon.ico
5.自动注册了
5.1转换器：类型转换使用Converter
5.2格式化器Formatter

2.扩展SpringMVC

<mvc:view-controller path="/atguigu" view-name="success" />
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/atguigu"/>
            <bean></bean>
        </mvc:interceptor>
    </mvc:interceptors>

编写一个配置类（Configuration）,是WebMvcConfigurerAdapter类型；不能标注@EnableWebMvc

@Configuration
public class MyMvcConfig implements WebMvcConfigurer {

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        //浏览器发送/hello请求来到success
        registry.addViewController("/atguigu").setViewName("success");
    }
}

3.全面接管SpringMVC

SpringBoot对SpringMVC的自动配置不需要了，所有都是我们自己配置；所有的SpringMVC的自动配置都失效了；
我们需要在配置类中添加@EnableWebMvc即可；
原理：
1、EnableWebMvc将WebMvcConfigurationSupport组件导入进来；
2、导入的WebMvcConfigurationSupport只是SpringMVC最基本的功能；

4.如何修改SpringBoot的默认配置

模式：
1、SpringBoot在自动配置很多组件的时候，先看容器中有没有用户自己配的的(@Bean、@Component)如果有就用用户配置的，如果没有，才自动配置；如果有些组件可以有多个（ViewResolver）将用户配置和自己默认的组合起来；
2、在SpringBoot中会有非常多的xxxConfigurer帮助我们进行扩展配置
3、在SpringBoot中会有很多的xxxCustomizer帮助我们进行扩展配置

四、RestfulCRUD

4.1国际化

1)、编写国际化配置文件，抽取页面需要显示的国际化消息
在这里插入图片描述

2）、SpringBoot自动配置好了管理国际化资源文件的组；
3）、配置文件中，设置spring.messages.basename=i18n.login

4.1.1点击切换国际化

（一）写自己的区域信息类实现LocaleResolver 接口

//可以携带区域信息
public class MyLocaleResolver implements LocaleResolver {
    @Override
    public Locale resolveLocale(HttpServletRequest request) {
        String i = request.getParameter("I");
        Locale locale = Locale.getDefault();
        if (!StringUtils.isEmpty(i)) {
            String[] split = i.split("_");
            locale = new Locale(split[0],split[1]);
        }
        return locale;
    }
    @Override
    public void setLocale(HttpServletRequest request, HttpServletResponse response, Locale locale) {
    }
}

	@Bean
    public LocaleResolver localeResolver(){
        return new MyLocaleResolver();
    }

4.2登录

开发期间模板引擎页面修改以后，要实时生效

1）、禁用模板引擎的暖存；

spring.thymeleaf.cache=false

页面修改完成以后按ctrl+f9,重新编译；

2）、登录错误消息的显示

<p style="color:red" th:text="${msg}" th:if="${not #strings.isEmpty(msg)}"></p>

3）、controller处理

@Controller
public class LoginController {
    @PostMapping(value="/user/login")
    public String login(@RequestParam("username") String username,
                        @RequestParam("password") String password,
                        Map<String,Object> map, HttpSession session){
        if(!StringUtils.isEmpty(username) && "123456".equals(password)){
            //登录成功,为了防止表单重复提交,可以重定向到主页
            session.setAttribute("loginUser",username);
            return "redirect:/main.html";
        }else {
            //登录失败
            map.put("msg","用户名密码错误");
            return "login";
        }
    }
}

此时会发现，直接就可以访问主页面，因此我们需要设置一个拦截器
在这里插入图片描述

4.3CRUD-员工列表

1、抽取公共片段

<div th:fragment="copy">
</div>

2、引入公共片段

<div th:insert="~{footer :: copy}"><div>
~{templatename::selector}:模板名::选择器
~{templatename::fragmentname}:模板名::片段名

3、默认效果：
insert的功能片段在div标签中
如果使用th:insert等属性进行引入，可以不写~{}：
行内写法可以加上：[[~{}]];[(`{})];

三种引入功能片段的th属性：
th:insert:将公共片段整个插入到声明引入的元素中
th:replace：将声明引入的元素替换为公共片段
th:include：将被引入的片段的内容包含进这个标签中
在这里插入图片描述

4.4CRUD-员工添加/编辑/删除

提交的数据格式不对：例如生日、日期；
2021/01/01;2021-01-01;2021.01.01
日期的格式化:SpringMVC将页面提交的值需要转换为指定的类型；
2021-01-01—Date:类型转换,格式化；

默认日期是按照/方式：

# 设置日期格式
spring.mvc.format.date=yyyy-MM-dd

在这里插入图片描述

五、错误处理机制

5.1SpringBoot默认处理机制

1）、返回一个错误的页面
在这里插入图片描述
2)、如果是其他客户端，默认响应一个json数据

5.2原理

1、原理：可以参考ErrorMvcAutoConfiguration；错误处理的自动配置；

给容器中添加以下组件
（1）DefaultErrorAttributes

	//帮我们在页面共享数据
    @Deprecated
    public Map<String, Object> getErrorAttributes(WebRequest webRequest, boolean includeStackTrace) {
        Map<String, Object> errorAttributes = new LinkedHashMap();
        errorAttributes.put("timestamp", new Date());
        this.addStatus(errorAttributes, webRequest);
        this.addErrorDetails(errorAttributes, webRequest, includeStackTrace);
        this.addPath(errorAttributes, webRequest);
        return errorAttributes;
    }

（2）BasicErrorController//处理默认/error请求

@RequestMapping("${server.error.path:${error.path:/error}}")
public class BasicErrorController extends AbstractErrorController {

	@RequestMapping(produces = MediaType.TEXT_HTML_VALUE)//
	public ModelAndView errorHtml(HttpServletRequest request, HttpServletResponse response) {
		HttpStatus status = getStatus(request);
		Map<String, Object> model = Collections
				.unmodifiableMap(getErrorAttributes(request, getErrorAttributeOptions(request, MediaType.TEXT_HTML)));
		response.setStatus(status.value());
		ModelAndView modelAndView = resolveErrorView(request, response, status, model);
		return (modelAndView != null) ? modelAndView : new ModelAndView("error", model);
	}

	@RequestMapping
	public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
		HttpStatus status = getStatus(request);
		if (status == HttpStatus.NO_CONTENT) {
			return new ResponseEntity<>(status);
		}
		Map<String, Object> body = getErrorAttributes(request, getErrorAttributeOptions(request, MediaType.ALL));
		return new ResponseEntity<>(body, status);
	}
}

在这里插入图片描述

（3）ErrorPageCustomizer

@Value("${error.path:/error}")
private String path = "/error";//系统出现错误以后来到error请求进行处理；(web.xml注册的错误页面规则)

在这里插入图片描述
（4）DefaultErrorViewResolver

	@Override
	public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status, Map<String, Object> model) {
		ModelAndView modelAndView = resolve(String.valueOf(status.value()), model);
		if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {
			modelAndView = resolve(SERIES_VIEWS.get(status.series()), model);
		}
		return modelAndView;
	}

	private ModelAndView resolve(String viewName, Map<String, Object> model) {
		//默认SpringBoot可以去找到一个页面？ error/404
		String errorViewName = "error/" + viewName;
		//模版引擎可以解析这个页面就用模版引擎解析
		TemplateAvailabilityProvider provider = this.templateAvailabilityProviders.getProvider(errorViewName,
				this.applicationContext);
		if (provider != null) {
			//模版引擎可用的情况下返回到errorViewName指定的视图地址
			return new ModelAndView(errorViewName, model);
		}
		//模版引擎不可用，就在静态资源文件夹下找errorViewName对应的页面。error/404
		return resolveResource(errorViewName, model);
	}

步骤：
一旦系统出现4xx或者5xx之类的错误；ErrorPageCustomizer就会生效（定制错误的响应规则）；就会来到/error请求；就会被BasicErrorController处理

2、如何定制错误响应

1）、如何定制错误的页面；
（一）有模版引擎的情况下，error/状态码;[将错误页面命令为错误状态码.html 放在模版引起文件里面的error文件夹下]发生此状态码的错误就会来到对于的页面；
（二）可以使用4xx和5xx作为错误页面的文件名来匹配这种类型的错误，精确优先(优先寻找精确的状态码.html);
（三）页面能获取的信息

timestamp:时间戳
status:状态吗
error：错误提示
exception：异常对象
message：异常消息
errors：JSR303数据校验的错误都在这

在这里插入图片描述

在这里插入图片描述
（四）没有模版引擎[模版引擎找不到这个错误页面]静态资源文件夹下找；
（五）以上都没有错误页面，就是默认来到SpringBoot默认的错误提示页面；

2）、如何定制错误的json数据
1、自定义异常处理&返回定制json数据

/**
 *    异常处理器@ControllerAdvice  
 * 客户端浏览器返回的都是json
 */
@ControllerAdvice
public class MyExceptionHandler {

    @ResponseBody
    @ExceptionHandler(UserNotExistException.class)
    public Map<String,Object> handleException(Exception e){

        Map<String,Object> map = new HashMap<>();
        map.put("code","user.notexist");
        map.put("message",e.getMessage());

        return map;
    }
}
//没有自适应

2、转发到/error进行自适应响应效果处理

@ExceptionHandler(UserNotExistException.class)
public String handleException(Exception e, HttpServletRequest request){

    Map<String,Object> map = new HashMap<>();
    //传入自己到状态码 4xx  5xx
    request.setAttribute("javax.servlet.error.status_code",400);
    map.put("code","user.notexist");
    map.put("message",e.getMessage());
    //转发到error页面
    return "forward:/error";
}

在这里插入图片描述
3、将我们的定制数据携带出去：
出现错误以后，会来到/error请求，会被BasicErrorController处理，响应出去可以获取的数据是由getErrorAttributes得到的（是AbstractErrorController[ErrorController]规定的方法）
（一）完全来编写一个ErrorController的实现类【或者是编写AbstractErrorController的子类】,放在容器中；
（二）页面上能用的数据，或者是json返回能用的数据都是通过errorAttributes.getErrorAttributes得到；
容器中DefaultErrorAttributes默认进行数据处理的；

自定义ErrorAttributes

/**
 *  给容器中加入我们自己定义的ErrorAttributes
 */
@Component
public class MyErrorAttributed extends DefaultErrorAttributes {

    @Override
    public Map<String, Object> getErrorAttributes(WebRequest webRequest, ErrorAttributeOptions options) {
        Map<String,Object> map = super.getErrorAttributes(webRequest,options);
        map.put("company","atguigu");

        //我们的异常处理器携带的数据
        Map<String,Object> ext = (Map<String, Object>) webRequest.getAttribute("ext",0);
        map.put("ext",ext);
        return map;
    }
}

最终的效果：响应是自适应的，可以通过定制ErrorAttributes改变需要返回的内容

上一片: springboot学习笔记（一）

java亮小白1997

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
4
评论
springboot学习笔记（二）

第三章一、日志框架市面上的日志框架；JUL、JCL、Jboss-logging、logback、log4j、log4j2、slf4j…日志门面（日志的抽象层）日志实现JCL（Jakarta Commons Logging） SLF4j（Simple Logging Facade for Java） jboss-loggingLog4j JUL（java.util.logging） Log4j2 Logback左边选一个门面（抽象层）、右边来选一个
复制链接

扫一扫