前言：“速成”，顾明司仪，大抵上应该指的是“迅速成功”—那当然不可能了！因为绝大多数的成绩都需要时间的孕育，而时间可不会因为你意志坚定而改变速度，对不对？虽然迅速成功绝对不可能，但是，快速入门，绝对是有可能的？对吧？
快速入门不仅绝对有可能，而且还绝对必要！

对于想要快速入门的朋友，我的建议是 搞定最少必要知识

正文：让我们先从从http协议开始

http协议有两大特性:

1. 基于请求/响应模型
2. 无状态
   所以你只要使用http协议，你就不得不按照它规定的请求/响应来开发web程序。我开始由Http协议的两大特性出发，一点一点搜集，涉猎servlet jsp开发的各个知识点。

如何向服务器发起请求？

1、使用URL（URI）/参数=参数值这样来请求
2、由服务器开发制定请求规则。（你向我请求，当然由我定游戏规则啊！对吧）
3、如何制定规则？@webservlet(“/hello”)
http://localhost:8080/firstservlet/hello 如果请求url是/hello，那么web容器就调用相应的Helloservlet来处理

服务器如何响应请求？

1、先想想你如何捕捉用户的请求再说吧!
2、 web容器如何根据http://image.baidu.com/search/index?tn=baiduimage&ps=1&ct=201326592&lm=-1&cl=2&nc=1&ie=utf-8&word=http%E5%8D%8F%E8%AE%AE%E8%AF%B7%E6%B1%82%E5%9B%BE将http请求，发往servlet的呢？ http请先发往http服务器（比如apache）,apache再将请求转发给tomact（web容器），web容器先创几种常用的对象（httpservletRequest\httpservletresponse\httpservletsession）以上是将http文本（请求头，电脑配置信息）转换成对象。然后，web容器才开始再识别出请求，构造出请求对应的那个servlet实例。使用httpservletresponse响应完成后，web再吧响应传给apache，apache再响应。
3、概念模型了解完成后，代码实现是怎样的？
继承httpservlet 重写doget，dopost方法。

4、web容器是是 如何找到servlet的？
servlet在web.xml 登记过，或者使用了@webservlet()标识符

如何跟踪用户？

SpringBoot

九、扩展默认的SprinMVC功能

1.说明

以前在SpringMVC中通过如下代码实现视图跳转和拦截器

<mvc:view-controller path="/showLogin" view-name="login"/>
<mvc:interceptors>
	<mvc:interceptor>
		<mvc:mapping path="/hello"/>
		<bean class="cn.cz.interceptor.HelloInterceptor"/>
	</mvc:interceptor>
</mvc:intercep

而SpringBoot自动配置默认并没有提供以上功能配置，需要自己扩展，使用WebMvcConfigure接口

2.操作

• 定义一个配置类，实现WebMvcConfigure接口

• 根据需要实现相应的方法

  代码：

  CustomMvcConfig.java

  package cn.cz.config;
  
  import cn.cz.interceptor.MyInterceptor;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
  import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  
  /**
   * 扩展默认的SpringMVC功能
   *
   * @author czzhao2
   * @created 2019年02月16日 16:05:30
   * @lastModified
   * @history
   * 要求：
   * 1.使用Configuration标注为配置类
   * 2.实现WebMvcConfigurer接口
   * 3.根据需要实现相应的方法
   * 注：这个接口中的方法都添加了jdk8中的default方法修饰，不强制实现所有的方法
   * 在SpringBoot1.0中是继承WebMvcConfigurerAdapter类，在SpringBoot2.0中已过时
   */
  @Configuration
  public class CustomMvcConfig implements WebMvcConfigurer{
      //添加ViewController
      @Override
      public void addViewControllers(ViewControllerRegistry registry) {
          //访问showLogin时跳转到login视图
          registry.addViewController("/showLogin").setViewName("login");
      }
  
      //添加Interceptors
      @Override
      public void addInterceptors(InterceptorRegistry registry) {
          registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**").excludePathPatterns("/showLogin");
      }
  }
  

  MyInterceptor.java

  package cn.cz.interceptor;
  
  import org.springframework.web.servlet.HandlerInterceptor;
  import org.springframework.web.servlet.ModelAndView;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  /**
   * 拦截器
   *
   * @author czzhao2
   * @created 2019年02月16日 16:15:02
   * @lastModified
   * @history
   */
  public class MyInterceptor implements HandlerInterceptor{
      @Override
      public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws
              Exception {
          System.out.println("MyInterceptor.preHandle");
          return true;
      }
  
      @Override
      public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView
              modelAndView) throws Exception {
          System.out.println("MyInterceptor.postHandle");
      }
  
      @Override
      public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
  
      }
  }
  

十、全局异常处理

1.简介

当程序出现异常时进行全局处理，SpringBoot默认的异常提示： Whitelabel Error Pag

两种方式：

• 定义错误码页面
• 定义异常通知

2.定义错误码页面

创建 错误状态码.html 页面，放在templates/error目录中，当发生错误时会自动到该目录下查找对应的错误页面。

可以创建如 4xx.html 或 5xx.html 页面，用来通配所有该类型的错误（会先进行精确匹配）

测试代码：

package cn.cz.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * 功能
 *
 * @author czzhao2
 * @created 2019年02月16日 16:29:05
 * @lastModified
 * @history
 */
@Controller
@RequestMapping("exception")
public class ExceptionController {
    @RequestMapping("/test1")
    public String error1(int num){
        int result=10/num;
        return "success";
    }
    @RequestMapping("/test2")
    public  String error2(){
        String str=null;
        str.toString();
        return "success";
    }
}

5xx.html

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>5xx</title>
</head>
<body>
<h2>5xx错误</h2>
<h3>状态码：[[${status}]]</h3>
<h3>错误提示：[[${error}]]</h3>
<h3>异常消息：[[${message}]]</h3>
<h3>时间戳：[[${timestamp}]]</h3>
</body>
</html>

3.定义异常通知

ExceptionAdvice.java

@ControllerAdvice
public class ExceptionAdvice {
    @ExceptionHandler(ArithmeticException.class)
    public String arithmetic(Exception e){
        System.out.println("算术异常："+e.getMessage());
        return "error/5xx";
    }
    @ExceptionHandler(Exception.class)
    public String exception(Exception e){
        System.out.println("发送异常："+e.getMessage());
        return "error/5xx";
    }
}

十一、关于Servlet容器

1.简介:

SpringBoot中默认内置了Servlet容器：Tomcat

• 问题：SpringBoot默认是以jar包的方式启动内置的Servlet容器，没有web.xml文件，如何注册Servlet三大组件：Servlet、Filter、Listener？
• 解决：通过自定义Servlet配置，使用ServletRegistrationBean、FilterRegistrationBean、ListenerRegistrationBean

2.注册Servlet组件

• 定义一个配置类

• 自定义一个方法，用来注册组件

  package cn.cz.config;
  
  import cn.cz.filter.MyFilter;
  import cn.cz.listener.MyListener;
  import cn.cz.servlet.Myservlet;
  import org.springframework.boot.web.servlet.FilterRegistrationBean;
  import org.springframework.boot.web.servlet.ServletListenerRegistrationBean;
  import org.springframework.boot.web.servlet.ServletRegistrationBean;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  
  /**
   * 自定义servlet配置
   *
   * @author czzhao2
   * @created 2019年02月16日 16:45:30
   * @lastModified
   * @history
   */
  @Configuration
  public class CustomServletConfig {
      //注册Servlet
      @Bean
      public ServletRegistrationBean myservlet(){
          ServletRegistrationBean<Myservlet> registrationBean=new ServletRegistrationBean<>();
          registrationBean.setServlet(new Myservlet());
          registrationBean.addUrlMappings("/myServlet");
          return registrationBean;
      }
      //过滤器
      @Bean
      public FilterRegistrationBean myFilter(){
          FilterRegistrationBean<MyFilter> registrationBean=new FilterRegistrationBean<>();
          registrationBean.setFilter(new MyFilter());
          registrationBean.addUrlPatterns("/showLogin","/test1");
          return registrationBean;
      }
      //监听器
      @Bean
     public ServletListenerRegistrationBean myListener(){
          ServletListenerRegistrationBean<MyListener> registrationBean=new ServletListenerRegistrationBean<>();
          registrationBean.setListener(new MyListener());
          return registrationBean;
      }
  
  
  }
  

Myservlet.java

package cn.cz.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * 功能
 *
 * @author czzhao2
 * @created 2019年02月16日 16:43:22
 * @lastModified
 * @history
 */
public class Myservlet extends HttpServlet{
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("Myservlet.doGet");
        doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("Myservlet.doPost");
    }
}

MyFilter.java

package cn.cz.filter;

import javax.servlet.*;
import java.io.IOException;

/**
 * 功能
 *
 * @author czzhao2
 * @created 2019年02月16日 16:51:20
 * @lastModified
 * @history
 */
public class MyFilter implements Filter{
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("MyFilter.doFilter");
        filterChain.doFilter(servletRequest,servletResponse);
    }

    @Override
    public void destroy() {

    }
}

MyListener.java

package cn.cz.listener;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

/**
 * 功能
 *
 * @author czzhao2
 * @created 2019年02月16日 16:56:28
 * @lastModified
 * @history
 */
public class MyListener implements ServletContextListener{
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("MyListener.contextInitialized");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("MyListener.contextDestroyed");
    }
}

3.使用外部的Servlet容器

使用内置Servlet容器：将应用打成可执行的jar包，直接运行

• 优点：简单、方便
• 缺点：不支持JSP、可定制性差

使用外部Servlet容器：将应用打成war包，然后部署到外部的Tomcat

• 优点：支持JSP、可定制性强

步骤：

• 1.创建一个Maven的war工程

  
  

• 有三个变化：

  • <packaging>war</packaging>
    

  • <!--将内置Tomcat的scope配置为provided-->
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-tomcat</artifactId>
    			<scope>provided</scope>
    		</dependency>
    

  • 定义了一个SpringBootServletInitializer的子类

  

  分析：

  package cn.cz;
  
  import org.springframework.boot.builder.SpringApplicationBuilder;
  import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
  
  /**
   * 1.继承ServletInitializer类
   * 2.重写configure（）方法
   * 3.调用SpringApplicationBuilder的sources（）方法，传入springBoot应用的主程序类
   */
  public class ServletInitializer extends SpringBootServletInitializer {
  
  	@Override
  	protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
  		//传入主程序类
  		return application.sources(Springboot05WarApplication.class);
  	}
  
  }
  

• 2.创建web目录

  • 可以自己新建webapp

    

  • 根据idea自动生成

    

    

  
  
  修改路径
  

  apply—>Ok

  

  配置前缀和后缀 ：

  spring.mvc.view.prefix=/WEB-INF/views/
  spring.mvc.view.suffix=.jsp
  

• 下面就可以自己写jsp页面，打包运行或者用内置的tomcat运行！

PS：需要完整版笔记，请评论留下邮箱，我看到后回发给你PDF完整版记录~~~

点击查看分版笔记目录：

【SpringBoot】最新版2019Spring Boot快速入门（速成SpringBoot）——学习笔记版解析【1】
【SpringBoot】最新版2019Spring Boot配置解析,源码解析（速成SpringBoot）——学习笔记版【2】
【SpringBoot】最新版2019Spring Boot之WEB开发——Thymeleaf模板引擎速成（速成SpringBoot）——学习笔记版解析【3】
【SpringBoot】最新版2019Spring Boot之MVC功能，异常处理，servlet容器（速成SpringBoot）——学习笔记版解析【4】
【SpringBoot】最新版2019Spring Boot之连接数据库——JDBC,MyBATIS,分页，MyBatis­Plus（速成SpringBoot）——学习笔记版解析【5】

1.Servlet.service() for servlet [springmvc] in context with path [] threw exception [Request processing failed; nested exception is com.alibaba.fastjson.JSONException] with root cause

java.lang.NumberFormatException

后台报错：

四月 01, 2019 6:46:54 下午 org.apache.catalina.core.StandardWrapperValve invoke
严重: Servlet.service() for servlet [springmvc] in context with path [] threw exception [Request processing failed; nested exception is com.alibaba.fastjson.JSONException] with root cause
java.lang.NumberFormatException
	at java.math.BigDecimal.<init>(Unknown Source)
	at java.math.BigDecimal.<init>(Unknown Source)
	at java.math.BigDecimal.<init>(Unknown Source)
	at com.alibaba.fastjson.util.TypeUtils.castToBigDecimal(TypeUtils.java:194)
	at com.alibaba.fastjson.serializer.BigDecimalCodec.deserialze(BigDecimalCodec.java:80)
	at com.alibaba.fastjson.serializer.BigDecimalCodec.deserialze(BigDecimalCodec.java:59)
	at com.alibaba.fastjson.parser.deserializer.DefaultFieldDeserializer.parseField(DefaultFieldDeserializer.java:71)
	at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.deserialze(JavaBeanDeserializer.java:574)
	at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.parseRest(JavaBeanDeserializer.java:948)
	at com.alibaba.fastjson.parser.deserializer.FastjsonASMDeserializer_3_TbGoods.deserialze(Unknown Source)
	at com.alibaba.fastjson.parser.deserializer.DefaultFieldDeserializer.parseField(DefaultFieldDeserializer.java:62)
	at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.deserialze(JavaBeanDeserializer.java:574)
	at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.parseRest(JavaBeanDeserializer.java:948)
	at com.alibaba.fastjson.parser.deserializer.FastjsonASMDeserializer_1_Goods.deserialze(Unknown Source)
	at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.deserialze(JavaBeanDeserializer.java:184)
	at com.alibaba.fastjson.parser.DefaultJSONParser.parseObject(DefaultJSONParser.java:642)
	at com.alibaba.fastjson.JSON.parseObject(JSON.java:350)
	at com.alibaba.fastjson.JSON.parseObject(JSON.java:318)
	at com.alibaba.fastjson.JSON.parseObject(JSON.java:281)
	at com.alibaba.fastjson.JSON.parseObject(JSON.java:381)
	at com.alibaba.fastjson.JSON.parseObject(JSON.java:463)
	at com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter.read(FastJsonHttpMessageConverter.java:192)
	at org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodArgumentResolver.readWithMessageConverters(AbstractMessageConverterMethodArgumentResolver.java:197)
	at org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor.readWithMessageConverters(RequestResponseBodyMethodProcessor.java:147)
	at org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor.resolveArgument(RequestResponseBodyMethodProcessor.java:125)
	at org.springframework.web.method.support.HandlerMethodArgumentResolverComposite.resolveArgument(HandlerMethodArgumentResolverComposite.java:78)
	at org.springframework.web.method.support.InvocableHandlerMethod.getMethodArgumentValues(InvocableHandlerMethod.java:162)
	at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:129)
	at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:110)
	at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:814)
	at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:737)
	at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:85)
	at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:959)
	at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:893)
	at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:969)
	at org.springframework.web.servlet.FrameworkServlet.doPost(FrameworkServlet.java:871)
	at javax.servlet.http.HttpServlet.service(HttpServlet.java:647)
	at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:845)
	at javax.servlet.http.HttpServlet.service(HttpServlet.java:728)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:305)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:210)
	at org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:51)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:243)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:210)
	at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:317)
	at org.springframework.security.web.access.intercept.FilterSecurityInterceptor.invoke(FilterSecurityInterceptor.java:127)
	at org.springframework.security.web.access.intercept.FilterSecurityInterceptor.doFilter(FilterSecurityInterceptor.java:91)
	at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:331)
	at org.springframework.security.web.access.ExceptionTranslationFilter.doFilter(ExceptionTranslationFilter.java:115)
	at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:331)
	at org.springframework.security.web.session.SessionManagementFilter.doFilter(SessionManagementFilter.java:137)
	at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:331)
	at org.springframework.security.web.authentication.AnonymousAuthenticationFilter.doFilter(AnonymousAuthenticationFilter.java:112)
	at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:331)
	at org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter.doFilter(SecurityContextHolderAwareRequestFilter.java:169)
	at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:331)
	at org.springframework.security.web.savedrequest.RequestCacheAwareFilter.doFilter(RequestCacheAwareFilter.java:63)
	at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:331)
	at org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter.doFilter(AbstractAuthenticationProcessingFilter.java:206)
	at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:331)
	at org.springframework.security.web.authentication.logout.LogoutFilter.doFilter(LogoutFilter.java:121)
	at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:331)
	at org.springframework.security.web.header.HeaderWriterFilter.doFilterInternal(HeaderWriterFilter.java:66)
	at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:107)
	at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:331)
	at org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFilter.doFilterInternal(WebAsyncManagerIntegrationFilter.java:56)
	at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:107)
	at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:331)
	at org.springframework.security.web.context.SecurityContextPersistenceFilter.doFilter(SecurityContextPersistenceFilter.java:106)
	at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:331)
	at org.springframework.security.web.FilterChainProxy.doFilterInternal(FilterChainProxy.java:214)
	at org.springframework.security.web.FilterChainProxy.doFilter(FilterChainProxy.java:177)
	at org.springframework.web.filter.DelegatingFilterProxy.invokeDelegate(DelegatingFilterProxy.java:346)
	at org.springframework.web.filter.DelegatingFilterProxy.doFilter(DelegatingFilterProxy.java:262)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:243)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:210)
	at org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:121)
	at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:107)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:243)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:210)
	at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:222)
	at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:123)
	at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:502)
	at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:171)
	at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:100)
	at org.apache.catalina.valves.AccessLogValve.invoke(AccessLogValve.java:953)
	at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:118)
	at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:408)
	at org.apache.coyote.http11.AbstractHttp11Processor.process(AbstractHttp11Processor.java:1041)
	at org.apache.coyote.AbstractProtocol$AbstractConnectionHandler.process(AbstractProtocol.java:603)
	at org.apache.tomcat.util.net.JIoEndpoint$SocketProcessor.run(JIoEndpoint.java:310)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
	at java.lang.Thread.run(Unknown Source)

前端页面报错：angular.min.js:80 SyntaxError: Unexpected token u in JSON at position 0
    at JSON.parse (<anonymous>)

如果你出现了这个错误那么可能的原因就是你前端页面录入的数据与数据库字段类型不一致导致的，此时你就应该检查你的前端数据和后端数据类型是否一致。

我的自己的问题是因为我在前端页面录入数据时，将一个数字类型的数据写成了字母所以才出现次错误的。

翻过这道山，就有人听到你的故事。
项目（需求）是很好的学习途径，项目（需求）+看书，这样效果才好，注意项目在前面。方向错了的话，容易出问题和狼狈。
择苦则安，择做则乐（闲）。
悟透：所有错误的抉择(所有的挣扎)都是因为没想明白，没领悟透。
接兼职：疯狂接兼职技能才能快速提升。这绝对是当下最最最优秀的决定。勤奋是有回报的。我最开始想象的不正是如此么。
接触：那些不好的东西，不要接触，停不下来的，比如游戏，各种接触都是触发的因素，同理可以应用于学习。
早：任务一定要早点做完，不然越拖心力和耐心会被耗没的，而且由于紧急质量和心情都会不会。
背和用和读：学英语效率最高的办法就是背和用，背些有趣的东西。词根词缀语法是辅助，除非能记住。英语是读记住的。
轻学无用：学生时代学html和之前学英语的感受，轻学无用，不为需求学，不学全面无用。
学校系统学习和自学的区别：在于学校提供系统教育，提供培养方案，而且给你很好的学习环境（有伙伴，有竞争，有资源，有检测），自己不抓紧学习就要废了。本质都是提供一种谋生手段。比如自学计算机，你学不到高数上面去吧。而且给了一种限制或者说自制，把在临界线外的人都拉回去。
学习和游戏的区别的启示：像游戏一样，每次学习完，你告诉自己，你学到了什么，你收获到了什么。是你在游戏中获得了多少道具装备等级场景，这个给你的舒适满足感。问题不是你学了多少，而是你到底学会了多少。
游戏-不想做事-无聊：不是因为想玩游戏而玩游戏，是因为不想做事，无聊才玩游戏，游戏也是无尽的，玩完了这个，你总会再找到另外一个。同理，电影，电视剧，影评也是看不完的。人生不过就那点事，亲情，友情，爱情，奋斗，财富，争斗，心机，脑子，生活。这么久的…应该也体验的差不多了
人生无大事：重在坚持，重在平时。所谓的希望并非是希望，或者说并非是希望的全部，比如词根词缀，语法，再到背，生活，没有人会告诉你这是几分之几的钥匙，这便是有趣的点。所谓的绝望，未必是绝望，比如大四下，很有可能是希望和机遇。
换环境：是个可行的方法，但是我不能什么事情都依靠外物啊，内在觉醒，经历，悟透才是王道，而且，内在不改变，激励不够，换个环境真的有用么。
同，所得：景色不过如此，每日的热搜也不过如此，每日的朋友圈也不过如此，每日的电影也不过如此，每日的游戏(打怪，升级，竞技)也不过如此。重点是，每日，自己到底收获了什么(学到了什么)。所谓的新鲜事真的新鲜吗，那么多年的历史(时间映射和地点映射)还涵盖不了当下么，再稀奇百倍的事情也发生过。
问题：急于求成，膨胀，过分效率，容易放弃，过分追求事情意义：饭要一口一口吃，脑子是个好东西。还有就是老觉得缺了点什么。
趣与换：可以先做简单有趣的，而且这边做累了做烦了可以先去做那边，然后再回来。
光与狠：要么心里有光，要么对自己狠，心里有光的情况少吧，多半是后者，先行者应该都是这么做的吧。
直播和抖音：如果将直播和抖音化为己用，一举多得，那么这个事情就很有意义了吧。
监管：在心智和阅历不够的情况下缺乏监管是相当恐怖的事情（小孩子没有明辨是非能力，易冲动，缺乏监管很容易从恶），事实上，就算心智和阅历很够，缺乏监管同样是很恐怖的事情（贪官贪财，官员渎职）。
图形化记忆：比如插件使用技巧，将各个技巧融入插件图和代码图。
自信：正常状态下突破，自信点获得一点，而在不良状态下突破，获取的自信点应该两点，或者是多点。
约定：初期规则和约定：https://www.bilibili.com/video/av35953030/?p=57。
空闲应该做什么：把之前没来得及做实验的插件都实验一下，文章没有消化的消化一下。兼职，自己项目，
最快最好的学习方式：书和视频一起学习是最好的方式，单看视频做笔记花时间，单看书印象不深刻以及理解不深刻。那些好书是不可或缺的，因为视频里面很多东西也讲不到，比如正在看的几本书。
命名：要给招数起名字，没有名字，没有经过大脑，没有深刻印象，他们永远都不是自己的，找一个自己喜欢印象深刻的名字做对应。
困境：有多少人困在这一层，而生活有趣的是，没有人告诉你需要去突破。（也没有人告诉你要怎么突破）
速成和提升的有效途径：每日目标明确：每日的训练要目标明确，目标明确，可速成，可提升，也是解决困境最好的方式。
调生物钟最简单方法：某一日睡觉不够，然后就会早睡。
六欲，迷茫：人皆有六欲，人皆会迷茫，不必太自责，及时收住就对了，不是看谁不迷，而是看谁能够及时悬崖勒马，事实上，所有的人都会迷，无一例外。及时亡羊补牢。
慌：他们是因为明白这些规律道理，明白事情的发展规律，所以他们一点也不慌，其实慌没用大家都知道。
对等驾驭：厉害的士兵厉害的将领才能驾驭，厉害的员工厉害的老板才能驾驭，厉害的男生厉害的女生才能驾驭，厉害的女生厉害的男生才能驾驭。（人间正道是沧桑：及所有）
生活的真谛：整日饱食终日的玩不是生活的意义，整日疲于奔命的学也不是生活的意义，生活的意义在于在于实力稳步提升，劳逸结合，享受生活。一定要做，一定要学，也一定要玩。每日都要完成一些。每天要玩，但是任务做完了才能玩。
每日清0规律：无论是对学习的劳累，还是对游戏的无趣，还是对生活的感受，每日睡一觉之后就可以清空绝绝绝大部分，只有极极少一部分会留下来。
开始：很多事情开始了就很难停下来，或者要花很久才能停下来，比如游戏，比如娱乐，这并不是我做的不对，而是我做的不够好，这种机制同理也可应用于学习。
多遍：学习视频或者书并不是只看一遍就够了，因为一遍能收获的内容非常有限，当然也可以只看一遍，那就需要好好记忆，多提问，多入脑子。
复利：量变产生质变第一步，博客评论变成了讨论区。可是量还远远不够。用于英语以及技术。英语提升和技术提升就靠这个了。人就是太急于求成，过分追求效率，过分追求事情的意义了，所以导致容易放弃。
主角：每个人都想当主角，每个人也都知道主角的巨大优势，主角能够拥有想要的荣光爱情以及各种资源，但是，各种因素造成，只有极少数人才能做主角。比如L。
修真小说：的确是不可或缺的一环，不论原因，不管因果，迷茫期都是没看修真小说的时期。
自卑自信：回忆大学经历，真的非常不缺nsxh，以及我忽略掉的gzyy，所以对于c，以及scnx的自卑可以去了，是有不足，但是每个人都不是完美的。每个人的潜力无限，自信可以来。总有比你厉害的多的人物，你知道的也很有限，想自负都还不够资格。
理解：能够使用并不代表理解，比如2岁大的宝宝，在这个阶段，宝宝可以正确告诉别人“我是男孩”或“我是女孩”。但是，这只是一种简单的“转述”行为，因为父母告诉他（她）“你是男（女）宝宝”，而尚未形成真正意义上的性别意识。