import org.springframework.util.DigestUtils;

String md5Password = DigestUtils.md5DigestAsHex(user.getPassword().getBytes());

import org.springframework.util.DigestUtils;
 String pws = DigestUtils.md5DigestAsHex("abd".getBytes());
 System.out.println(pws); 
 //4911e516e5aa21d327512e0c8b197616

 // 手动加盐 salt
String s = RandomStringUtils.randomAlphanumeric(10);
String pw = "123"+s;
String s1 = DigestUtils.md5DigestAsHex(pw.getBytes());
System.out.println(s1); 
 // 1.caf48c8d204092e86a290f3f4ad8fcf6  	  2.8e14ee50f31636231fe59002da0ec648

import com.heima.utils.common.BCrypt;
String gensalt = BCrypt.gensalt();//这个是盐  29个字符，随机生成
System.out.println(gensalt); //1.$2a$10$Pi.o0Qs2v3tcCsHkD9Kgb. 2.$2a$10$Q3Og2gyFbdfWvStJTfCdtu
//密码是123456
String password = BCrypt.hashpw("123456", gensalt);  //根据盐对密码进行加密
System.out.println(password);//加密后的字符串前29位就是盐 //$2a$10$Pi.o0Qs2v3tcCsHkD9Kgb.AYaNt/yg6Y8KsAsz79s1KrUwhh8w/0u 2.$2a$10$Q3Og2gyFbdfWvStJTfCdtuOc572y/TlXFvzWiVcYRJJfnpQ5W23L.

/**
   * plaintext: 自己输入的密码
   * hashed: 通过密码加密产生的密文
   * 通过为true，不通过为false
*/
boolean checkpw = BCrypt.checkpw("123456", "$2a$10$abRa2gRztbu9dPKBY/nBXOTUP7i0gmzz6qLmiuIYb2LHUU2CsofXa");
System.out.println(checkpw); //true

import org.springframework.util.AntPathMatcher;
//路径匹配器，支持通配符
public static final AntPathMatcher PATH_MATCHER = new AntPathMatcher();

// 无参构造，默认以 "/" 作为路径分隔符
AntPathMatcher antPathMatcher = new AntPathMatcher();
// 也可以指定路径分隔符
antPathMatcher = new AntPathMatcher("-");

AntPathMatcher antPathMatcher = new AntPathMatcher();
Map<String, String> map = antPathMatcher.extractUriTemplateVariables("/root/{a}/{b}/{c}/{d}.html", "/root/aa/bb/cc/xyz.html");
map.forEach((k, v) -> System.out.println(k + "=" + v));

a=aa
b=bb
c=cc
d=xyz

AntPathMatcher antPathMatcher = new AntPathMatcher();
Map<String, String> map = antPathMatcher.extractUriTemplateVariables("/root/{a}/{b}/{c}", "/root/aa/bb/cc/xyz.html");
map.forEach((k, v) -> System.out.println(k + "=" + v));

Exception in thread "main" java.lang.IllegalStateException: Pattern "/root/{a}/{b}/{c}" is not a match for "/root/aa/bb/cc/xyz.html"
	at org.springframework.util.AntPathMatcher.extractUriTemplateVariables(AntPathMatcher.java:517)
	at com.example.springbootdemo.MainApplication.main(MainApplication.java:17)

 AntPathMatcher antPathMatcher = new AntPathMatcher();
 boolean isPattern = antPathMatcher.isPattern("/aa/bb/cc/xyz.html");
 System.out.println(isPattern);

 AntPathMatcher antPathMatcher = new AntPathMatcher();
 boolean isPattern = antPathMatcher.isPattern("/aa/*/cc/xyz.html");
 System.out.println(isPattern);

 AntPathMatcher antPathMatcher = new AntPathMatcher();
 boolean isPattern = antPathMatcher.isPattern("/aa/**/xyz.html");
 System.out.println(isPattern);

AntPathMatcher antPathMatcher = new AntPathMatcher();
 boolean isPattern = antPathMatcher.isPattern("/aa/?/xyz.html");
 System.out.println(isPattern);

 AntPathMatcher antPathMatcher = new AntPathMatcher();
 boolean isPattern = antPathMatcher.isPattern("/aa/{qwer}/xyz.html");
 System.out.println(isPattern);

 AntPathMatcher antPathMatcher = new AntPathMatcher();
 // 输出：true
 System.out.println(antPathMatcher.match("/jd/a?c", "/jd/abc"));
 // 输出：false
 System.out.println(antPathMatcher.match("/jd/a?c", "/jd/ac"));
 // 输出：false
 System.out.println(antPathMatcher.match("/jd/a?c", "/jd/axyzc"));

 AntPathMatcher antPathMatcher = new AntPathMatcher();
 // 输出：true
 System.out.println(antPathMatcher.match("/jd/a*c", "/jd/ac"));
 // 输出：true
 System.out.println(antPathMatcher.match("/jd/a*c", "/jd/abc"));
 // 输出：true
 System.out.println(antPathMatcher.match("/jd/a*c", "/jd/axyzc"));
 // 输出：false
 System.out.println(antPathMatcher.match("/jd/a*c", "/jd/a"));
 // 输出：false
 System.out.println(antPathMatcher.match("/jd/a*c", "/jd/xc"));
 // 输出：false
 System.out.println(antPathMatcher.match("/jd/a*c", "/jk/ac"));

 AntPathMatcher antPathMatcher = new AntPathMatcher();
 //true
 //false
 //false
 System.out.println(antPathMatcher.match("**", ""));
 System.out.println(antPathMatcher.match("**", "/"));
 System.out.println(antPathMatcher.match("**", ""));

 //false
 //true
 //true
 System.out.println(antPathMatcher.match("/**", ""));
 System.out.println(antPathMatcher.match("/**", "/"));
 System.out.println(antPathMatcher.match("/**", ""));

 //true
 //false
 //false
 System.out.println(antPathMatcher.match("**/", ""));
 System.out.println(antPathMatcher.match("**/", "/"));
 System.out.println(antPathMatcher.match("**/", ""));

 //false
 //true
 //true
 System.out.println(antPathMatcher.match("/**/", ""));
 System.out.println(antPathMatcher.match("/**/", "/"));
 System.out.println(antPathMatcher.match("/**/", ""));

 //true
 //true
 //true
 //true
 //false
 //false
 System.out.println(antPathMatcher.match("/**/abc.html", "/abc.html"));
 System.out.println(antPathMatcher.match("/**/abc.html", "//abc.html"));
 System.out.println(antPathMatcher.match("/**/abc.html", "/1/2/3/4/5/abc.html"));
 System.out.println(antPathMatcher.match("/**/abc.html", "/a/b/c//jd/ac/abc.html"));
 System.out.println(antPathMatcher.match("/**/abc.html", "/a/abc"));
 System.out.println(antPathMatcher.match("/**/abc.html", "/a/bc.html"));

 AntPathMatcher antPathMatcher = new AntPathMatcher();
 //true
 //false
 //false
 System.out.println(antPathMatcher.match("a/{b}/c", "a/b0/c"));
 System.out.println(antPathMatcher.match("a/{b}/c", "a/b1/b2/b3/c"));
 System.out.println(antPathMatcher.match("a/{b}", "a/b1/b2/b3/c"));

 AntPathMatcher antPathMatcher = new AntPathMatcher();
 //false
 //true
 //true
 System.out.println(antPathMatcher.matchStart("a/{b}", "a/b0/c"));
 System.out.println(antPathMatcher.matchStart("a/{b}/c", "a/b0/c"));
 System.out.println(antPathMatcher.matchStart("a/{b}/c/d", "a/b0/c"));

 //false
 //true
 //true
 System.out.println(antPathMatcher.matchStart("a/?", "a/b/c"));
 System.out.println(antPathMatcher.matchStart("a/?/c", "a/b/c"));
 System.out.println(antPathMatcher.matchStart("a/?/c/d", "a/b/c"));

 //false
 //true
 //true
 System.out.println(antPathMatcher.matchStart("a/*", "a/b0/c"));
 System.out.println(antPathMatcher.matchStart("a/*/c", "a/b0/c"));
 System.out.println(antPathMatcher.matchStart("a/*/c/d", "a/b0/c"));

 //true
 //true
 //true
 System.out.println(antPathMatcher.matchStart("a/**", "a/b0/c"));
 System.out.println(antPathMatcher.matchStart("a/**/c", "a/b0/c"));
 System.out.println(antPathMatcher.matchStart("a/**/c/d", "a/b0/c"));

mybatis-plus:
  configuration:
    #在映射实体或者属性时，将数据库中表名和字段名中的下划线去掉，按照驼峰命名法映射
    #例如：user_name--> userName
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  global-config:
    db-config:
      #递增
      id-type: auto
       #雪花算法
#      id-type: ASSIGN_ID

//定义全局异常处理方法
@ControllerAdvice(annotations = {RestController.class,Controller.class})
@ResponseBody
@Slf4j
public class GlobalExceptionHandler {
    @ExceptionHandler(SQLIntegrityConstraintViolationException.class)
    public R<String> exceptionHandler(SQLIntegrityConstraintViolationException ex){
        if(ex.getMessage().contains("Duplicate entry")){
            String[] split = ex.getMessage().split(" ");
            String msg = split[2] + "已存在" ;
            return R.error(msg);
        }
        return R.error("未知错误");
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface ControllerAdvice {

	@AliasFor("basePackages")
	String[] value() default {};

	@AliasFor("value")
	String[] basePackages() default {};

	Class<?>[] basePackageClasses() default {};

	Class<?>[] assignableTypes() default {};

	Class<? extends Annotation>[] annotations() default {};

}

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(IllegalArgumentException.class)
    public ModelAndView handleException(IllegalArgumentException e){
        ModelAndView modelAndView = new ModelAndView("error");
        modelAndView.addObject("errorMessage", "参数不符合规范!");
        return modelAndView;
    }
}

@ControllerAdvice
public class CustomExceptionHandler {
    @ExceptionHandler(MaxUploadSizeExceededException.class)
    public void uploadException(MaxUploadSizeExceededException e, HttpServletResponse resp) throws IOException {
        resp.setContentType("text/html;charset=utf-8");
        System.out.println(1111);
        PrintWriter out = resp.getWriter();
        out.write("上传文件大小超出限制!");
        out.flush();
        out.close();
    }
}

@ControllerAdvice
public class CustomExceptionHandler {
    @ExceptionHandler(MaxUploadSizeExceededException.class)
    public ModelAndView uploadException(MaxUploadSizeExceededException e) throws IOException {
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg", "上传文件大小超出限制! ");
        mv.setViewName("error");
        return mv;
    }
}

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title></head>
<body>
<div th:text="${msg}"></div>
</body>
</html>

/**
 * Annotation that binds a method parameter or method return value
 * to a named model attribute, exposed to a web view. Supported
 * for controller classes with {@link RequestMapping @RequestMapping}
 * methods.
 * 此注解用于绑定一个方法参数或者返回值到一个被命名的model属性中，暴露给web视图。支持在
 * 在Controller类中注有@RequestMapping的方法使用（这里有点拗口，不过结合下面的使用介绍
 * 你就会明白的)
 */
@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ModelAttribute {

	@AliasFor("name")
	String value() default "";

	@AliasFor("value")
	String name() default "";

	boolean binding() default true;

}

/**
 * Annotation that identifies methods which initialize the
 * {@link org.springframework.web.bind.WebDataBinder} which
 * will be used for populating command and form object arguments
 * of annotated handler methods.
 * 粗略翻译：此注解用于标记那些 (初始化[用于组装命令和表单对象参数的]WebDataBinder)的方法。
 * 原谅我的英语水平，翻译起来太拗口了，从句太多就用‘()、[]’分割一下便于阅读
 *
 * Init-binder methods must not have a return value; they are usually
 * declared as {@code void}.
 * 粗略翻译：初始化绑定的方法禁止有返回值，他们通常声明为 'void'
 *
 * <p>Typical arguments are {@link org.springframework.web.bind.WebDataBinder}
 * in combination with {@link org.springframework.web.context.request.WebRequest}
 * or {@link java.util.Locale}, allowing to register context-specific editors.
 * 粗略翻译：典型的参数是`WebDataBinder`，结合`WebRequest`或`Locale`使用，允许注册特定于上下文的编辑 
 * 器。
 * 
 * 总结如下：
 *  1. @InitBinder 标识的方法的参数通常是 WebDataBinder。
 *  2. @InitBinder 标识的方法,可以对 WebDataBinder 进行初始化。WebDataBinder 是 DataBinder 的一
 * 		           个子类,用于完成由表单字段到 JavaBean 属性的绑定。
 *  3. @InitBinder 标识的方法不能有返回值,必须声明为void。
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface InitBinder {
	/**
	 * The names of command/form attributes and/or request parameters
	 * that this init-binder method is supposed to apply to.
	 * <p>Default is to apply to all command/form attributes and all request parameters
	 * processed by the annotated handler class. Specifying model attribute names or
	 * request parameter names here restricts the init-binder method to those specific
	 * attributes/parameters, with different init-binder methods typically applying to
	 * different groups of attributes or parameters.
	 * 粗略翻译：此init-binder方法应该应用于的命令/表单属性和/或请求参数的名称。默认是应用于所有命	   		* 令/表单属性和所有由带注释的处理类处理的请求参数。这里指定模型属性名或请求参数名将init-binder		 * 方法限制为那些特定的属性/参数，不同的init-binder方法通常应用于不同的属性或参数组。
	 * 我至己都理解不太理解这说的是啥呀，我们还是看例子吧
	 */
	String[] value() default {};
}

@ControllerAdvice
public class MyGlobalHandler {

    @InitBinder
    public void processParam(WebDataBinder dataBinder){

        /*
         * 创建一个字符串微调编辑器
         * 参数{boolean emptyAsNull}: 是否把空字符串("")视为 null
         */
        StringTrimmerEditor trimmerEditor = new StringTrimmerEditor(true);

        /*
         * 注册自定义编辑器
         * 接受两个参数{Class<?> requiredType, PropertyEditor propertyEditor}
         * requiredType：所需处理的类型
         * propertyEditor：属性编辑器，StringTrimmerEditor就是 propertyEditor的一个子类
         */
        dataBinder.registerCustomEditor(String.class, trimmerEditor);
        
        //同上，这里就不再一步一步讲解了
        binder.registerCustomEditor(Date.class,
                new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"), false));
    }
}

@RestController
public class BinderTestController {

    @GetMapping("processParam")
    public Map<String, Object> test(String str, Date date) throws Exception {
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("str", str);
        map.put("data", date);
        return  map;
    }
}

class Person {

    private String name;
    private Integer age;
    // omitted getters and setters.
}

class Book {

    private String name;
    private Double price;
    // omitted getters and setters.
}

@RestController
public class BinderTestController {

    @PostMapping("bindParam")
    public void test(Person person, Book book) throws Exception {
        System.out.println(person);
        System.out.println(book);
    }
}

@ControllerAdvice
public class MyGlobalHandler {

	/*
     * @InitBinder("person") 对应找到@RequstMapping标识的方法参数中
     * 找参数名为person的参数。
     * 在进行参数绑定的时候，以‘p.’开头的都绑定到名为person的参数中。
     */
    @InitBinder("person")
    public void BindPerson(WebDataBinder dataBinder){
        dataBinder.setFieldDefaultPrefix("p.");
    }

    @InitBinder("book")
    public void BindBook(WebDataBinder dataBinder){
        dataBinder.setFieldDefaultPrefix("b.");
    }
}

<template>
	<div class="pagination">
		<!-- 上 -->
		<button :disabled="pageNo == 1" @click="$emit('getPageNo', pageNo - 1)">
			上一页
		</button>
		<button v-if="startNumAndEndNum.start > 1" @click="$emit('getPageNo', 1)" :class="{ active: pageNo == 1 }">
			1
		</button>
		<button v-if="startNumAndEndNum.start > 2">···</button>
		<!-- 中间部分 -->
		<button v-for="(page, index) in startNumAndEndNum.end" :key="index" v-if="page >= startNumAndEndNum.start"
			@click="$emit('getPageNo', page)" :class="{ active: pageNo == page }">
			{{ page }}
		</button>

		<!-- 下 -->
		<button v-if="startNumAndEndNum.end < totalPage - 1">···</button>
		<button v-if="startNumAndEndNum.end < totalPage" @click="$emit('getPageNo', totalPage)"
			:class="{active:pageNo==totalPage}">
			{{ totalPage }}
		</button>
		<button :disabled="pageNo == totalPage" @click="$emit('getPageNo', pageNo + 1)">
			下一页
		</button>

		<button style="margin-left: 30px">共 {{ total }} 条</button>
	</div>
</template>

<script>
	export default {
		name: "Pagination",
		props: ["pageNo", "pageSize", "total", "continues"],
		computed: {
			//总共多少页
			totalPage() {
				//向上取整
				return Math.ceil(this.total / this.pageSize);
			},
			//计算出连续的页码的起始数字与结束数字[连续页码的数字:至少是5]
			startNumAndEndNum() {
				// console.log(this)
				const {
					continues,
					pageNo,
					totalPage
				} = this;
				//先定义两个变量存储起始数字与结束数字
				let start = 0,
					end = 0;
				//连续页码数字5【就是至少五页】，如果出现不正常的现象【就是不够五页】
				//不正常现象【总页数没有连续页码多】
				if (continues > totalPage) {
					start = 1;
					end = totalPage;
				} else {
					//正常现象【连续页码5，但是你的总页数一定是大于5的】
					//起始数字
					start = pageNo - parseInt(continues / 2);
					//结束数字
					end = pageNo + parseInt(continues / 2);
					//把出现不正常的现象【start数字出现0|负数】纠正
					if (start < 1) {
						start = 1;
						end = continues;
					}
					//把出现不正常的现象[end数字大于总页码]纠正
					if (end > totalPage) {
						end = totalPage;
						start = totalPage - continues + 1;
					}
				}
				return {
					start,
					end
				};
			},
		},
	};
</script>

<style lang="less" scoped>
	.pagination {
		text-align: center;

		button {
			margin: 0 5px;
			background-color: #f4f4f5;
			color: #606266;
			outline: none;
			border-radius: 2px;
			padding: 0 4px;
			vertical-align: top;
			display: inline-block;
			font-size: 13px;
			min-width: 35.5px;
			height: 28px;
			line-height: 28px;
			cursor: pointer;
			box-sizing: border-box;
			text-align: center;
			border: 0;

			&[disabled] {
				color: #c0c4cc;
				cursor: not-allowed;
			}

			&.active {
				cursor: not-allowed;
				background-color: #409eff;
				color: #fff;
			}
		}
	}

	.active {
		background: skyblue;
	}
</style>

————————————————————————————————————————-——————————————
//别的组件调用分页组件
<Pagination :pageNo="searchParams.pageNo" :pageSize="searchParams.pageSize" :total="total"
						:continues="5" @getPageNo="getPageNo" />

<el-input v-model="account" placeholder="请输入账号" @keyup.enter.native="search()"></el-input>

<template slot-scope="scope">
    {{ String(scope.row.status) === '0' ? '已禁用' : '正常' }}
</template>

//子组件：　　　　　　　　　　
<div>
     <p>这里是子组件</p>
     <slot></slot>
</div>

//父组件：
<div>
    <!--引用子组件-->
    <myslot>
        <p>这里是父组件</p>//当想在父组件中渲染这一行数据时，必须要在引用的子组件中定义一个slot标签
    </myslot>
</div>
 
//最后显示内容：
这里是子组件
这里是父组件　

//子组件 ： (假设名为：ebutton)
<template>
  <div class= 'button'>
      <button>  </button>
      <slot name= 'one'> 这就是默认值1</slot>
      <slot name='two'> 这就是默认值2 </slot>
      <slot name='three'> 这就是默认值3 </slot>
  </div>
</template>


父组件通过v-slot : name 的方式添加内容：
//父组件：（引用子组件 ebutton）
<template>
  <div class= 'app'>
     <ebutton> 
        <template v-slot:one> 这是插入到one插槽的内容 </template>
        <template v-slot:two> 这是插入到two插槽的内容 </template>
        <template v-slot:three> 这是插入到three插槽的内容 </template>
     </ebutton>
  </div>

<template>
  <div>
    <h2>效果一: 显示TODO列表时, 已完成的TODO为绿色</h2>
    <List :todos="todos">
        <!-- 书写template -->
        <template slot-scope="todo">
            <h5 :style="{color:todo.todo.isComplete?'green':'black'}">{{todo.todo.text}}</h5>
        </template>
    </List>
    
    <hr>
    <h2>效果二: 显示TODO列表时, 带序号, TODO的颜色为蓝绿搭配</h2>
    <List1 :data="todos">
         <template slot-scope="{row,index}">
               <h1 :style="{color:row.isComplete?'green':'hotpink'}">索引值{{index}}---------{{row.text}}</h1>
         </template>
    </List1>
  </div>
</template>

<script type="text/ecmascript-6">
  //子组件
  import List from './List'
  import List1 from './List1'
  export default {
    name: 'ScopeSlotTest',
    data () {
      return {
        todos: [
          {id: 1, text: 'AAA', isComplete: false},
          {id: 2, text: 'BBB', isComplete: true},
          {id: 3, text: 'CCC', isComplete: false},
          {id: 4, text: 'DDD', isComplete: false},
        ]
      }
    },

    components: {
      List,
      List1 
    }
  }
</script>

<template>
  <ul>
    <li v-for="(todo,index) in todos" :key="index">
       <!-- 坑：熊孩子挖到坑，父亲填坑 -->
       <!-- 数据来源于父亲：但是子组件决定不了结构与外网-->
       <slot :todo="todo"></slot>
    </li>
  </ul>
</template>

<script>
export default {
  name: 'List',
  props: {
    todos: Array
  }
}
</script>

<template>
  <ul>
    <li v-for="(todo,index) in data" :key="index">
       <!-- 坑：熊孩子挖到坑，父亲填坑 -->
       <!-- 数据来源于父亲：但是子组件决定不了结构与外网-->
       <slot :row="todo" :index="index "></slot>
    </li>
  </ul>
</template>

<script>
export default {
  name: 'List1',
  props: {
    data: Array
  }
}
</script>

// 把前端传递id,传递成String类型的，这样就不会造成精度的丢失。

//状态修改
statusHandle(row) {
     this.id = row.id
     this.status = row.status
     this.$confirm('确认调整该账号的状态?', '提示', {
          'confirmButtonText': '确定',
          'cancelButtonText': '取消',
          'type': 'warning'
      }).then(() => {
           enableOrDisableEmployee({'id': this.id, 'status': !this.status ? 1 : 0}).then(res => {
                 console.log('enableOrDisableEmployee', res)
                 if (String(res.code) === '1') {
                        this.$message.success('账号状态更改成功！')
                        this.handleQuery()
                  }
            }).catch(err => {
                  this.$message.error('请求出错了：' + err)
            })
       })
 },       

/**
 * 对象映射器:基于jackson将Java对象转为json，或者将json转为Java对象
 * 		将JSON解析为Java对象的过程称为 [从JSON反序列化Java对象]
 * 		从Java对象生成JSON的过程称为 [序列化Java对象到JSON]
 */
public class JacksonObjectMapper extends ObjectMapper {

    public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
    public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";

    public JacksonObjectMapper() {
        super();
        //收到未知属性时不报异常
        this.configure(FAIL_ON_UNKNOWN_PROPERTIES, false);

        //反序列化时，属性不存在的兼容处理
        this.getDeserializationConfig().withoutFeatures(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);


        SimpleModule simpleModule = new SimpleModule()
                .addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
                .addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
                .addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)))

                .addSerializer(BigInteger.class, ToStringSerializer.instance)
                .addSerializer(Long.class, ToStringSerializer.instance)    // 主要解决精度问题
                .addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
                .addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
                .addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));

        //注册功能模块 例如，可以添加自定义序列化器和反序列化器
        this.registerModule(simpleModule);
    }
}





------------------------------------
在WebMvcConfig中调用该方法

    
@Slf4j
@Configuration
@EnableSwagger2
@EnableKnife4j
public class WebMvcConfig extends WebMvcConfigurationSupport {

    /**
     * 扩展mvc框架的消息转换器
     * 默认的转换器一共有8个
     * @param converters
     */
    @Override
    protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
        // log.info("扩展消息转换器...");
        //创建消息转换器对象
        MappingJackson2HttpMessageConverter messageConverter = new MappingJackson2HttpMessageConverter();
        //设置对象转换器，底层使用Jackson将Java对象转为json
        messageConverter.setObjectMapper(new JacksonObjectMapper());
        //将上面的消息转换器对象追加到mvc框架的转换器集合中
        converters.add(0,messageConverter);
    }

}

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.11.1</version>
</dependency>

public class Car {

    private String color;
    private String type;

    // standard getters setters
}

ObjectMapper objectMapper = new ObjectMapper();
Car car = new Car("yellow", "renault");
objectMapper.writeValue(new File("target/car.json"), car);

{"color":"yellow","type":"renault"}

String carAsString = objectMapper.writeValueAsString(car);

String json = "{ \"color\" : \"Black\", \"type\" : \"BMW\" }";
Car car = objectMapper.readValue(json, Car.class);	

Car car = objectMapper.readValue(
new File("src/test/resources/json_car.json"), Car.class);

Car car = 
  objectMapper.readValue(
new URL("file:src/test/resources/json_car.json"), Car.class);

String json = "{ \"color\" : \"Black\", \"type\" : \"FIAT\" }";
JsonNode jsonNode = objectMapper.readTree(json);
String color = jsonNode.get("color").asText();

String jsonCarArray = 
  "[{ \"color\" : \"Black\", \"type\" : \"BMW\" }, { \"color\" : \"Red\", \"type\" : \"FIAT\" }]";
List<Car> listCar = objectMapper.readValue(
jsonCarArray, new TypeReference<List<Car>>(){});

String json = "{ \"color\" : \"Black\", \"type\" : \"BMW\" }";
Map<String, Object> map 
  = objectMapper.readValue(json, new TypeReference<Map<String,Object>>(){});

String jsonString 
  = "{ \"color\" : \"Black\", \"type\" : \"Fiat\", \"year\" : \"1970\" }";

objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
Car car = objectMapper.readValue(jsonString, Car.class);

JsonNode jsonNodeRoot = objectMapper.readTree(jsonString);
JsonNode jsonNodeYear = jsonNodeRoot.get("year");
String year = jsonNodeYear.asText();

objectMapper.configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, false);

objectMapper.configure(DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS, false);

public class CustomCarSerializer extends StdSerializer<Car> {
    
    public CustomCarSerializer() {
        this(null);
    }

    public CustomCarSerializer(Class<Car> t) {
        super(t);
    }

    @Override
    public void serialize(
      Car car, JsonGenerator jsonGenerator, SerializerProvider serializer) {
        jsonGenerator.writeStartObject();
        jsonGenerator.writeStringField("car_brand", car.getType());
        jsonGenerator.writeEndObject();
    }
}

ObjectMapper mapper = new ObjectMapper();
SimpleModule module = new SimpleModule("CustomCarSerializer", new Version(1, 0, 0, null, null, null));
module.addSerializer(Car.class, new CustomCarSerializer());
mapper.registerModule(module);

Car car = new Car("yellow", "renault");
String carJson = mapper.writeValueAsString(car);

public class CustomCarDeserializer extends StdDeserializer<Car> {
    
    public CustomCarDeserializer() {
        this(null);
    }

    public CustomCarDeserializer(Class<?> vc) {
        super(vc);
    }

    @Override
    public Car deserialize(JsonParser parser, DeserializationContext deserializer) {
        Car car = new Car();
        ObjectCodec codec = parser.getCodec();
        JsonNode node = codec.readTree(parser);
        
        // try catch block
        JsonNode colorNode = node.get("color");
        String color = colorNode.asText();
        car.setColor(color);
        return car;
    }
}

String json = "{ \"color\" : \"Black\", \"type\" : \"BMW\" }";
ObjectMapper mapper = new ObjectMapper();
SimpleModule module =
  new SimpleModule("CustomCarDeserializer", new Version(1, 0, 0, null, null, null));
module.addDeserializer(Car.class, new CustomCarDeserializer());
mapper.registerModule(module);

Car car = mapper.readValue(json, Car.class);

public class Request 
{
    private Car car;
    private Date datePurchased;

    // standard getters setters
}

ObjectMapper objectMapper = new ObjectMapper();
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm a z");
objectMapper.setDateFormat(df);
String carAsString = objectMapper.writeValueAsString(request);
// output: {"car":{"color":"yellow","type":"renault"},"datePurchased":"2016-07-03 11:43 AM CEST"}

@Data
public class TestBO {
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
private Date date;

private LocalDateTime localDateTime;

@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyyMMdd")
private LocalDate localDate;

@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "HHmmss")
private LocalTime localTime;
}

@Configuration
public class JacksonDateformatConfig {
    /**
     * Date格式化字符串
     */
    private static final String DATE_FORMAT = "yyyy-MM-dd";
    /**
     * DateTime格式化字符串
     */
    private static final String DATETIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    /**
     * Time格式化字符串
     */
    private static final String TIME_FORMAT = "HH:mm:ss";
/**
 * 自定义Bean
 *
 * @return
 */
@Bean
@Primary
public Jackson2ObjectMapperBuilderCustomizer jackson2ObjectMapperBuilderCustomizer() {
    return builder -> builder.serializerByType(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DATETIME_FORMAT)))
        .serializerByType(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DATE_FORMAT)))
        .serializerByType(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(TIME_FORMAT)))
        .deserializerByType(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DATETIME_FORMAT)))
        .deserializerByType(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DATE_FORMAT)))
        .deserializerByType(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(TIME_FORMAT)))
        .serializerByType(Date.class, new DateSerializer(true, new SimpleDateFormat(DATETIME_FORMAT))).deserializerByType(Date.class, new JsonDeserializer<String>() {
            @Override
            public String deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
                return p.getValueAsString();
            }
        }).deserializerByType(BigDecimal.class, new NumberDeserializers.BigDecimalDeserializer());
}

/**
 * @Description: 自定义元数据对象处理器
 */
@Component
@Slf4j
public class MyMetaObjectHandler implements MetaObjectHandler {
    /**
     * @Description: 插入操作，自动填充
     */

    @Override
    public void insertFill(MetaObject metaObject) {

        //log.info("公共字段填充insert"+metaObject.toString());
        //设置值
        metaObject.setValue("createTime", LocalDateTime.now());
        metaObject.setValue("updateTime", LocalDateTime.now());
        metaObject.setValue("createUser", BaseContext.getCurrentId());
        metaObject.setValue("updateUser", BaseContext.getCurrentId());

    }

    /**
     * @Description: 更新操作，自动填充
     */

    @Override
    public void updateFill(MetaObject metaObject) {

        //log.info("公共字段填充update"+metaObject.toString());

        metaObject.setValue("updateTime", LocalDateTime.now());

        metaObject.setValue("updateUser", BaseContext.getCurrentId());

    }
}


——————————————————————————————————————————————
BaseContext.java

/**
 * @Description: 基于TreadLocal封装工具类，用户保存和获取当前登录用户id
 */

public class BaseContext {
    public static ThreadLocal<Long> threadLocal = new ThreadLocal();

    /**
     * @Description: 设置值
     */
    
    public static void setCurrentId(Long id) {
        threadLocal.set(id);
    }

    /**
     * @Description: 得到值 
     */
    
    public static Long getCurrentId() {
        return threadLocal.get();
    }
}

public class Role{
    @TableId(type = IdType.AUTO)
    private Integer id;

    private String roleName;

    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createTime;

    @TableField(fill = FieldFill.UPDATE)
    private LocalDateTime updateTime;
}

@Log4j2
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("插入时自动填充...");
        this.strictInsertFill(metaObject,"createTime", LocalDateTime.class,LocalDateTime.now(ZoneId.of("Asia/Shanghai")));
    }
@Override
public void updateFill(MetaObject metaObject) {
    log.info("更新时自动填充...");
    this.strictInsertFill(metaObject,"updateTime", LocalDateTime.class,LocalDateTime.now(ZoneId.of("Asia/Shanghai")));
}
}

<form method="post" action="/common/upload" enctype="multipart/form-data">
  <input name="myFile" type="file" />
  <input type="submit" value="提交" /> 
</form>

/**
 * @Description: 文件上传和下载
 */

@RestController
@RequestMapping("/common")
public class CommonController {

    @Value("${reggie.path}")
    private String bathPath;
    /**
     * @Description: 文件上传
     */

    @PostMapping("/upload")
    public R<String> upload(MultipartFile file){
        // file 是一个临时文件，需要转存到指定位置，否则本次请求完成后临时文件会删除
        // 原始文件名,abc.jpg
        String originnalFilename = file.getOriginalFilename();
        String suffix = originnalFilename.substring(originnalFilename.indexOf("."));
        // 使用UUID重新生成文件名，防止文件名称重复造成文件覆盖
        String fileName = UUID.randomUUID().toString() + suffix;

        // 创建一个目录对象
        File dir = new File(bathPath);
        // 判断当前目录是否存在
        if (!dir.exists()) {
            // 目录不存在，需要创建
            dir.mkdirs();
        }

        try {
            // 将临时文件转存到指定位置
            file.transferTo(new File(bathPath + fileName ));
        } catch (IOException e) {
            e.printStackTrace();
        }
        return R.success(fileName);
    }

    /**
     * @Description: 文件下载
     */

    @GetMapping("/download")
    public void download(String name, HttpServletResponse response){
        // 输入流，通过输入流读取文件内容
        try {
            FileInputStream fileInputStream = new FileInputStream(new File(bathPath + name ));

            // 输出流，通过输出流将文件写回浏览器，再浏览器展示图片
            ServletOutputStream outputStream = response.getOutputStream();
            response.setContentType("image/jpeg");

            int len = 0;
            byte[] bytes = new byte[1024];
            while ((len = fileInputStream.read(bytes)) != -1){
                outputStream.write(bytes,0,len);
                outputStream.flush();
            }
            // 关闭资源
            outputStream.close();
            fileInputStream.close();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 flavors.stream().map((item)->{
      item.setDishId(dishId);
      return item;
 }).collect(Collectors.toList());

public class Demo1 {
    public static void main ( String[] args ) {
        //创建stream流,通过Arrays.stream
        int[] arr = {1, 2, 3};
        IntStream stream = Arrays.stream(arr);
        Person[] personStr = {new Person(18, "xiaoliu"), new Person(18, "xiaojing")};
        Stream<Person> personStream = Arrays.stream(personStr);
        // 通过stream.of
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4);
        // 通过集合创建流
        List<String> stringList = Arrays.asList("123", "456", "789");
        // 创建普通流
        Stream<String> stringStream = stringList.stream();
        // 创建并行流
        Stream<String> parallelStream = stringList.parallelStream();
}
}

public class Demo2 {
    public static void main ( String[] args ) {
        // 流的筛选
        List<Integer> integerList = Arrays.asList(1, 2, 3,3, 4, 5, 6);
        // 筛选出集合中数字大于4的元素
        List<Integer> collect = integerList.stream().filter(x -> x > 4).collect(Collectors.toList());
        System.out.println(collect); //[5, 6]
        // 集合中的去重
        List<Integer> collect1 = integerList.stream().distinct().collect(Collectors.toList());
        System.out.println(collect1);//[1, 2, 3, 4, 5, 6]
        // 获取流中的第一个元素
        Optional<Integer> first = integerList.stream().filter(x -> x > 4).findFirst();
        Optional<Integer> any = integerList.stream().filter(x -> x > 4).findAny();
        Optional<Integer> any1 = integerList.parallelStream().filter(x -> x > 4).findAny();
        System.out.println(first); //Optional[5]
        System.out.println(any); //Optional[5]
        System.out.println(any1); // 预期结果不稳定
}
}

public class Demo3 {
    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("huainvhai", "xiaotiancai", "bennvhai");
        // 获取集合中最长的字符串
        Optional<String> maxString = stringList.stream().max(Comparator.comparing(String::length));
        // 获取集合中最短字符串
        Optional<String> minString = stringList.stream().min(Comparator.comparing(String::length));
        System.out.println(maxString);
        System.out.println(minString);
       
    // 获取集合中的最大值
    List<Integer> integerList = Arrays.asList(1, 2, 3);
    Optional<Integer> maxInteger = integerList.stream().max((i, j) -> {
        return i - j;
    });
    // 获取集合中的最小值
    Optional<Integer> minInteger = integerList.stream().max((i, j) -> {
        return j - i;
    });
    System.out.println(maxInteger);
    System.out.println(minInteger);


    // 集合泛型是个对象的最值
    ArrayList<Person> personList = new ArrayList<>();
    personList.add(new Person("xiao",12));
    personList.add(new Person("xiao",20));
    personList.add(new Person("xiao",18));
    Optional<Person> max = personList.stream().max(Comparator.comparing(Person::getAge));
    // 获取集合中的元素数量
    long count = personList.stream().filter(p -> p.getAge() > 12).count();
    System.out.println(max);
    System.out.println(count);
}
}

public interface Stream<T> extends BaseStream<T, Stream<T>> {
 // 方法1
 T reduce(T identity, BinaryOperator<T> accumulator);
 // 方法2
 Optional<T> reduce(BinaryOperator<T> accumulator);
 // 方法3
 <U> U reduce(U identity,
          BiFunction<U, ? super T, U> accumulator,
          BinaryOperator<U> combiner);
}

public class Demo4 {
    public static void main(String[] args) {
        List<Integer> integers = Arrays.asList(1, 2, 3, 4);
        // 写法一 集合中的元素求和 (就是集合中的元素求和再加上1)
        Integer integer = integers.stream().reduce(1, Integer::sum);
        // 写法二
        integers.stream().reduce(1,(x,y)->x+y);
        System.out.println(integer); // 11
        
    // 第二种缩减方式 集合中的元素求和
    Optional<Integer> reduce = integers.stream().reduce(Integer::sum);
    // 写法二
    Optional<Integer> reduce1 = integers.stream().reduce((x, y) -> x + y);
    System.out.println(reduce); //Optional[10]
    System.out.println(reduce1); //Optional[10]

    // 集合中使用reduce求最值问题
    Optional<Integer> reduce2 = integers.stream().reduce(Integer::max);
    System.out.println(reduce2);

    /**
     * 对象集合求和 求最值问题
     */
    ArrayList<Person> personList = new ArrayList<>();
    personList.add(new Person("xiao",12));
    personList.add(new Person("xiao",20));
    personList.add(new Person("xiao",18));
    // 求集合中对象的年龄的总和
    Optional<Integer> reduce3 = personList.stream().map(p -> p.getAge()).reduce(Integer::sum);
    System.out.println(reduce3);  //Optional[50]

    // 求集合中年龄最大的对象
    Optional<Person> reduce4 = personList.stream().reduce((p1, p2) -> p1.getAge() > p2.getAge() ? p1 : p2);
    Optional<Person> max = personList.stream().max(Comparator.comparingInt(Person::getAge));
    System.out.println(reduce4);
    System.out.println(max);
}
}

public class Demo5 {
    public static void main(String[] args) {
        ArrayList<Person> personList = new ArrayList<>();
        personList.add(new Person("xiao",12));
        personList.add(new Person("xiao",20));
        personList.add(new Person("xiao",18));
        // 获取平均年龄 averaging
        Double collect = personList.stream().collect(Collectors.averagingInt(Person::getAge));
        System.out.println(collect); //16.666666666666668

    // summarizing
    DoubleSummaryStatistics collect1 = personList.stream().collect(Collectors.summarizingDouble(Person::getAge));
    System.out.println(collect1); // DoubleSummaryStatistics{count=3, sum=50.000000, min=12.000000, average=16.666667, max=20.000000}

    //joining
    String collect2 = personList.stream().map(p -> p.getName()).collect(Collectors.joining(","));
    System.out.println(collect2);  //xiao,xiao,xiao

    // reduce
    Integer collect3 = personList.stream().collect(Collectors.reducing(0, Person::getAge, (x, y) -> x + y));
    Optional<Integer> reduce = personList.stream().map(Person::getAge).reduce(Integer::sum);
    System.out.println(collect3); //50
    System.out.println(reduce);   //Optional[50]

    // groupingBy
    // 以名字进行分组
    Map<String, List<Person>> collect4 = personList.stream().collect(Collectors.groupingBy(Person::getName));
    System.out.println(collect4); //{xiao=[Person(name=xiao, age=12), Person(name=xiao, age=20), Person(name=xiao, age=18)]}
    // 先以名字分组，再以年龄分组
    Map<String, Map<Integer, List<Person>>> collect5 = personList.stream().collect(Collectors.groupingBy(Person::getName, Collectors.groupingBy(Person::getAge)));
    System.out.println(collect5); //{xiao={18=[Person(name=xiao, age=18)], 20=[Person(name=xiao, age=20)], 12=[Person(name=xiao, age=12)]}}

    // toList、toSet、toMap
    Set<Person> collect6 = personList.stream().collect(Collectors.toSet());
    System.out.println(collect6);//[Person(name=xiao, age=18), Person(name=xiao, age=20), Person(name=xiao, age=12)]

}
}