python复制代码pip install python-dateutil

python复制代码from dateutil.rrule import *

def get_two_datelist(sdate,edate):

    return list(rrule(DAILY,dtstart=parse(sdate),until=parse(edate)))

print(get_two_datelist("2021-11-1","2021-11-10"))

input复制代码# 终端输出结果

[datetime.datetime(2021, 11, 1, 0, 0), 
datetime.datetime(2021, 11, 2, 0, 0), 
datetime.datetime(2021, 11, 3, 0, 0), 
datetime.datetime(2021, 11, 4, 0, 0), 
datetime.datetime(2021, 11, 5, 0, 0), 
datetime.datetime(2021, 11, 6, 0, 0), 
datetime.datetime(2021, 11, 7, 0, 0),
datetime.datetime(2021, 11, 8, 0, 0), 
datetime.datetime(2021, 11, 9, 0, 0), 
datetime.datetime(2021, 11, 10, 0, 0)]

python复制代码  def get_two_date_interval(sdate,edate):

      return relativedelta(parse(sdate),parse(edate))

  print(get_two_date_interval("2021-10-21","2021-11-10"))

go复制代码// 定义一x全局对象 这是并发安全的对象 注意这个是sqlx了 不是sql
var db *sqlx.DB

func initMysql() (err error) {
   dsn := "root:1234qwer@tcp(127.0.0.1:3306)/go_test"
   // 原生的 是open 这里直接用connect 就行了 里面包含了ping的操作
   db, err = sqlx.Connect("mysql", dsn)
   if err != nil {
      panic(err)
   }

   db.SetConnMaxLifetime(time.Second * 10)
   // 设置最大的连接数 默认是无限制 如果超出限制了 就会排队等待
   db.SetMaxOpenConns(200)
   // 设置最大的空闲连接数 默认是无限制 业务量小的时候 可以把多余的连接释放掉，只保留一定数量的连接数
   db.SetMaxIdleConns(10)
   return nil
}

go复制代码// 这里注意首字母要大写了
// 因为sqlx是用的反射来对结构体进行赋值，所以是跨包的，
// 那自然这个结构体的 field 要首字母大写了
type user struct {
   Id   int    `db:"id"`
   Age  int    `db:"age"`
   Name string `db:"name"`
}

func queryRow() {
   sqlStr := "select id,age,name from user where id=?"
   var u user
   //queryRow 之后 一定要执行scan  否则 持有的数据库连接 不会释放
   err := db.Get(&u, sqlStr, 1)
   if err != nil {
      fmt.Println(err)
   }
   fmt.Println("result:", u)
}

go复制代码func queryRow() {
   sqlStr := "select id,age,name from user where id=?"
   var u user
   //queryRow 之后 一定要执行scan  否则 持有的数据库连接 不会释放
   err := db.Get(&u, sqlStr, 1)
   if err != nil {
      fmt.Println(err)
   }
   fmt.Println("result:", u)
}

go复制代码func insert() {
   sqlStr := "insert into user(name,age) values(?,?)"
   ret, err := db.Exec(sqlStr, "李彦宏", 99)
   if err != nil {
      fmt.Println(err)
      return
   }
   id, err2 := ret.LastInsertId()
   if err2 != nil {
      fmt.Println("get lastid error:", err2)
      return
   }
   fmt.Println("insert success,id: ", id)
}

go复制代码func betterInsert() {
   sqlStr := `insert into user(name,age) values(:name,:age) `
   _, err := db.NamedExec(sqlStr, map[string]interface{}{
      "name": "大强子",
      "age":  17,
   })
   if err != nil {
      panic(err)
   }
   return
}

go复制代码func transactionDemo() error {
   tx, err := db.Begin()
   if err != nil {
      fmt.Println("begin trans failed")
      return err
   }

   defer func() {
      // 如果这个函数有panic 则 回滚以后再panic
      if p := recover(); p != nil {
         tx.Rollback()
         panic(p)
      } else if err != nil {
         // 如果有错误 也回滚
         fmt.Println("rollback")
         tx.Rollback()
      } else {
         err = tx.Commit()
         fmt.Println("commit")
      }
   }()

   sqlstr1 := "update user set age=130 where id=?"
   _, err = tx.Exec(sqlstr1, 1)
   if err != nil {
      return err
   }

   sqlstr2 := "update user set age=130 where id=?"
   _, err = tx.Exec(sqlstr2, 2)
   if err != nil {
      return err
   }

   err = tx.Commit()
   if err != nil {
      return err
   }
   return nil

}

go复制代码
func insertUsers(users []user) error {
   // 存放 (?, ?) 的slice
   valueStrings := make([]string, 0, len(users))
   // 存放values的slice
   valueArgs := make([]interface{}, 0, len(users)*2)
   // 遍历users准备相关数据
   for _, u := range users {
      // 此处占位符要与插入值的个数对应
      valueStrings = append(valueStrings, "(?, ?)")
      valueArgs = append(valueArgs, u.Name)
      valueArgs = append(valueArgs, u.Age)
   }
   // strings.Join(valueStrings, ",")  ===》(?, ?),(?, ?),(?, ?)
   // 自行拼接要执行的具体语句 形如：INSERT INTO user (name, age) VALUES (?, ?),(?, ?),(?, ?)
   stmt := fmt.Sprintf("INSERT INTO user (name, age) VALUES %s",
      strings.Join(valueStrings, ","))
   fmt.Println(valueArgs)
   _, err := db.Exec(stmt, valueArgs...)
   return err
}

css复制代码users := []user{
   {
      Name: "kk1",
      Age:  11,
   },
   {
      Name: "kk2",
      Age:  12,
   },
   {
      Name: "kk1",
      Age:  13,
   },
}
insertUsers(users)

go复制代码func insertMoreUsers(users []user) error {
   _, err := db.NamedExec("INSERT INTO user (name, age) VALUES (:name, :age)", users)
   return err
}

go复制代码func searchByIDs(ids []int)(users []user, err error){
   //把id 填到sql语句中
   query, args, err := sqlx.In("SELECT name, age FROM user WHERE id IN (?)", ids)
   if err != nil {
      return
   }
   // sqlx.In 返回带 `?` 的查询语句, 记得要用rebind 重新绑定下
   query = db.Rebind(query)

   err = db.Select(&users, query, args...)
   return
}

xml复制代码   <dependencies>
        <!--        springboot相关包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!--        springboot相关包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--        数据源链接池 不是此部分必备包-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--        springboot相关包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--        json序列化相关包 不是本部分关键包-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.70</version>
        </dependency>
        <!--        mybatis相关包 必备包-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>
        <!--        mysql数据库驱动 必备包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.23</version>
        </dependency>
        <!--        lombok 不用写写get和set，不是本部分必备包-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.18</version>
        </dependency>
    </dependencies>

less复制代码@SpringBootApplication
// 扫描指定包路径
@MapperScan("com.aims.mybatisplus.dao")
public class SpringbootMybatisPlusApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootMybatisPlusApplication.class, args);
    }
}

sql复制代码CREATE TABLE `member` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `create_by` varchar(32) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '创建人',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `update_by` varchar(32) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '更新人',
  `update_time` datetime DEFAULT NULL COMMENT '更新时间',
  `member_name` varchar(255) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '会员名称',
  `member_type` tinyint(3) DEFAULT NULL COMMENT '会员类型',
  `member_phone` varchar(20) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '手机号',
  `member_level` tinyint(3) DEFAULT NULL COMMENT '会员等级',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='会员表';

arduino复制代码package com.aims.mybatisplus.model.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/**
 * @description member
 * @author AI码师
 * @date 2021-11-07
 */
@Data
// 如果表名和实体名称一样 则不需要使用这个注解
@TableName("member")
public class Member implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(type = IdType.AUTO)
    /**
    * 主键
    */
    private Long id;

    /**
    * 创建人
    */
    private String createBy;

    /**
    * 创建时间
    */
    private Date createTime;

    /**
    * 更新人
    */
    private String updateBy;

    /**
    * 更新时间
    */
    private Date updateTime;

    /**
    * 会员名称
    */
    private String memberName;

    /**
    * 会员类型
    */
    private int memberType;

    /**
    * 手机号
    */
    private String memberPhone;

    /**
    * 会员等级
    */
    private int memberLevel;

    public Member() {}
}

java复制代码package com.aims.mybatisplus.dao;

import com.aims.mybatisplus.model.entity.Member;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

/**
 * @author AI码师
 * @description memberMapper
 * @date 2021-11-07
 */
@Mapper
public interface MemberMapper extends BaseMapper<Member> {
// 用上

}

c复制代码spring:
  datasource:
    url: jdbc:mysql://localhost:3306/springboot-integration?useUnicode=true&characterEncoding=utf-8
    username: aims
    password: aims
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
// 下面这个是开启sql打印的，不是必须要配置的
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

less复制代码   @GetMapping
    public String get(@RequestParam("name") String name) {
        
        LambdaQueryWrapper<Member> lambda = new QueryWrapper<Member>().lambda();
        lambda.eq(Member::getMemberName, name);
        Member member = memberMapper.selectOne(lambda);
        return Objects.isNull(member) ? "没找到信息" : JSON.toJSONString(member);
    }

less复制代码    @PostMapping
    public int post(@RequestBody Member member) {
        int effectNum = memberMapper.insert(member);
        return effectNum;
    }

java复制代码module com.foo.bar {
    requires org.baz.qux;
    exports com.foo.bar.alpha;
    exports com.foo.bar.beta;
}

cpp复制代码#include <iostream>
#include <thread>

void myprint(const int &i, char *pmybuf) {
	std::cout << "i = " << i << std::endl;
    std::cout << "pmybuf = " << pmybuf << std::endl;
	return;
}

int main()
{
	int my = 1;
	int &may = my;
	char buf[] = "I love china";

	std::thread obj(myprint, my, buf);
	obj.join();
	std::cout << "main thread finished!!" << std::endl;
	return 0;
}

bash复制代码0x00eff940 {1}
0x00eff940 {1}
直接传入函数
0x00eff940 {1}
使用线程
0x01010a9c {1}

bash复制代码0x00b7f750 "I love china"
函数传入
0x00b7f750 "I love china"
&pmybuf
0x00b7f65c {0x00b7f750 "I love china"}
线程
0x00b7f750 "I love china"
&pmybuf
0x00cef99c {0x00b7f750 "I love china"}

cpp复制代码#include <iostream>
#include <thread>
#include <string>
using namespace std;

void myPrint(const int i, const string& pmybuf)
{
	cout << i << endl;
	cout << pmybuf << endl;
}

int main()
{
	int mvar = 1;
	int& mvary = mvar;
	char mybuf[] = "this is a test";
	//如果detach了，这样仍然是不安全的
	//因为存在主线程运行完了，mybuf被回收了，系统采用mybuf隐式类型转换成string
	//推荐先创建一个临时对象thread myThread(myPrint, mvar, string(mybuf));就绝对安全了。。。。
	thread myThread(myPrint, mvar, mybuf);
	myThread.join();
	//myThread.detach();

	cout << "Hello World!" << endl;
}

cpp复制代码std::thread myobj(myprint,mvar);

cpp复制代码std::thread myobj(myprint,A(mvar));

cpp复制代码#include <iostream>
#include <thread>
using namespace std;

class A {
public:
	mutable int m_i; //m_i即使实在const中也可以被修改
	A(int i) :m_i(i) {}
};

void myPrint(const A& pmybuf)
{
	pmybuf.m_i = 199;
	cout << "子线程myPrint的参数地址是" << &pmybuf << "thread = " << std::this_thread::get_id() << endl;
}

int main()
{
	A myObj(10);
	//myPrint(const A& pmybuf)中引用不能去掉，如果去掉会多创建一个对象
	//const也不能去掉，去掉会出错
	//即使是传递的const引用，但在子线程中还是会调用拷贝构造函数构造一个新的对象，
	//所以在子线程中修改m_i的值不会影响到主线程
	//如果希望子线程中修改m_i的值影响到主线程，可以用thread myThread(myPrint, std::ref(myObj));
	//这样const就是真的引用了，myPrint定义中的const就可以去掉了，类A定义中的mutable也可以去掉了
	thread myThread(myPrint, myObj);
	myThread.join();
	//myThread.detach();

	cout << "Hello World!" << endl;
}

cpp复制代码#include <iostream>
#include <thread>
#include <memory>
using namespace std;

void myPrint(unique_ptr<int> ptn)
{
	cout << "thread = " << std::this_thread::get_id() << endl;
}

int main()
{
	unique_ptr<int> up(new int(10));
	//独占式指针只能通过std::move()才可以传递给另一个指针
	//传递后up就指向空，新的ptn指向原来的内存
	//所以这时就不能用detach了，因为如果主线程先执行完，ptn指向的对象就被释放了
	thread myThread(myPrint, std::move(up));//由于这里使用move所以当运行到这里后 之前的up里值不存在，子线程函数执行完之后才会被释放
	myThread.join();
	//myThread.detach();

	return 0;
}

java复制代码@ExceptionHandler(Exception.class)
public void deaCommonException(Exception exception, HttpServletResponse response) {
    logger.info("------> 处理通用异常 <-------");
}

java复制代码protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    
    
   try {
      ModelAndView mv = null;
      // 准备异常接收对象
      Exception dispatchException = null;

      try {
         // 省略主流程处理 , 主要是 handler 的调用
         mappedHandler = getHandler(processedRequest);
         HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
         mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

      }
      
      // 此处接收 exception , 映射给接收对象
      catch (Exception ex) {
         dispatchException = ex;
      }
      catch (Throwable err) {
         dispatchException = new NestedServletException("Handler dispatch failed", err);
      }
      // 核心逻辑 , 对 Exception 进行处理
      processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
   }
   catch (Exception ex) {
      triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
   }
   catch (Throwable err) {
      triggerAfterCompletion(processedRequest, response, mappedHandler,
            new NestedServletException("Handler processing failed", err));
   }
   finally {
      if (asyncManager.isConcurrentHandlingStarted()) {
         // Instead of postHandle and afterCompletion
         if (mappedHandler != null) {
            mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
         }
      }
      else {
         // Clean up any resources used by a multipart request.
         if (multipartRequestParsed) {
            cleanupMultipart(processedRequest);
         }
      }
   }
}

java复制代码private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
      @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
      @Nullable Exception exception) throws Exception {

   boolean errorView = false;

   if (exception != null) {
      // 视图处理类 ,特定条件的异常会转发给特定的处理视图 , 可以在处理程序处理期间的任何时间抛出
      if (exception instanceof ModelAndViewDefiningException) {
         mv = ((ModelAndViewDefiningException) exception).getModelAndView();
      }
      else {
         // Step 1 : 获取当前请求的 handler 类 , 业务处理类 
         Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
         // Step 2 : 核心 , 处理主流程处理
         mv = processHandlerException(request, response, handler, exception);
         errorView = (mv != null);
      }
   }

   
   if (mv != null && !mv.wasCleared()) {
      // 渲染给定的ModelAndView -> resolveViewName
      render(mv, request, response);
      if (errorView) {

        // request.removeAttribute("javax.servlet.error.status_code");
        // request.removeAttribute("javax.servlet.error.exception_type");
        // request.removeAttribute("javax.servlet.error.message");
        // request.removeAttribute("javax.servlet.error.exception");
        // request.removeAttribute("javax.servlet.error.request_uri");
        // request.removeAttribute("javax.servlet.error.servlet_name");
         WebUtils.clearErrorRequestAttributes(request);
      }
   }
   else {
   }

   if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
      return;
   }

   if (mappedHandler != null) {
      mappedHandler.triggerAfterCompletion(request, response, null);
   }
}

java复制代码protected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response,
      @Nullable Object handler, Exception ex) throws Exception {

   // 成功和错误响应可能使用不同的内容类型
   // HandlerMapping.class.getName() + ".producibleMediaTypes";
   request.removeAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);

   // Check registered HandlerExceptionResolvers...
   ModelAndView exMv = null;
   if (this.handlerExceptionResolvers != null) {
      // -      
      // - DefaultErrorAttributes
      // - HandlerExceptionResolverComposite 
      for (HandlerExceptionResolver resolver : this.handlerExceptionResolvers) {
         exMv = resolver.resolveException(request, response, handler, ex);
         if (exMv != null) {
            break;
         }
      }
   }
   if (exMv != null) {
      if (exMv.isEmpty()) {
         request.setAttribute(EXCEPTION_ATTRIBUTE, ex);
         return null;
      }
      // We might still need view name translation for a plain error model...
      if (!exMv.hasView()) {
         String defaultViewName = getDefaultViewName(request);
         if (defaultViewName != null) {
            exMv.setViewName(defaultViewName);
         }
      }
      WebUtils.exposeErrorRequestAttributes(request, ex, getServletName());
      return exMv;
   }

   throw ex;
}

java复制代码public ModelAndView resolveException(
      HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {

   if (this.resolvers != null) {
      // 遍历 resolvers 处理类 , 常见的有以下几种 , 添加默认异常解析器
      // - ExceptionHandlerExceptionResolver 
      // - ResponseStatusExceptionResolver
      // - DefaultHandlerExceptionResolver
      for (HandlerExceptionResolver handlerExceptionResolver : this.resolvers) {
         ModelAndView mav = handlerExceptionResolver.resolveException(request, response, handler, ex);
         if (mav != null) {
            return mav;
         }
      }
   }
   return null;
}

java复制代码protected ModelAndView doResolveHandlerMethodException(HttpServletRequest request,
      HttpServletResponse response, @Nullable HandlerMethod handlerMethod, Exception exception) {

   // 通过业务方法和异常类型从集合中获取去 
   ServletInvocableHandlerMethod exceptionHandlerMethod = getExceptionHandlerMethod(handlerMethod, exception);
   if (exceptionHandlerMethod == null) {
      return null;
   }
   
   // setHandlerMethodArgumentResolvers +  setHandlerMethodReturnValueHandlers

   ServletWebRequest webRequest = new ServletWebRequest(request, response);
   ModelAndViewContainer mavContainer = new ModelAndViewContainer();

   // 此处会调用具体的代理方法 , 会根据是否存在 Throwable cause 分别调用2个不同的方法
   exceptionHandlerMethod.invokeAndHandle

   //如果完全处理了请求 ,这直接返回 ModelAndView
   if (mavContainer.isRequestHandled()) {
      return new ModelAndView();
   }
   else {
      // 省略返回处理的 ModelAndView 或者 RedirectAttributes 对象
   }
}

java复制代码protected ServletInvocableHandlerMethod getExceptionHandlerMethod(
      @Nullable HandlerMethod handlerMethod, Exception exception) {

   Class<?> handlerType = null;

   // 如果 HandlerMethod 存在 , 则先尝试处理
   if (handlerMethod != null) {
      // 控制器类本身的局部异常处理程序方法 , 此处是具体的业务方法
      handlerType = handlerMethod.getBeanType();
      // 从缓存中获取当前异常类对应的 ExceptionResolver , 不存在则 new ExceptionHandlerMethodResolver , 并且缓存
      ExceptionHandlerMethodResolver resolver = this.exceptionHandlerCache.get(handlerType);
      
      Method method = resolver.resolveMethod(exception);
      
      // 如果控制器本身存在存在局部异常处理方法 , 则直接返回
      if (method != null) {
         return new ServletInvocableHandlerMethod(handlerMethod.getBean(), method);
      }
      
      // 代理类需要获取实际类
      if (Proxy.isProxyClass(handlerType)) {
         handlerType = AopUtils.getTargetClass(handlerMethod.getBean());
      }
   }

   // 此处遍历所有的异常类
   for (Map.Entry<ControllerAdviceBean, ExceptionHandlerMethodResolver> entry : this.exceptionHandlerAdviceCache.entrySet()) {
      ControllerAdviceBean advice = entry.getKey();
      
      if (advice.isApplicableToBeanType(handlerType)) {
         // Exception 处理类 , 包含核心的类信息
         ExceptionHandlerMethodResolver resolver = entry.getValue();
         // 
         Method method = resolver.resolveMethod(exception);
         
         if (method != null) {
            return new ServletInvocableHandlerMethod(advice.resolveBean(), method);
         }
      }
   }

   return null;
}

// 从缓存中尝试获取Method
public Method resolveMethodByExceptionType(Class<? extends Throwable> exceptionType) {
   Method method = this.exceptionLookupCache.get(exceptionType);
   if (method == null) {
      method = getMappedMethod(exceptionType);
      // 不存在则获取后添加到缓存中
      this.exceptionLookupCache.put(exceptionType, method);
   }
   return method;
}

private Method getMappedMethod(Class<? extends Throwable> exceptionType) {
   List<Class<? extends Throwable>> matches = new ArrayList<>();
  
   // 遍历所有的 Method Mapper
   // PS : 这里是第二个循环 ,第一个循环遍历 Class , 第二个循环遍历 Method
   for (Class<? extends Throwable> mappedException : this.mappedMethods.keySet()) {
      if (mappedException.isAssignableFrom(exceptionType)) {
         matches.add(mappedException);
      }
   }
   if (!matches.isEmpty()) {
      matches.sort(new ExceptionDepthComparator(exceptionType));
      // 返回匹配的第一个方法 ?
      return this.mappedMethods.get(matches.get(0));
   }
   else {
      return null;
   }
}

java复制代码// 在 ExceptionHandlerExceptionResolver 中存在2个Map 用于存放对应的关联关系

// 用于保存 Class 对应的 Resolver , 对应业务Controller 对应 Resolver
Map<Class<?>, ExceptionHandlerMethodResolver> exceptionHandlerCache =new ConcurrentHashMap<>(64);

// 对应 Error 处理类对应 resolver
Map<ControllerAdviceBean, ExceptionHandlerMethodResolver> exceptionHandlerAdviceCache =new LinkedHashMap<>();

java复制代码// C- ExceptionHandlerExceptionResolver
public void afterPropertiesSet() {
   // 初始化 Advice  , 处理 ResponseBodyAdvice 
   initExceptionHandlerAdviceCache();

   if (this.argumentResolvers == null) {
      List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
      this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
   }
   if (this.returnValueHandlers == null) {
      List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
      this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
   }
}

private void initExceptionHandlerAdviceCache() {
   if (getApplicationContext() == null) {
      return;
   }
   
   // 所有的 Error 处理类
   List<ControllerAdviceBean> adviceBeans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());
   for (ControllerAdviceBean adviceBean : adviceBeans) {
      Class<?> beanType = adviceBean.getBeanType();
      if (beanType == null) {
         throw new IllegalStateException("Unresolvable type for ControllerAdviceBean: " + adviceBean);
      }
      // 通过 BeanType 构建 Resolver
      ExceptionHandlerMethodResolver resolver = new ExceptionHandlerMethodResolver(beanType);
      
      // 将 Resolver 存入缓存
      if (resolver.hasExceptionMappings()) {
         this.exceptionHandlerAdviceCache.put(adviceBean, resolver);
      }
      if (ResponseBodyAdvice.class.isAssignableFrom(beanType)) {
         this.responseBodyAdvice.add(adviceBean);
      }
   }
}