bash复制代码Code-Generate
├── pom.xml
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── mysql
│   │   │           ├── App.java                         // 程序入口
│   │   │           ├── bean
│   │   │           │   ├── ClassInfo.java               // 类实体（对应表维度）
│   │   │           │   ├── ConfigurationInfo.java       // 配置中心
│   │   │           │   ├── FieldInfo.java               // 字段实体（对应表字段维度）
│   │   │           │   └── GlobleConfig.java            // 全局配置
│   │   │           ├── engine
│   │   │           │   ├── AbstractEngine.java          // 抽象引擎
│   │   │           │   ├── GeneralEngine.java           // 接口引擎
│   │   │           │   └── impl            
│   │   │           │       ├── CustomEngineImpl.java    // 自定义引擎（拔插式基类）
│   │   │           │       └── DefaultEngine.java       // 默认引擎
│   │   │           ├── factory
│   │   │           │   ├── ClassInfoFactory.java        // 类工厂（非必要，可融进上述配置中心）
│   │   │           │   └── PropertiesFactory.java       // 配置文件工厂（非必要，可融进上述配置中心）
│   │   │           ├── intercept
│   │   │           │   ├── CustomEngine.java
│   │   │           │   └── impl
│   │   │           │       ├── DataMdImpl.java          // 自定义引擎案例一（数据库文档）
│   │   │           │       └── LayUiHtmlImpl.java       // 自定义引擎案例二（视图界面）
│   │   │           └── util
│   │   │               ├── DataBaseUtil.java            // 数据库依赖
│   │   │               ├── DBUtil.java                  // 数据库操作类
│   │   │               ├── IOTools.java                 // 工具类
│   │   │               └── StringUtil.java              // 工具类
│   │   ├── resources
│   │   │   ├── application.properties                   // 配置文件
│   │   │   ├── log4j2.xml                               // 日志配置
│   │   │   └── templates                                // 模板目录
│   │   └── test
│   └── META-INF
        └── MANIFEST.MF                                  // META-INF文件，为了打成Jar包使用（非必须）

bash复制代码# 数据库IP, 数据库Driver, 编码, 用户名, 密码
ip=127.0.0.1
port=3306
driver=com.mysql.jdbc.Driver
dataBase=school-miao
encoding=UTF-8
loginName=root
passWord=

# 需要构建的表名  为* 默认包含全部, 以;号隔离比如:  a;b;c;d;
include=*;

# 项目名
projectName=Demo

# 包名
packageName=com.demo

# 作者
authorName=Kerwin

# 项目输出根目录
rootPath=F:\\code

# 自定义Handle包含项, 现有自定义模块：DataMdImpl，LayUiHtmlImpl, * 号默认包含所有，以;号隔离比如:  a;b;c;d;
customHandleInclude=DataMdImpl;LayUiHtmlImpl;

mysql复制代码SELECT
	table_name 
FROM
	information_schema.TABLES 
WHERE
	table_schema = "school-miao-demo"  # 库名
	AND table_type = "base table";

# 响应
# schools

mysql复制代码SELECT
	column_name,
	data_type,
	column_comment,
	numeric_precision,
	numeric_scale,
	character_maximum_length,
	is_nullable nullable 
FROM
	information_schema.COLUMNS 
WHERE
	table_name = 'schools'                   # 表明
	AND table_schema = 'school-miao-demo';   # 库名

# 结果为
# column_name  data_type
# sname	       varchar

jsp复制代码package ${packageName}.entity;

import java.io.Serializable;
import lombok.Data;
import java.util.Date;
import java.util.List;

/**
 * ${classInfo.classComment}
 * @author ${authorName} ${.now?string('yyyy-MM-dd')}
 */
@Data
public class ${classInfo.className} implements Serializable {

    private static final long serialVersionUID = 1L;
	<#if classInfo.fieldList?exists && classInfo.fieldList?size gt 0>
		<#list classInfo.fieldList as fieldItem >

    /**
     * ${fieldItem.columnName}  ${fieldItem.fieldComment}
     */
    private ${fieldItem.fieldClass} ${fieldItem.fieldName};
		</#list>
	</#if>
}

java复制代码public final class CustomEngineImpl {

    /***
     * 扫描全包获取 实现CustomEngine接口的类
     */
    private static Set<Class<? extends CustomEngine>> toDos () {
        Reflections reflections = new Reflections(new ConfigurationBuilder()
                .setUrls(ClasspathHelper.forPackage(""))
                .filterInputsBy(input -> {
                    assert input != null;
                    return input.endsWith(".class");
                }));

        return reflections.getSubTypesOf(CustomEngine.class);
    }

    public static void handleCustom() {
        Set<Class<? extends CustomEngine>> classes = toDos();
        for (Class<? extends CustomEngine> aClass : classes) {

            // 基于配置项检测是否需要启用自定义实现类
            if("*;".equals(GlobleConfig.getGlobleConfig().getCustomHandleInclude()) ||
                    GlobleConfig.getGlobleConfig().getCustomHandleIncludeMap().containsKey(aClass.getSimpleName())) {
                try {
                    // 基于反射构建对象 - 调用handle方法
                    CustomEngine engine = aClass.newInstance();
                    engine.handle(GlobleConfig.getGlobleConfig(), ClassInfoFactory.getClassInfoList());
                } catch (InstantiationException | IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

jsp复制代码# 基础介绍

| 说明     | 内容 |
| :------- | ---- |
| 项目名   | ${config.projectName} |
| 作者     | ${config.authorName} |
| 数据库IP | ${config.ip} |
| 数据库名 | ${config.dataBase} |

<#if classInfos?exists && classInfos?size gt 0>
<#list classInfos as classInfo >
## ${classInfo.tableName}表结构说明
| 代码字段名 | 字段名 | 数据类型（代码） | 数据类型 | 长度 | NullAble | 注释 |
| :--------- | ------ | ---------------- | -------- | ---- | -------------- | ---- |
<#list classInfo.fieldList as fieldItem >
| ${fieldItem.fieldName} | ${fieldItem.columnName} | ${fieldItem.fieldClass} | ${fieldItem.dataType} | ${fieldItem.maxLength} | ${fieldItem.nullAble} | ${fieldItem.fieldComment} |
</#list>

</#list>
</#if>

java复制代码// 我是一个测试#{demo.name}
// 按行读取，触发#{}正则匹配时，将 demo.name 替换为 Map/其他数据结构的值即可。

jsp复制代码<#list classInfo.fieldList as fieldItem>
    /**
     * ${fieldItem.columnName}  ${fieldItem.fieldComment}
     */
    private ${fieldItem.fieldClass} ${fieldItem.fieldName};
</#list>

java复制代码/**
 * freemarker.core.Environment#visit(freemarker.core.TemplateElement)
 * "Visit" the template element.
 */
void visit(TemplateElement element) throws IOException, TemplateException {
  	// 临时数组，存储数据
    pushElement(element);
    try {
        
        // 构建子元素集
        TemplateElement[] templateElementsToVisit = element.accept(this);
        
        // 遍历子元素
        if (templateElementsToVisit != null) {
            for (TemplateElement el : templateElementsToVisit) {
                if (el == null) {
                    break;  // Skip unused trailing buffer capacity 
                }
                
                // 递归遍历
                visit(el);
            }
        }
    } catch (TemplateException te) {
        handleTemplateException(te);
    } finally {
        // 移出数据
        popElement();
    }
}

yaml复制代码server:
  port: 9005
spring:
  application:
    ## 指定服务名称，在nacos中的名字
    name: openFeign-provider
  cloud:
    nacos:
      discovery:
        # nacos的服务地址，nacos-server中IP地址:端口号
        server-addr: 127.0.0.1:8848
management:
  endpoints:
    web:
      exposure:
        ## yml文件中存在特殊字符，必须用单引号包含，否则启动报错
        include: '*'

xml复制代码<dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

java复制代码@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class OpenFeignConsumer9006Application
{
    public static void main(String[] args) {
        SpringApplication.run(OpenFeignConsumer9006Application.class, args);
    }
}

java复制代码@FeignClient(value = "openFeign-provider")
public interface OpenFeignService {
}

java复制代码@RestController
@RequestMapping("/openfeign")
public class OpenFeignController {
    
}

java复制代码@RestController
@RequestMapping("/openfeign/provider")
public class OpenFeignProviderController {
    @PostMapping("/order2")
    public Order createOrder2(@RequestBody Order order){
        return order;
    }
}

java复制代码@FeignClient(value = "openFeign-provider")
public interface OpenFeignService {
    /**
     * 参数默认是@RequestBody标注的，这里的@RequestBody可以不填
     * 方法名称任意
     */
    @PostMapping("/openfeign/provider/order2")
    Order createOrder2(@RequestBody Order order);
}

java复制代码@RestController
@RequestMapping("/openfeign/provider")
public class OpenFeignProviderController {
    @PostMapping("/order1")
    public Order createOrder1(Order order){
        return order;
    }
}

java复制代码@FeignClient(value = "openFeign-provider")
public interface OpenFeignService {
    /**
     * 参数默认是@RequestBody标注的，如果通过POJO表单传参的，使用@SpringQueryMap标注
     */
    @PostMapping("/openfeign/provider/order1")
    Order createOrder1(@SpringQueryMap Order order);
}

java复制代码@RestController
@RequestMapping("/openfeign/provider")
public class OpenFeignProviderController {

    @GetMapping("/test/{id}")
    public String test(@PathVariable("id")Integer id){
        return "accept one msg id="+id;
}

java复制代码@FeignClient(value = "openFeign-provider")
public interface OpenFeignService {

    @GetMapping("/openfeign/provider/test/{id}")
    String get(@PathVariable("id")Integer id);
}

java复制代码@RestController
@RequestMapping("/openfeign/provider")
public class OpenFeignProviderController {
    @PostMapping("/test2")
    public String test2(String id,String name){
        return MessageFormat.format("accept on msg id={0}，name={1}",id,name);
    }
}

java复制代码@FeignClient(value = "openFeign-provider")
public interface OpenFeignService {
    /**
     * 必须要@RequestParam注解标注，且value属性必须填上参数名
     * 方法参数名可以任意，但是@RequestParam注解中的value属性必须和provider中的参数名相同
     */
    @PostMapping("/openfeign/provider/test2")
    String test(@RequestParam("id") String arg1,@RequestParam("name") String arg2);
}

java复制代码@PostMapping("/test2")
public String test2(String id,String name) throws InterruptedException {
        Thread.sleep(3000);
        return MessageFormat.format("accept on msg id={0}，name={1}",id,name);
}

yaml复制代码ribbon:
  # 值的是建立链接所用的时间，适用于网络状况正常的情况下， 两端链接所用的时间
  ReadTimeout: 5000
  # 指的是建立链接后从服务器读取可用资源所用的时间
  ConectTimeout: 5000

yaml复制代码feign:
  client:
    config:
      ## default 设置的全局超时时间，指定服务名称可以设置单个服务的超时时间
      default:
        connectTimeout: 5000
        readTimeout: 5000

java复制代码public T invoke(){
    //1. 调用serviceA
    serviceA();
    
    //2. 调用serviceA
    serviceB();
    
    //3. 调用serviceA
    serviceC();
}

yaml复制代码feign:
  client:
    config:
      ## default 设置的全局超时时间，指定服务名称可以设置单个服务的超时时间
      default:
        connectTimeout: 5000
        readTimeout: 5000
      ## 为serviceC这个服务单独配置超时时间
      serviceC:
        connectTimeout: 30000
        readTimeout: 30000

yaml复制代码logging:
  level:
    cn.myjszl.service: debug

xml复制代码<!--     使用Apache HttpClient替换Feign原生httpclient-->
    <dependency>
      <groupId>org.apache.httpcomponents</groupId>
      <artifactId>httpclient</artifactId>
    </dependency>
    
    <dependency>
      <groupId>io.github.openfeign</groupId>
      <artifactId>feign-httpclient</artifactId>
    </dependency>

yaml复制代码feign:
  client:
    httpclient:
      # 开启 Http Client
      enabled: true

yaml复制代码feign:
  ## 开启压缩
  compression:
    request:
      enabled: true
      ## 开启压缩的阈值，单位字节，默认2048，即是2k，这里为了演示效果设置成10字节
      min-request-size: 10
      mime-types: text/xml,application/xml,application/json
    response:
      enabled: true

xml复制代码<dependency>
      <groupId>com.alibaba.cloud</groupId>
      <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

yaml复制代码feign:
  sentinel:
    enabled: true

java复制代码@FeignClient(value = "openFeign-provider",fallback = OpenFeignFallbackService.class)
public interface OpenFeignService {}

java复制代码/**
 * 生成二维码内容
 *
 * @return 结果
 */
@GetMapping("/generate")
public BaseResult generate() {
    String code = IdUtil.simpleUUID();
    redisCache.setCacheObject(code, CodeUtils.getUnusedCodeInfo(), 
                              DEFAULT_QR_EXPIRE_SECONDS, TimeUnit.SECONDS);
    return BaseResult.success(GENERATE_SUCCESS, code);
}

javascript复制代码getToken() {
    this.codeStatus = 'EMPTY'
    this.tip = '正在获取登录码，请稍等'
    // 有效时间 60 秒
    this.effectiveSeconds = 60
    clearInterval(this.timer)
    request({
        method: 'get',
        url: '/code/generate'
    }).then((response) => {
        // 请求成功, 设置二维码内容, 并更新相关信息
        this.code = `${HOST}/code/scan?code=${response.data}`
        this.codeStatus = 'UNUSED'
        this.tip = '请使用手机扫码登录'
        this.timer = setInterval(this.getTokenInfo, 2000)
    }).catch(() => {
        this.getToken()
    })
}

java复制代码/**
 * 获取二维码状态信息
 *
 * @param code 二维码
 * @return 结果
 */
@GetMapping("/info")
public BaseResult info(String code) {
    CodeVO codeVO = redisCache.getCacheObject(code);
    if (codeVO == null) {
        return BaseResult.success(INVALID_CODE, StringUtils.EMPTY);
    }
    return BaseResult.success(GET_SUCCESS, codeVO);
}

javascript复制代码getTokenInfo() {
    this.effectiveSeconds--
    // 二维码过期
    if (this.effectiveSeconds <= 0) {
        this.codeStatus = 'EXPIRE'
        this.tip = '二维码已过期，请刷新'
        return
    }
    // 轮询查询二维码状态
    request({
        method: 'get',
        url: '/code/info',
        params: {
            code: this.code.substr(this.code.indexOf('=') + 1)
        }
    }).then(response => {
        const codeVO = response.data
        // 二维码过期
        if (!codeVO || !codeVO.codeStatus) {
            this.codeStatus = 'EXPIRE'
            this.tip = '二维码已过期，请刷新'
            return
        }
        // 二维码状态为为正在登录
        if (codeVO.codeStatus === 'CONFIRMING') {
            this.username = codeVO.username
            this.avatar = codeVO.avatar
            this.codeStatus = 'CONFIRMING'
            this.tip = '扫码成功，请在手机上确认'
            return
        }
        // 二维码状态为确认登录
        if (codeVO.codeStatus === 'CONFIRMED') {
            clearInterval(this.timer)
            const token = codeVO.token
            store.commit('setToken', token)
            this.$router.push('/home')
            Message.success('登录成功')
            return
        }
    })
}

java复制代码/**
 * 处理未使用状态的二维码
 *
 * @param code 二维码
 * @param token token
 * @return 结果
 */
private BaseResult handleUnusedQr(String code, String token) {
    // 校验 app 端访问传递的 token
    boolean isLegal = JwtUtils.verify(token);
    if (!isLegal) {
        return BaseResult.error(AUTHENTICATION_FAILED);
    }
    // 保存用户名、头像信息, 供前端展示
    String username = JwtUtils.getUsername(token);
    CodeVO codeVO = CodeUtils.getConfirmingCodeInfo(username, DEFAULT_AVATAR_URL);
    redisCache.setCacheObject(code, codeVO, DEFAULT_QR_EXPIRE_SECONDS, TimeUnit.SECONDS);
    // 返回登录地址、浏览器、操作系统以及一个临时 token 给 app
    String address = HttpUtils.getRealAddressByIp();
    String browser = HttpUtils.getBrowserName();
    String os = HttpUtils.getOsName();
    String tmpToken = JwtUtils.sign(username);
    // 将临时 token 作为键, 用户名为内容存储在 redis 中
    redisCache.setCacheObject(tmpToken, username, DEFAULT_TEMP_TOKEN_EXPIRE_MINUTES, TimeUnit.MINUTES);
    LoginInfoVO loginInfoVO = new LoginInfoVO(address, browser, os, tmpToken);
    return BaseResult.success(SCAN_SUCCESS, loginInfoVO);
}

java复制代码/**
 * 处理未待确认状态的二维码
 *
 * @param code 二维码
 * @param token token
 * @return 结果
 */
private BaseResult handleConfirmingQr(String code, String token) {
    // 使用临时 token 获取用户名, 并从 redis 中删除临时 token
    String username = redisCache.getCacheObject(token);
    if (StringUtils.isBlank(username)) {
        return BaseResult.error(AUTHENTICATION_FAILED);
    }
    redisCache.deleteObject(token);
    // 根据用户名生成正式 token并保存在 redis 中供前端使用
    String formalToken = JwtUtils.sign(username);
    CodeVO codeVO = CodeUtils.getConfirmedCodeInfo(username, DEFAULT_AVATAR_URL, formalToken);
    redisCache.setCacheObject(code, codeVO, DEFAULT_QR_EXPIRE_SECONDS, TimeUnit.SECONDS);
    return BaseResult.success(CONFIRM_SUCCESS);
}

sql复制代码sudo yum install https://repo.percona.com/yum/percona-release-latest.noarch.rpm

sudo percona-release enable-only pxc-80 release

sudo percona-release enable tools release

sudo yum install percona-xtradb-cluster

csharp复制代码firewall-cmd --zone=public ȁƕadd-port=3306/tcp ȁƕpermanent

firewall-cmd --zone=public ȁƕadd-port=4444/tcp ȁƕpermanent

firewall-cmd --zone=public ȁƕadd-port=4567/tcp ȁƕpermanent

firewall-cmd --zone=public ȁƕadd-port=4568/tcp ȁƕpermanent

firewall-cmd --reload

bash复制代码# 临时关闭防火墙

systemctl stop firewalld.service

# 永久关闭防火墙

systemctl disable firewalld.service

ini复制代码# PXC集群的所有ip

wsrep_cluster_address=gcomm:ȁi192.168.68.140,192.168.68.141,192.168.68.142

# 节点IP地址

wsrep_node_address=192.168.68.140

# 集群名称，集群中保持统一

wsrep_cluster_name=pxc-cluster

# 节点名称，不同的节点名称不同

wsrep_node_name=pxc-cluster-node-1

ini复制代码#关闭加密传输

pxc-encrypt-cluster-traffic=OFF

sql复制代码systemctl start mysql@bootstrap.service

systemctl stop mysql@bootstrap.service

systemctl restart mysql@bootstrap.service

arduino复制代码systemctl start mysql.service

systemctl stop mysql.service

systemctl status mysql.service

java复制代码private static class Node<E> {
    E item;        // 存储数据
    Node<E> next;  // 后继节点
    Node<E> prev;  // 前继节点

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

java复制代码// 元素个数，默认为0
transient int size = 0;

// 表示第一个节点，第一个节点必须满足(first == null && last == null) || (first.prev == null && first.item != null)
transient Node<E> first;

// 表示最后一个节点，最后一个节点必须满足(first == null && last == null) || (last.next == null && last.item != null)
transient Node<E> last;

java复制代码public LinkedList() {}

java复制代码public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

public boolean addAll(Collection<? extends E> c) {
    return addAll(size, c);
}

public boolean addAll(int index, Collection<? extends E> c) {
    checkPositionIndex(index);

    Object[] a = c.toArray();
    int numNew = a.length;
    if (numNew == 0)
        return false;

    Node<E> pred, succ;
    if (index == size) {
        succ = null;
        pred = last;
    } else {
        succ = node(index);
        pred = succ.prev;
    }
    // 循环创建节点，设置prev，next指向
    for (Object o : a) {
        @SuppressWarnings("unchecked") E e = (E) o;
        Node<E> newNode = new Node<>(pred, e, null);
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        pred = newNode;
    }

    if (succ == null) {
        last = pred;
    } else {
        pred.next = succ;
        succ.prev = pred;
    }

    size += numNew;
    modCount++;
    return true;
}

java复制代码public void add(int index, E element) {
    // 下标合法性检查
    checkPositionIndex(index);

    if (index == size)
        // 如果插入下标等于size，说明是在尾部插入，执行尾部插入操作
        linkLast(element);
    else
        // 如果不是尾插入，则在指定下标节点前插入
        linkBefore(element, node(index));
}

private void checkPositionIndex(int index) {
    if (!isPositionIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

private boolean isPositionIndex(int index) {
    return index >= 0 && index <= size;
}

void linkLast(E e) {
    // 获取最后一个节点
    final Node<E> l = last;
    // 创建一个新节点，prev为原链表最后一个节点，next为null
    final Node<E> newNode = new Node<>(l, e, null);
    // 更新last为新节点
    last = newNode;
    if (l == null)
        // 如果原链表最后一个节点为null，说明原链表没有节点，将新节点赋给first
        first = newNode;
    else
        // 否则更新原链表最后一个节点的next为新节点
        l.next = newNode;
    // size递增
    size++;
    // 模数递增，用于快速失败
    modCount++;
}

void linkBefore(E e, Node<E> succ) {
    // succ为原链表指定index位置的节点，获取其prev节点
    final Node<E> pred = succ.prev;
    // 创建新节点，prev为原链表指定index位置的节点的prev节点，next为原链表指定index位置的节点
    final Node<E> newNode = new Node<>(pred, e, succ);
    // 将原链表指定index位置的节点的prev更新为新节点
    succ.prev = newNode;
    if (pred == null)
        // 如果链表指定index位置的节点的prev为null，说明原链表没有节点，将新节点赋给first
        first = newNode;
    else
        // 否则更新原链表指定index位置的节点的prev的next节点为新节点
        pred.next = newNode;
    // size递增
    size++;
    // 模数递增，用于快速失败
    modCount++;
}

// 采用二分法遍历每个Node节点，直到找到index位置的节点
Node<E> node(int index) {
    // assert isElementIndex(index);

    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

java复制代码public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

// 采用二分法遍历每个Node节点，直到找到index位置的节点
Node<E> node(int index) {
    // assert isElementIndex(index);

    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

java复制代码public E set(int index, E element) {
    // 下标合法性检查
    checkElementIndex(index);
    // 获取index下标节点
    Node<E> x = node(index);
    // 获取旧值
    E oldVal = x.item;
    // 设置新值
    x.item = element;
    // 返回旧值
    return oldVal;
}

// 采用二分法遍历每个Node节点，直到找到index位置的节点
Node<E> node(int index) {
    // assert isElementIndex(index);

    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

java复制代码public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}

E unlink(Node<E> x) {
    // assert x != null;
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;

    if (prev == null) {
        first = next;
    } else {
        prev.next = next;
        x.prev = null;
    }

    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }

    x.item = null;
    size--;
    modCount++;
    return element;
}

java复制代码package java.util;

public interface RandomAccess {}

java复制代码public static <T>
int binarySearch(List<? extends Comparable<? super T>> list, T key) {
    if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
        return Collections.indexedBinarySearch(list, key);
    else
        return Collections.iteratorBinarySearch(list, key);
}

scss复制代码Rocket的运维指令都包装成了SubCommand对象，而重置消费位点对应的是ResetOffsetByTimeCommand对象
Rocket的MQAdmin启动时，调用initCommand(),将命令对象实例化并注册到subCommandList中。

接收到对应的命令之后findSubCommand()可以定位到对应的SubCommand对象，
并调用该命令对象的buildCommandlineOptions()进行参数的解析与组装，最后返回一个参数集合对象Options

真正的逻辑处理需要执行命令对象的execute();

css复制代码首先要根据时间戳获取到ConsumeQueue中的偏移量

调用栈如下:

    ResetOffsetByTimeCommand.execute()
->  DefaultMQAdminExt.resetOffsetByTimestamp()
->  DefaultMQAdminExtImpl.resetOffsetByTimestamp()
->  MQClientAPIImpl.invokeBrokerToResetOffset()
->  RemotingClient.invokeSync()

假设没有服务端开发经验，也没有系统的研究过网络编程，调用链到此处就断开了。
想必你应该知道Rocket的各个组件通过Tcp建立通信连接，组件间的信息交换则是通过一个个RPC调用实现的。
Rocket组件间的交互信息的通讯协议专门定义了此数据帧的业务类型，所有类型在RequestCode中都有明确定义。
同样重置消费位点也有约定其业务类型枚举常量:RequestCode.INVOKE_BROKER_TO_RESET_OFFSET。
顺藤摸瓜你就可以找到此消息的处理器:
    (这里默认你已经理解了Rocket中处理数据包的那套逻辑，即使不理解也没问题，跟着文中思路也可以找到此处)
    AdminBrokerProcessor.processRequest()
->  AdminBrokerProcessor.resetOffset()
->  Broker2Client.resetOffset()
->  DefaultMessageStore.getOffsetInQueueByTime()
->  ConsumeQueue.getOffsetInQueueByTime()

根据时间戳获取到ConsumeQueue中的偏移量的实现就在这一个方法中ConsumeQueue.getOffsetInQueueByTime()

java复制代码    Map<MessageQueue, Long> offsetTable = new HashMap<>();
    for (int i = 0; i < topicConfig.getWriteQueueNums(); i++) {
        /* i即是QueueId，构造出MessageQueue对象 */
        MessageQueue mq = new MessageQueue();
        mq.setBrokerName(this.brokerController.getBrokerConfig().getBrokerName());
        mq.setTopic(topic);
        mq.setQueueId(i);
        /* 根据时间戳计算出ConsumeQueue中的偏移量 */
        timeStampOffset = this.brokerController.getMessageStore()
            .getOffsetInQueueByTime(topic, i, timeStamp);
        
        offsetTable.put(mq, timeStampOffset);
    }

java复制代码public RemotingCommand resetOffset(String topic, String group, long timeStamp,
                                   boolean isForce, boolean isC) {
    /* 构造请求体 */                                   
    ResetOffsetRequestHeader requestHeader = new ResetOffsetRequestHeader();
    requestHeader.setTopic(topic);
    requestHeader.setGroup(group);
    requestHeader.setTimestamp(timeStamp);
    RemotingCommand request = RemotingCommand.createRequestCommand(
        RequestCode.RESET_CONSUMER_CLIENT_OFFSET, requestHeader
    );     
    ResetOffsetBody body = new ResetOffsetBody();
    body.setOffsetTable(offsetTable);
    request.setBody(body.encode());     

    /* 执行Rpc调用 */   
    this.brokerController.getRemotingServer().invokeOneway(entry.getKey(), request, 5000);
   }

java复制代码public RemotingCommand resetOffset(ChannelHandlerContext ctx,
    RemotingCommand request) throws RemotingCommandException {
    ResetOffsetRequestHeader requestHeader =
        (ResetOffsetRequestHeader) request.decodeCommandCustomHeader(ResetOffsetRequestHeader.class);
    /* 序列化数据得到Message、消费偏移量的映射关系 */
    Map<MessageQueue, Long> offsetTable = new HashMap<>();
    if (request.getBody() != null) {
        ResetOffsetBody body = ResetOffsetBody.decode(request.getBody(), ResetOffsetBody.class);
        offsetTable = body.getOffsetTable();
    }

    /* 根据上述数据修改客户端本地消费进度 */
    this.mqClientFactory.resetOffset(requestHeader.getTopic(), requestHeader.getGroup(), offsetTable);
    return null;
}

java复制代码resetOffset(String topic, String group, Map<MessageQueue, Long> offsetTable) {
    /* 根据Group从列表中搜索到对应的Consumer */
    MQConsumerInner impl = this.consumerTable.get(group);

    /* 如果是推模式则强转为DefaultMQPushConsumerImpl类型 */
    if (impl != null && impl instanceof DefaultMQPushConsumerImpl) {
        consumer = (DefaultMQPushConsumerImpl) impl;
    } else {
        /* 如果不是则直接结束 */
        return;
    }

    /* 暂停消费 */
    consumer.suspend();

    /* 循环更新消费进度 */
    while (iterator.hasNext()) {
        MessageQueue mq = iterator.next();
        Long offset = offsetTable.get(mq);
        if (topic.equals(mq.getTopic()) && offset != null) {
            try {
                consumer.updateConsumeOffset(mq, offset);
            } catch (Exception e) {
                log.warn("reset offset failed. group={}, {}", group, mq, e);
            }
        }
    }
        
    /* 恢复工作 */
    consumer.resume();
}

java复制代码/**
 * 获取分布式锁
 * 
 * @param lockKey   锁定
 * @param waitTime  锁定等待时间
 * @param leaseTime 获取到的锁的存活时间,到期后自动释放
 * @return 未能锁定则返回null
 */
@Override
public RLock tryLock(String lockKey, long waitTime, long leaseTime) {
   RLock lock = redisson.getLock(lockKey);
   try {
      if (lock.tryLock(waitTime, leaseTime, TimeUnit.MILLISECONDS)) {
         return lock;
      }
   } catch (InterruptedException ignore) {
      if (log.isWarnEnabled()) {
         log.warn("Redisson tryLock exception", ignore);
      }
   }
   return null;
}

typescript复制代码public RLock getLock(String name) {
    return new RedissonLock(this.connectionManager.getCommandExecutor(), name);
}