php复制代码<?php

class TestDemo
{
}

php复制代码/**
 * 这是一个测试Demo类
 * Author: gxcuizy
 * Date: 2021-05-25 13:57:16
 * Class TestClass
 */
class TestDemo
{
}

php复制代码// 声明一个常量
const HELLO_WORLD = 'best';

php复制代码// 声明一个公共变量
public $user_name = '';
// 声明一个静态变量
public static $user_age = 18;

php复制代码/**
 * 这是一个测试方法
 * @param string $msg 参数说明
 * @return array
 */
public function testAction($msg = '')
{
    // 返回数据格式
    $return = array('code' => 200, 'msg' => '');
    return $return;
}

/**
 * 这是私有方法，方法命名以单下划线开始
 * @param string $arg 参数说明
 * @return string
 */
private function privateAction($arg = '')
{
    return $arg;
}

php复制代码/**
 * 获取两个数相加的和
 * @param int $one 第一个数
 * @param int $two 第二个数
 * @return int
 */
public function getUserAge($one = 0, $two = 0)
{
    $sum = $one + $two;
    return $sum;
}

php复制代码/**
 * 判断用户是否成年
 * @param int $age 年龄
 */
public function logicAction($age = 18)
{
    if ($age >= 18) {
        echo '已成年';
    } else {
        echo '未成年';
    }
}

Java复制代码public class Master {
    //主宰的初始血量
    private int blood = 100;

    //每次被击打后血量减5
    public int decreaseBlood() {
        blood = blood - 5;
        return blood;
    }

    //通过血量判断主宰是否还存活
    public boolean isAlive() {
        return blood > 0;
    }
}

Java复制代码 public static void main(String[] args) {
        final Master master = new Master();
        Thread neZhaAttachThread = new Thread() {
            public void run() {
                while (master.isAlive()) {
                    try {
                        int remainBlood = master.decreaseBlood();
                        if (remainBlood == 0) {
                            System.out.println("哪吒击败了主宰！");
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        Thread lanLingWangThread = new Thread() {
            public void run() {
                while (master.isAlive()) {
                    try {
                        int remainBlood = master.decreaseBlood();
                        if (remainBlood == 0) {
                            System.out.println("兰陵王击败了主宰！");
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        neZhaAttachThread.start();
        lanLingWangThread.start();
    }

vbnet复制代码兰陵王击败了主宰！
哪吒击败了主宰！

Process finished with exit code 0

Java复制代码public synchronized int decreaseBlood() {
       blood = blood - 5;
       return blood;
}

Java复制代码public synchronized int decreaseBlood() {
       blood = blood - 5;
       return blood;
}

Java复制代码public static synchronized int decreaseBlood() {
       blood = blood - 5;
       return blood;
}

Java复制代码public int decreaseBlood() {
    synchronized(this) {
       blood = blood - 5;
       return blood;
    }
}

Java复制代码public int decreaseBlood() {
    synchronized(this) {
       blood = blood - 5;
       return blood;
    }
}

public synchronized int decreaseBlood() {
       blood = blood - 5;
       return blood;
}

Java复制代码public static int decreaseBlood() {
    synchronized(Master.class) {
       blood = blood - 5;
       return blood;
    }
}

public static synchronized int decreaseBlood() {
       blood = blood - 5;
       return blood;
}

xml复制代码<properties>
    <erupt.version>1.6.13</erupt.version>
</properties>

xml复制代码<dependencies>
    <!--用户权限管理-->
    <dependency>
        <groupId>xyz.erupt</groupId>
        <artifactId>erupt-upms</artifactId>
        <version>${erupt.version}</version>
    </dependency>
    <!--接口数据安全-->
    <dependency>
        <groupId>xyz.erupt</groupId>
        <artifactId>erupt-security</artifactId>
        <version>${erupt.version}</version>
    </dependency>
    <!--后台WEB界面-->
    <dependency>
        <groupId>xyz.erupt</groupId>
        <artifactId>erupt-web</artifactId>
        <version>${erupt.version}</version>
    </dependency>
    <!--Mysql数据库驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.15</version>
    </dependency>
</dependencies>

yaml复制代码spring:
  datasource:
    url: jdbc:mysql://localhost:3306/erupt?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
    username: root
    password: root
  jpa:
    show-sql: true
    generate-ddl: true
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
    database: mysql

java复制代码/**
 * Created by macro on 2021/4/13.
 */
@Configuration
@ComponentScan({"xyz.erupt","com.macro.mall.tiny"})
@EntityScan({"xyz.erupt","com.macro.mall.tiny"})
@EruptScan({"xyz.erupt","com.macro.mall.tiny"})
public class EruptConfig {
}

java复制代码@Erupt(name = "商品品牌")
@Table(name = "pms_brand")
@Entity
public class PmsBrand {

    @Id
    @GeneratedValue(generator = "generator")
    @GenericGenerator(name = "generator", strategy = "native")
    @Column(name = "id")
    @EruptField
    private Long id;

    @EruptField(
            views = @View(title = "品牌名称"),
            edit = @Edit(title = "品牌名称",notNull=true,search = @Search(vague = true))
    )
    private String name;

    @EruptField(
            views = @View(title = "品牌首字母"),
            edit = @Edit(title = "品牌首字母",notNull=true)
    )
    private String firstLetter;

    @EruptField(
            views = @View(title = "品牌LOGO"),
            edit = @Edit(title = "品牌LOGO", type = EditType.ATTACHMENT,
                    attachmentType = @AttachmentType(type = AttachmentType.Type.IMAGE))
    )
    private String logo;

    @EruptField(
            views = @View(title = "品牌专区大图"),
            edit = @Edit(title = "品牌专区大图", type = EditType.ATTACHMENT,
                    attachmentType = @AttachmentType(type = AttachmentType.Type.IMAGE))
    )
    private String bigPic;

    @EruptField(
            views = @View(title = "品牌故事"),
            edit = @Edit(title = "品牌故事")
    )
    private String brandStory;

    @EruptField(
            views = @View(title = "排序"),
            edit = @Edit(title = "排序")
    )
    private Integer sort;

    @EruptField(
            views = @View(title = "是否显示"),
            edit = @Edit(title = "是否显示")
    )
    private Boolean showStatus;

    @EruptField(
            views = @View(title = "品牌制造商"),
            edit = @Edit(title = "品牌制造商")
    )
    private Boolean factoryStatus;

    private Integer productCount;

    private Integer productCommentCount;

}

xml复制代码<!--定时任务erupt-job-->
<dependency>
    <groupId>xyz.erupt</groupId>
    <artifactId>erupt-job</artifactId>
    <version>${erupt.version}</version>
</dependency>

yaml复制代码spring:
  mail:
    username: xxxxxx@qq.com
    password: 123456
    host: smtp.exmail.qq.com
    port: 465
    properties:
      mail.smtp.ssl.auth: true
      mail.smtp.ssl.enable: true
      mail.smtp.ssl.required: true

java复制代码/**
 * Created by macro on 2021/4/13.
 */
@Service
@Slf4j
public class JobHandlerImpl implements EruptJobHandler {
    @Override
    public String exec(String code, String param) throws Exception {
        log.info("定时任务已经执行，code:{},param:{}",code,param);
        return "success";
    }
}

xml复制代码<!-- 代码生成器 erupt-generator -->
<dependency>
    <groupId>xyz.erupt</groupId>
    <artifactId>erupt-generator</artifactId>
    <version>${erupt.version}</version>
</dependency>

xml复制代码<!--服务器监控 erupt-monitor-->
<dependency>
    <groupId>xyz.erupt</groupId>
    <artifactId>erupt-monitor</artifactId>
    <version>${erupt.version}</version>
</dependency>

yaml复制代码spring:
  redis:
    host: localhost # Redis服务器地址
    database: 1 # Redis数据库索引（默认为0）
    port: 6379 # Redis服务器连接端口
    password: 123456 # Redis服务器连接密码（默认为空）
    timeout: 3000ms # 连接超时时间
erupt:
  # 开启redis方式存储session，默认false，开启后需在配置文件中添加redis配置
  redisSession: true

xml复制代码<!--NoSQL数据源 erupt-mongodb-->
<dependency>
    <groupId>xyz.erupt</groupId>
    <artifactId>erupt-mongodb</artifactId>
    <version>${erupt.version}</version>
</dependency>

yaml复制代码spring:
  data:
    mongodb:
      host: localhost # mongodb的连接地址
      port: 27017 # mongodb的连接端口号
      database: erupt # mongodb的连接的数据库

java复制代码/**
 * Created by macro on 2021/4/13.
 */
@EruptDataProcessor(EruptMongodbImpl.MONGODB_PROCESS)  //此注解表示使用MongoDB来存储数据
@Document(collection = "product")
@Erupt(
        name = "商品管理",
        orderBy = "sort"
)
public class PmsProduct {
    @Id
    @EruptField
    private String id;

    @EruptField(
            views = @View(title = "商品名称", sortable = true),
            edit = @Edit(title = "商品名称", search = @Search(vague = true))
    )
    private String name;

    @EruptField(
            views = @View(title = "副标题", sortable = true),
            edit = @Edit(title = "副标题", search = @Search(vague = true))
    )
    private String subTitle;

    @EruptField(
            views = @View(title = "价格", sortable = true),
            edit = @Edit(title = "价格")
    )
    private Double price;

    @EruptField(
            views = @View(title = "商品图片"),
            edit = @Edit(title = "商品图片", type = EditType.ATTACHMENT,
                    attachmentType = @AttachmentType(type = AttachmentType.Type.IMAGE))
    )
    private String pic;

    @EruptField(
            views = @View(title = "状态", sortable = true),
            edit = @Edit(title = "状态",
                    boolType = @BoolType(trueText = "上架", falseText = "下架"),
                    search = @Search)
    )
    private Boolean publishStatus;

    @EruptField(
            views = @View(title = "创建时间", sortable = true),
            edit = @Edit(title = "创建时间", search = @Search(vague = true))
    )
    private Date createTime;
}

java复制代码@EruptDataProcessor(EruptMongodbImpl.MONGODB_PROCESS)  //此注解表示使用MongoDB来存储数据
@Document(collection = "product")
@Erupt(
        name = "商品管理",
        orderBy = "sort"
)
public class PmsProduct {
    //...省略若干代码
}

xml复制代码<!--在线接口开发 erupt-magic-api-->
<dependency>
    <groupId>xyz.erupt</groupId>
    <artifactId>erupt-magic-api</artifactId>
    <version>${erupt.version}</version>
</dependency>

yaml复制代码erupt:
  # 设置具体哪些包被jackson消息转化而不是gson
  jacksonHttpMessageConvertersPackages:
    - org.ssssssss

magic-api:
  web: /magic/web
  # 接口配置文件存放路径
  resource.location: D:/erupt/magic-script

javascript复制代码var sql = "select * from pms_brand";    
return db.select(sql);

java复制代码public abstract class Handler {

    protected Handler handler;

    public void setHandler(Handler handler) {
        this.handler = handler;
    }
    public abstract void handleRequest(Integer times);
}

java复制代码public class FirstInterview extends Handler {
    @Override
    public void handleRequest(Integer times) {
        // 条件判断是否是属于当前Handler的处理范围之内，不是则向下传递Handler处理器
        if(times ==1){
          // 假设这里是处理的业务逻辑代码
            System.out.println("第一次面试"+times);
        }
        handler.handleRequest(times);
    }
}

java复制代码public class ThreeInterview extends Handler {
    @Override
    public void handleRequest(Integer times) {
        if (times == 3) {
            System.out.println("第三次面试"+ times + "，恭喜面试通过，HR会跟你联      系！！！");
        }
    }

    public static void main(String[] args) {
        Handler first = new FirstInterview();
        Handler second = new SecondInterview();
        Handler three = new ThreeInterview();
        first.setHandler(second);
        second.setHandler(three);

        // 第一次面试
        first.handleRequest(1);
        System.out.println();
        // 第二次面试
        first.handleRequest(2);
        System.out.println();
        // 第三次面试
        first.handleRequest(3);
        System.out.println();
    }
}

java复制代码public abstract class AbstractDataHandler<T> {

    // 处理模块化数据
    protected abstract T doRequest(String query) throws Exception;
}

java复制代码@Component
public class ItemInfoHandler extends AbstractDataHandler<ItemInfoHandler.ItemInfo> {
    @Override
    protected ItemInfoHandler.ItemInfo doRequest(String query) {
        ItemInfoHandler.ItemInfo info = new ItemInfo();
        info.setItemId(123456L);
        info.setItemName("测试商品");
        return info;
    }

    @Data
    public static class ItemInfo {
        private Long itemId;
        private String itemName;
    }
}

scala复制代码@Component
public class SkuInfoHandler extends AbstractDataHandler<SkuInfoHandler.SkuInfo> {
    @Override
    protected SkuInfoHandler.SkuInfo doRequest(String query) {
        SkuInfoHandler.SkuInfo info = new SkuInfoHandler.SkuInfo();
        info.setSkuId(78910L);
        info.setSkuName("测试SKU");
        return info;
    }
    @Data
    public static class SkuInfo {
        private Long skuId;
        private String skuName;
    }
}

java复制代码@Component
public class DataAggregation {
    @Autowired
    private SkuInfoHandler skuInfoHandler;
    @Autowired
    private ItemInfoHandler itemInfoHandler;

    public Map convertItemDetail() throws Exception {
       Map result = new HashMap();
       result.put("skuInfoHandler", skuInfoHandler.doRequest("模拟数据请求"));
       result.put("itemInfoHandler",itemInfoHandler.doRequest("模拟数据请求"));
       return result;
    }

    public static void main(String[] args) throws Exception {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        DataAggregation dataAggregation = (DataAggregation) applicationContext.getBean("dataAggregation");
        Map map = dataAggregation.convertItemDetail();
        System.out.println(JSON.toJSONString(map));
      // 打印的结果数据
      // {"skuInfoHandler":{"skuId":78910,"skuName":"测试SKU"},"itemInfoHandler":{"itemId":123456,"itemName":"测试商品"}}
    }
}

java复制代码/** Initialize your data structure here. */
public Trie() {
    root = new TrieNode();
}

java复制代码/** Inserts a word into the trie. */
public void insert(String word) {
    TrieNode curr = root;

    for (char c : word.toCharArray()) {
        if (curr.childs[c - 'a'] == null) {
            curr.childs[c - 'a'] = new TrieNode();
        }
        curr = curr.childs[c - 'a'];
    }

    curr.isEnd = true;
}

java复制代码/** Returns if the word is in the trie. */
public boolean search(String word) {
    TrieNode curr = root;

    for (char c : word.toCharArray()) {
        if (curr.childs[c - 'a'] == null) return false;
        curr = curr.childs[c - 'a'];
    }

    return curr.isEnd;
}

java复制代码class Trie {

    class TrieNode {
        boolean isEnd;
        TrieNode[] childs = new TrieNode[26];
    }

    TrieNode root;

    /** Initialize your data structure here. */
    public Trie() {
        root = new TrieNode();
    }
    
    /** Inserts a word into the trie. */
    public void insert(String word) {
        TrieNode curr = root;

        for (char c : word.toCharArray()) {
            if (curr.childs[c - 'a'] == null) {
                curr.childs[c - 'a'] = new TrieNode();
            }
            curr = curr.childs[c - 'a'];
        }

        curr.isEnd = true;
    }
    
    /** Returns if the word is in the trie. */
    public boolean search(String word) {
        TrieNode curr = root;

        for (char c : word.toCharArray()) {
            if (curr.childs[c - 'a'] == null) return false;
            curr = curr.childs[c - 'a'];
        }

        return curr.isEnd;
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    public boolean startsWith(String prefix) {
        TrieNode curr = root;

        for (char c : prefix.toCharArray()) {
            if (curr.childs[c - 'a'] == null) return false;
            curr = curr.childs[c - 'a'];
        }

        return true;
    }
}

java复制代码class Solution {

    private final int MAX_BIT = 30; // 最大位数

    private Trie root = new Trie();

    public int findMaximumXOR(int[] nums) {
        int ans = 0;

        for (int num : nums) {
            add(num);
            // 每加入一个数字找一下这个数字和当前前缀树里的数的最大异或结果
            ans = Math.max(ans, find(num));
        }

        return ans;
    }

    public void add(int num) {
        Trie cur = root;

        // 从最高位到最低位
        for (int k = MAX_BIT; k >= 0; k--) {
            int bit = (num >> k) & 1; // 计算当前位是什么

            if (bit == 0) {
                if (cur.left == null)
                    cur.left = new Trie(); // 如果不存在这个结点，就创建一个
                cur = cur.left;
            } else {
                if (cur.right == null)
                    cur.right = new Trie(); // 如果不存在这个结点，就创建一个
                cur = cur.right;
            }
        }
    }

    public int find(int num) {
        Trie cur = root;
        int res = 0;

        // 从最高位到最低位
        for (int k = MAX_BIT; k >= 0; k--) {
            int bit = (num >> k) & 1; // 计算当前位是什么

            if (bit == 0) {
                // 当前位是 0，找 1
                if (cur.right != null) {
                    res = (res << 1) + 1; // 找到 1 了，这一位可以直接置为 1
                    cur = cur.right;
                } else {
                    // 没找到
                    res = res << 1; // 没有找到 1 ，这一位就只能是 0 了
                    cur = cur.left;
                }   
            } else {
                // 当前位是 1，找 0
                if (cur.left != null) {
                    res = (res << 1) + 1; // 找到 0 了，这一位可以直接置为 1
                    cur = cur.left;
                } else {
                    // 没找到
                    res = res << 1; // 没有找到 0 ，这一位就只能是 0 了
                    cur = cur.right;
                }
            }
        }

        return res;
    }
}

class Trie {
    Trie left = null; // 记录该位为 0
    Trie right = null; // 记录该位为 1
}

mysql复制代码[CONSTRAINT <外键名>] FOREIGN KEY 字段名 [，字段名2，…]
REFERENCES <主表名> 主键列1 [，主键列2，…]

mysql复制代码mysql> CREATE TABLE demo_dept
    -> (
    -> id INT(11) PRIMARY KEY,
    -> name VARCHAR(22) NOT NULL,
    -> location VARCHAR(50)
    -> );
Query OK, 0 rows affected (0.37 sec)

mysql复制代码mysql> CREATE TABLE demo_employee
    -> (
    -> id INT(11) PRIMARY KEY,
    -> name VARCHAR(25),
    -> dept_id INT(11),
    -> salary FLOAT,
    -> CONSTRAINT fk_emp_dept
    -> FOREIGN KEY(dept_id) REFERENCES demo_dept(id)
    -> );
Query OK, 0 rows affected (0.37 sec)
mysql> DESC demo_employee;
+--------+-------------+------+-----+---------+-------+
| Field  | Type        | Null | Key | Default | Extra |
+--------+-------------+------+-----+---------+-------+
| id     | int(11)     | NO   | PRI | NULL    |       |
| name   | varchar(25) | YES  |     | NULL    |       |
| dept_id| int(11)     | YES  | MUL | NULL    |       |
| salary | float       | YES  |     | NULL    |       |
+--------+-------------+------+-----+---------+-------+
4 rows in set (1.33 sec)

mysql复制代码ALTER TABLE <数据表名> ADD CONSTRAINT <索引名> FOREIGN KEY (<列名>)  REFERENCES <主表名>(<列名>);

mysql复制代码mysql> ALTER TABLE tb_employee
    -> ADD CONSTRAINT fk_demo_dept
    -> FOREIGN KEY(dept_id)
    -> REFERENCES demo_dept(id);
Query OK, 0 rows affected (1.38 sec)
Records: 0  Duplicates: 0  Warnings: 0

mysql> SHOW CREATE TABLE tb_employee\G
*************************** 1. row ***************************
       Table: tb_employee
Create Table: CREATE TABLE `tb_employee` (
  `id` int(11) NOT NULL,
  `name` varchar(30) DEFAULT NULL,
  `dept_id` int(11) DEFAULT NULL,
  `salary` float DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `fk_demo_dept` (`dept_id`),
  CONSTRAINT `fk_demo_dept` FOREIGN KEY (`dept_id`) REFERENCES `demo_dept` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=gb2312
1 row in set (0.12 sec)

mysql复制代码mysql> ALTER TABLE tb_employee
    -> DROP FOREIGN KEY fk_demo_dept;
Query OK, 0 rows affected (0.19 sec)
Records: 0  Duplicates: 0  Warnings: 0

mysql> SHOW CREATE TABLE tb_employee\G
*************************** 1. row ***************************
       Table: tb_employee
Create Table: CREATE TABLE `tb_employee` (
  `id` int(11) NOT NULL,
  `name` varchar(30) DEFAULT NULL,
  `dept_id` int(11) DEFAULT NULL,
  `salary` float DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `fk_demo_dept` (`dept_id`)
) ENGINE=InnoDB DEFAULT CHARSET=gb2312
1 row in set (0.00 sec)

java复制代码
C31- RequestMappingHandlerMapping : 扫描的起点 , 因为类实现了 InitializingBean 接口 , 其核心基于 afterPropertiesSet
    M- afterPropertiesSet
        ?- 这个方法中主要对  RequestMappingInfo.BuilderConfiguration 进行配置 ,最后调用父类 afterPropertiesSet 方法
    
C32- AbstractHandlerMethodMapping
    M32_01- afterPropertiesSet
        - initHandlerMethods() : 核心方法 , 对 Handler Method 进行处理 -> M32_02
    M32_02- initHandlerMethods 
        ?- 扫描ApplicationContext中的bean，检测和注册处理程序方法
        - 获取所有的 BeanName , 调用 processCandidateBean 执行 -> M32_03
    M32_03- processCandidateBean
        - obtainApplicationContext().getType 获取具体的 Class 类
        - 通过 isHandler 判断是否包含 Controller 或者 RequestMapping 
            ?- RestController 继承了 Controller
            - 如果需要处理 , 调用 detectHandlerMethods 处理 -> M32_04
    M32_04- detectHandlerMethods
        - 同样的 , 通过传入的 handle (类的别名) 获取对应的 Class<?>
        - 获取所有的标注了注解的集合 Map<Method, T> -> ps:M32_04_01
            - getMappingForMethod 获取注解对应的 Condition -> ps:M32_04_01 详细流程
            - selectMethods
        FOR- 循环所有的 methods , 首先搜索可用的代理 , 注册对应的 Bean
            ?- 代理是 Spring 中很重要的一环 , 后面开单章详细说
    M32_05- registerHandlerMethod
        - 注册到 MappingRegistry
                
            
// ps:M32_04_01 流程详细分析
Map<Method, T> methods = MethodIntrospector.selectMethods(userType,(MethodIntrospector.MetadataLookup<T>) method -> {
    return getMappingForMethod(method, userType);
});

// 可以看到 , 其中核心的方法有2个 getMappingForMethod / selectMethods
getMappingForMethod 会返回Mapping 对应的 Condition , 例如 patternsCondition / methodCondition
    

// ps:M32_04_01
protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
    // 此处对 RequestMapping 进行了扫描操作
    // 代码比较简单 , 就是 AnnotatedElementUtils.findMergedAnnotation 后构建了一个 RequestMappingInfo bean
    RequestMappingInfo info = createRequestMappingInfo(method);
    if (info != null) {
        // 此处是获取 Class 类上面的 RequestMapping
        RequestMappingInfo typeInfo = createRequestMappingInfo(handlerType);
        if (typeInfo != null) {
             // 对2者进行组合 , 生成新的 Bean 对象
             // 注意是类 组合 方法
             // 主要是覆盖和合并 , url 比较特殊 , 变化为 /get -> /cookie/get
            info = typeInfo.combine(info);
        }
        
        // 前缀 path 的处理 , 该属性在配置 PathMatchConfigurer 时处理 , 可以通过 addPathPrefix 添加
        String prefix = getPathPrefix(handlerType);
        if (prefix != null) {
            info = RequestMappingInfo.paths(prefix).options(this.config).build().combine(info);
        }
    }
    return info;
}

java复制代码            
C- AbstractHandlerMethodMapping
    VC33- MappingRegistry : 内部类 
        F33_01- Map<T, MappingRegistration<T>> registry = new HashMap<>();
        F33_02- Map<T, HandlerMethod> mappingLookup = new LinkedHashMap<>();
        F33_03- MultiValueMap<String, T> urlLookup = new LinkedMultiValueMap<>();
        F33_04- Map<String, List<HandlerMethod>> nameLookup = new ConcurrentHashMap<>();
        F33_05- Map<HandlerMethod, CorsConfiguration> corsLookup = new ConcurrentHashMap<>();
        M33_01- register(T mapping, Object handler, Method method)  -> PS:M33_01
            ?- 此处主要是为了构建 Map 集合 , 用于映射时匹配
            1- 通过 handler 和 Method 构建了使用时的主要单元Bean HandlerMethod
            2- 以 RequestMappingInfo(mapping) 为key 将 HandlerMethod 放入 Map (F33_02) 集合 
            3- 以 URL 字符串为 key , 将 以 RequestMappingInfo(mapping) 放入 Map 集合 (F33_03)
            4- 以 Name (策略类构建特殊的 mappingName)为 key , 将 handlerMethod 放入 Map (F33_04) -> PS:M33_02
            5- 以 HandlerMethod 为 key , 将 CorsConfiguration 放入集合 Map (F33_05)
            6- 以 RequestMappingInfo(mapping) 为key , 生成一个 MappingRegistration 放入集合 registry (F33_01)
            
        
// PS:M33_01 register 方法的关键和亮点
1- 使用 ReentrantReadWriteLock  保证多线程下访问的唯一性 , 在 finally 中解锁

// PS:M33_02 特殊的命名方式 RequestMappingInfoHandlerMethodMappingNamingStrategy
这里主要通过 RequestMappingInfoHandlerMethodMappingNamingStrategy 类生成对应的 Name
    
    
// M33_01 伪代码
public void register(T mapping, Object handler, Method method) {
    this.readWriteLock.writeLock().lock();
    try {
        // 1- 通过 handler 和 Method 构建了使用时的主要单元Bean HandlerMethod
        HandlerMethod handlerMethod = createHandlerMethod(handler, method);
        validateMethodMapping(handlerMethod, mapping);
        
        // 2- 以 RequestMappingInfo(mapping) 为key 将 HandlerMethod 放入 Map (F33_02) 集合 
        this.mappingLookup.put(mapping, handlerMethod);

        List<String> directUrls = getDirectUrls(mapping);
        for (String url : directUrls) {
            // 3- 以 URL 字符串为 key , 将 以 RequestMappingInfo(mapping) 放入 Map 集合 (F33_03)
            this.urlLookup.add(url, mapping);
        }

        String name = null;
        if (getNamingStrategy() != null) {
            name = getNamingStrategy().getName(handlerMethod, mapping);
            // 4- 以 Name (策略类构建特殊的 mappingName)为 key , 将 handlerMethod 放入 Map (F33_04) 
            addMappingName(name, handlerMethod);
        }
        
        // 构建跨域配置
        CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);
        if (corsConfig != null) {
            5- 以 HandlerMethod 为 key , 将 CorsConfiguration 放入集合 Map (F33_05)
            this.corsLookup.put(handlerMethod, corsConfig);
        }
        // 6- 以 RequestMappingInfo(mapping) 为key , 生成一个 MappingRegistration 放入集合 registry
        this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directUrls, name));
    }finally {
        this.readWriteLock.writeLock().unlock();
    }
}
    

// 自此 , Mapper 的前期准备就完成了

java复制代码StandardWrapper -> GenericServlet (init) -> HttpServletBean (init) -> FrameworkServlet (initServletBean)

java复制代码C51- DispatcherServlet 
    M51_10- initHandlerMappings(ApplicationContext context)
        ?- 这个方法的核心操作就是初始化 handlerMappings -> PS:M51_10_01
        - 通过 BeanFactoryUtils 构建所有的 Mapping 类型结合  
        - 为 Map 进行排序

java复制代码                  
C- ServletWebServerApplicationContext
    M- selfInitialize
        - getServletContextInitializerBeans 其中会获取所有的 Beans  , 分别调用 beans.onStartup 启动
    M- getServletContextInitializerBeans
        - 核心处理逻辑在 ServletContextInitializerBeans 中
            
C- ServletContextInitializerBeans
    M- ServletContextInitializerBeans(ListableBeanFactory beanFactory,Class<? extends ServletContextInitializer>... initializerTypes)
        ?- 此方法中会获取 Servlet 和 Filter 的初始化类 --> TODO : 后续单独分析 Serlvet 时看

java复制代码            
// Filter 的拦截调用
Filter 的核心思路就是 FilterChain 的链表调用 . 其起点为  ApplicationFilterChain 
C- ApplicationFilterChain
    F- private ApplicationFilterConfig[] filters = new ApplicationFilterConfig[0];
        - 选择一个 ApplicationFilterConfig , 调用 doFilter , 并且把当前对象传入
             ?- 后续就是调用链的逻辑
            
            
            
            
// HandlerInterceptor 的处理流程
- 与 Filter 不同的是 , 这里的 HandlerInterceptor 是 Spring 体系中的对象
- 拦截器主要在 WebMvcConfigurer 通过 InterceptorRegistry 手动注入             

@Override
public void addInterceptors(InterceptorRegistry registry) {
    logger.info("------> this is addInterceptors  <-------");
    registry.addInterceptor(new ConfigInterceptor());
}

// Interceptor 的初始化
Interceptor 的主要起点是 WebMvcConfigurationSupport
C- WebMvcConfigurationSupport
    M- requestMappingHandlerMapping
        - 其中会为当前 Mapping 添加 Interceptor

    
// Interceptor 的调用
Interceptor 的主调流程位于 HandlerExecutionChain
C- HandlerExecutionChain
    M- applyPreHandle
        - getInterceptors() 获取 HandlerInterceptor->LV001 数组
        FOR- 循环 HandlerInterceptor:LV001 调用 preHandle
            

// DispatcherServlet 衔接到 RequestMapping 映射关联
- ApplicationFilterChain 处理完成 Filter 
//  这里会进行一次继承类的循环调用
C- DispatcherServlet
    M- FrameworkServlet
        M- HttpServlet
            
- HttpServlet 执行 service(ServletRequest req, ServletResponse res) 方法
- FrameworkServlet 执行 service(HttpServletRequest request, HttpServletResponse response) 方法        
- HttpServlet 执行 service(HttpServletRequest request, HttpServletResponse response) 方法
- FrameworkServlet 执行 doGet 处理请求
- FrameworkServlet 执行 processRequest 开始完整处理
- 来到具体实现类 DispatcherServlet

java复制代码Start -> HttpServlet
// TODO : Dispatch 具体流程以后单独分析 , 这里先简单过一下
C51- DispatcherServlet 
    M51_01- doService(HttpServletRequest request, HttpServletResponse response)
        ?- 执行 Service 处理请求
        - 调用 M51_02 执行具体的流程
    M51_02- doDispatch(HttpServletRequest request, HttpServletResponse response)
        1- WebAsyncUtils.getAsyncManager(request) : 准备异步处理管理器 WebAsyncManager -> PS:M51_02_01
        2- checkMultipart(request) : 尝试解析 Multipart Request -> PS:M51_02_02
        3- getHandler(processedRequest) : 获取具体需要执行的 Handler -> M51_03
            ?- 未找到对应的 Handler 会直接 return
        4- getHandlerAdapter(mappedHandler.getHandler()) : 确定当前请求的处理程序适配器 -> PS:M51_02_04
        5- 处理 Get-Head 请求 -> PS:M51_02_05
        - mappedHandler.applyPreHandle : 前置处理
        6- 调用 HandlerAdapter 处理 请求
        7- applyDefaultViewName : view 名称的解析 , 此环节不分析
        - mappedHandler.applyPostHandle : 后置处理 -> PS:M51_02_09
    M51_03- getHandler
    M51_04- getHandlerAdapter    

// M51_03 源代码
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    if (this.handlerMappings != null) {
        for (HandlerMapping mapping : this.handlerMappings) {
            HandlerExecutionChain handler = mapping.getHandler(request);
            if (handler != null) {
                return handler;
            }
        }
    }
    return null;
}


//  M51_04 getHandlerAdapter 源代码
protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
    if (this.handlerAdapters != null) {
        for (HandlerAdapter adapter : this.handlerAdapters) {
            // 太常见的处理方式 , 循环处理中通过 support 判断
            if (adapter.supports(handler)) {
                return adapter;
            }
        }
    }
    throw new ServletException("....");
}

java复制代码getHandler -> HandlerExecutionChain
getHandlerAdapter -> HandlerAdapter

// HandlerExecutionChain 的作用 :
- HandlerExecutionChain 是 Handler 的处理器链 , 其中包含了 HandlerInterceptor 的数组和对应的 Handler 

// HandlerAdapter 的作用　:
- 首先 , 看名字就知道 , 这是个适配器 , 适配器能在原有功能上扩展新的功能
- MVC框架SPI，允许参数化核心MVC工作流 , 该接口用于允许DispatcherServlet无限扩展。
- DispatcherServlet通过这个接口访问所有已安装的处理程序

java复制代码- mappedHandler.applyPreHandle : 前置处理
- mappedHandler.applyPostHandle : 后置处理 

// 这2个方法主要是对拦截器的处理 , 可以看到其中直接调用拦截器的方法
boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HandlerInterceptor[] interceptors = getInterceptors();
    if (!ObjectUtils.isEmpty(interceptors)) {
        for (int i = 0; i < interceptors.length; i++) {
            HandlerInterceptor interceptor = interceptors[i];
            if (!interceptor.preHandle(request, response, this.handler)) {
                triggerAfterCompletion(request, response, null);
                return false;
            }
            this.interceptorIndex = i;
        }
    }
    return true;
}

java复制代码
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        boolean multipartRequestParsed = false;

        // 准备异步处理管理器 WebAsyncManager
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

        try {
            ModelAndView mv = null;
            Exception dispatchException = null;

            try {
                // 尝试解析 Multipart Request
                processedRequest = checkMultipart(request);
                multipartRequestParsed = (processedRequest != request);

                // 获取具体需要执行的 Handler
                mappedHandler = getHandler(processedRequest);
                if (mappedHandler == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }

                // 确定当前请求的处理程序适配器
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

                // 处理 Get-Head 请求
                String method = request.getMethod();
                boolean isGet = "GET".equals(method);
                if (isGet || "HEAD".equals(method)) {
                    long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                    if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                        return;
                    }
                }

                // 拦截器前置处理
                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }

                // 调用 HandlerAdapter 处理 请求
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

                if (asyncManager.isConcurrentHandlingStarted()) {
                    return;
                }

                applyDefaultViewName(processedRequest, mv);
                // 拦截器后置处理
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            }
            catch (Exception ex) {
                dispatchException = ex;
            }
            catch (Throwable err) {
                // As of 4.3, we're processing Errors thrown from handler methods as well,
                // making them available for @ExceptionHandler methods and other scenarios.
                dispatchException = new NestedServletException("Handler dispatch failed", err);
            }
            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复制代码C76- AbstractHandlerMapping 
    M76_01- HandlerExecutionChain getHandler(HttpServletRequest request) : 构建处理链
        - getHandlerInternal(request) 获取处理的 Handler -> M32_01
        - 通过 Handler 构建 HandlerExecutionChain TODO 
        - 跨域配置的处理 CorsConfiguration
    M76_02- getHandlerInternal
        - 调用 父类 -> M32_01

C32- AbstractHandlerMethodMapping
   M32_01- getHandlerInternal(HttpServletRequest request)
        - 先配置了一个读锁
        - 调用 lookupHandlerMethod -> M32_02
   M32_02- lookupHandlerMethod : 对请求做真正的处理 , 获取 HandlerMethod
        1- 构建 List<Match> 用于存放匹配结果
        - MappingRegistry 通过 lookupPath 获取对象 List<RequestMappingInfo>
               ?- 底层实际上是调用上文初始化使用的 urlLookup.get(urlPath)
        - 调用 addMatchingMappings  , 将匹配的 Match放入 1 步构建的 List 中
        - 返回处理的 Method

java复制代码protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
        List<Match> matches = new ArrayList<>();
        // 从 MappingRegistry 中获取 Mapping List
        List<T> directPathMatches = this.mappingRegistry.getMappingsByUrl(lookupPath);
        if (directPathMatches != null) {
            addMatchingMappings(directPathMatches, matches, request);
        }
        if (matches.isEmpty()) {
            // No choice but to go through all mappings...
            addMatchingMappings(this.mappingRegistry.getMappings().keySet(), matches, request);
        }
        // 如果匹配项不为空 
        if (!matches.isEmpty()) {
             // {POST /test/getBody}
            Match bestMatch = matches.get(0);
            // 进行匹配 , 获取对应的 HandlerMethod
            if (matches.size() > 1) {
                Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
                matches.sort(comparator);
                bestMatch = matches.get(0);
                if (CorsUtils.isPreFlightRequest(request)) {
                    return PREFLIGHT_AMBIGUOUS_MATCH;
                }
                Match secondBestMatch = matches.get(1);
                if (comparator.compare(bestMatch, secondBestMatch) == 0) {
                    Method m1 = bestMatch.handlerMethod.getMethod();
                    Method m2 = secondBestMatch.handlerMethod.getMethod();
                    String uri = request.getRequestURI();
                    throw new IllegalStateException(
                            "Ambiguous handler methods mapped for '" + uri + "': {" + m1 + ", " + m2 + "}");
                }
            }
            
            // request.setAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, lookupPath) -> PS:M32_02_01
            request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.handlerMethod);
             
            handleMatch(bestMatch.mapping, lookupPath, request);
            return bestMatch.handlerMethod;
        }
        else {
            return handleNoMatch(this.mappingRegistry.getMappings().keySet(), lookupPath, request);
        }
    }

// PS:M32_02_01
String PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE = HandlerMapping.class.getName() + ".pathWithinHandlerMapping";

java复制代码protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
            HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

        ServletWebRequest webRequest = new ServletWebRequest(request, response);
        try {
            WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
            ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
            
            // 扩展InvocableHandlerMethod，通过注册的HandlerMethodReturnValueHandler处理返回值
            ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
            if (this.argumentResolvers != null) {
                invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
            }
            if (this.returnValueHandlers != null) {
                invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
            }
            invocableMethod.setDataBinderFactory(binderFactory);
            invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
            
            // ModuleAndView 容器
            ModelAndViewContainer mavContainer = new ModelAndViewContainer();
            mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
            modelFactory.initModel(webRequest, mavContainer, invocableMethod);
            mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);

            AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
            asyncWebRequest.setTimeout(this.asyncRequestTimeout);

            WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
            asyncManager.setTaskExecutor(this.taskExecutor);
            asyncManager.setAsyncWebRequest(asyncWebRequest);
            
            // 异步管理器注册回调拦截器
            asyncManager.registerCallableInterceptors(this.callableInterceptors);
            asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);

            if (asyncManager.hasConcurrentResult()) {
                Object result = asyncManager.getConcurrentResult();
                mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0];
                asyncManager.clearConcurrentResult();
                invocableMethod = invocableMethod.wrapConcurrentResult(result);
            }

            invocableMethod.invokeAndHandle(webRequest, mavContainer);
            if (asyncManager.isConcurrentHandlingStarted()) {
                return null;
            }

            return getModelAndView(mavContainer, modelFactory, webRequest);
        }
        finally {
            webRequest.requestCompleted();
        }
    }

java复制代码


        
// Web 模块最终步骤     
C- InvocableHandlerMethod 

        
// 代码最终步骤 : 调用 Method 的 invoke 方法 , 去完成具体的逻辑        
C39- Method 
    M39_01- invoke(Object obj, Object... args)
        ?- 通过此方法调用最后的代理类 . java 反射包中方法 ,省略

java复制代码C- RequestMappingHandlerAdapter
    M- invokeHandlerMethod(HttpServletRequest request,HttpServletResponse response, HandlerMethod handlerMethod)
        - invocableMethod.invokeAndHandle(webRequest, mavContainer)

// Step 1 : 处理的入口
public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
            Object... providedArgs) throws Exception {
    
    //  将 Request 解析处理
    Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
    setResponseStatus(webRequest);

    if (returnValue == null) {
        if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
            disableContentCachingIfNecessary(webRequest);
            mavContainer.setRequestHandled(true);
            return;
        }
    } else if (StringUtils.hasText(getResponseStatusReason())) {
        mavContainer.setRequestHandled(true);
        return;
    }

    mavContainer.setRequestHandled(false);
    try {
        this.returnValueHandlers.handleReturnValue(returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
    } catch (Exception ex) {
        throw ex;
    }
}


// PS : invokeForRequest 中主要流程
C- InvocableHandlerMethod 
    M- invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,Object... providedArgs)    
        - getMethodArgumentValues(request, mavContainer, providedArgs)
            ?- 详见下文参数获取

java复制代码    protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
            Object... providedArgs) throws Exception {

        MethodParameter[] parameters = getMethodParameters();
        if (ObjectUtils.isEmpty(parameters)) {
            return EMPTY_ARGS;
            }
        
        // 构建一个 Object 数组用于存放 param
        Object[] args = new Object[parameters.length];
        for (int i = 0; i < parameters.length; i++) {
            MethodParameter parameter = parameters[i];
            parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
            args[i] = findProvidedArgument(parameter, providedArgs);
            if (args[i] != null) {
                continue;
            }
            if (!this.resolvers.supportsParameter(parameter)) {
                throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
            }
            try {
                  // 解析参数主体
                args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
            }
            catch (Exception ex) {
                throw ex;
            }
        }
        return args;
}



public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
            NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

    HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
    if (resolver == null) {
        throw new IllegalArgumentException("Unsupported parameter type [" +
                    parameter.getParameterType().getName() + "]. supportsParameter should be called first.");
    }
    return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
}

java复制代码 
public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
            NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

    parameter = parameter.nestedIfOptional();
    // 读取并且转换为相关对象
    Object arg = readWithMessageConverters(webRequest, parameter, parameter.getNestedGenericParameterType());
    String name = Conventions.getVariableNameForParameter(parameter);

    if (binderFactory != null) {
        WebDataBinder binder = binderFactory.createBinder(webRequest, arg, name);
        if (arg != null) {
            validateIfApplicable(binder, parameter);
            if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
                throw new MethodArgumentNotValidException(parameter, binder.getBindingResult());
            }
        }
        if (mavContainer != null) {
            mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
        }
    }
    return adaptArgumentIfNecessary(arg, parameter);
}


// Step  : 转换操作入口
protected <T> Object readWithMessageConverters(NativeWebRequest webRequest, MethodParameter parameter,
            Type paramType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {

    HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
    ServletServerHttpRequest inputMessage = new ServletServerHttpRequest(servletRequest);

    Object arg = readWithMessageConverters(inputMessage, parameter, paramType);
    if (arg == null && checkRequired(parameter)) {
        throw new HttpMessageNotReadableException("Required request body is missing: " +
                    parameter.getExecutable().toGenericString(), inputMessage);
    }
    return arg;
}