怎样用此列表来排序彼列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
private List<TagGroup> reorder(Long id, List<TagGroup> entities) {
    final AccountSettings accountSettings = getAccountSetting(
            id);
    final List<Long> tagGroupOrders = accountSettings.getTagGroupOrders();
    // 根据 tagGroupOrders 里提供的 tagGroupId 对 entities 排序
    if (CollectionUtils.isNotEmpty(tagGroupOrders)) {
        entities.sort((o1, o2) -> {
            int index1 = tagGroupOrders.indexOf(o1.getTagGroupId());
            int index2 = tagGroupOrders.indexOf(o2.getTagGroupId());
            // 不对没有出现在列表里的 tagGroup 进行排序
            if (index1 == -1 || index2 == -1) {
                return sortByModifiedTime(o1, o2);
            }
            return index1 - index2;
        });
    }
    // 还有一种潜在的排序方法是在这里加一个 else 分支，只对  modified time 进行排序

    // 返回排序后的结果
    return entities;
}

private static int sortByModifiedTime(TagGroup o1, TagGroup o2) {
    final long time1 = o1.getLastModifiedTime().getTime();
    final long time2 = o2.getLastModifiedTime().getTime();
    if (time1 < time2) {
        return -1;
    } else if (time1 > time2) {
        return 1;
    } else {
        return 0;
    }
}

怎样每次生成一把锁实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
@Slf4j
@Component
@Scope("prototype")
public class LockRunner {

    private RedissonClient redissonClient;

    /**
     * 私有构造器
     */
    @Autowired
    public LockRunner(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    @WithSpan
    public void runInLock(@SpanAttribute("lockConfig") LockKey lockKeyConfig, Runnable runnable) {
        final String lockKey = lockKeyConfig.getLockKey();
        RLock lock = redissonClient.getLock(lockKey);
        // 新的锁是无限锁模式，只要锁的key包含细颗粒的id（手机号、线索id、呼叫id）就不会超时有问题
        lock.lock();
        try {
            runnable.run();
        } finally {
            unlock(lock);
        }
    }

    @WithSpan
    public <V> V callInLock(@SpanAttribute("lockConfig") LockKey lockKeyConfig, Callable<V> callable) {
        final String lockKey = lockKeyConfig.getLockKey();
        RLock lock = redissonClient.getLock(lockKey);
        // 新的锁是无限锁模式，只要锁的key包含细颗粒的id（手机号、线索id、呼叫id）就不会超时有问题
        lock.lock();
        try {
            return callable.call();
        } catch (Exception e) {
            throw new SystemInternalException("callable.call()失败：" + e.getMessage(), e);
        } finally {
            unlock(lock);
        }
    }

    private void unlock(RLock lock) {
        log.info("unlock for: {}", lock.getName());
        lock.unlock();
    }
}

@Component
public class LockRunnerFactory {

    private final ApplicationContext applicationContext;

    @Autowired
    public LockRunnerFactory(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    public LockRunner createLockRunner() {
        return applicationContext.getBean(LockRunner.class);
    }
}

一个更好的设计是去掉@Scope("prototype")和LockRunnerFactory，LockRunner的可变状态都被参数化了，所有最好的设计实际上是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
@Data
public class LockConfig {

    /**
     * 锁的后缀
     */
    public static final String LOCK_SUFFIX = "-lock";

    /**
     * 超时时间
     */
    private final int expireSecs;

    /**
     * 真正的锁键
     */
    private final String lockKey;

    private LockConfig(final int expireSecs, final String lockKey) {
        this.expireSecs = expireSecs;
        this.lockKey = lockKey;
    }

    public LockConfig(final int expireSecs, final Object... objects) {
        this(expireSecs, Joiner.on("-").join(objects) + LOCK_SUFFIX);
    }
}

@Data
public class LockKey {

    /**
     * 锁的后缀
     */
    public static final String LOCK_SUFFIX = "-lock";


    /**
     * 真正的锁键
     */
    private final String lockKey;

    public LockKey(final Object... objects) {
        lockKey = Joiner.on("-").join(objects) + LOCK_SUFFIX;
    }

}

在还原一个字段的时候，怎么确定它有没有被修改过？

一个字段是 ownerId。它曾经是1，无意之中被设置为0，能不能恢复为1？
假设有另一个字段为 ownerName，有意设置 ownerId 的时候，一定会清空 ownerName。则可以做这样的比对：

1
2
3
if (owner == 0 && StringUtils.isNotBlank(ownerName)) {
    owner = 1;
}

使用一个特定参数来排除某个 jar

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// 这个配置交给 service 层的那个 fileTree 来做也可以
// 引入本地的 lib
def jars = fileTree(dir: 'addtionnallib', include: ['*.jar'])

jars.each { File file ->
    println("jars：${file}")
}

/*
 * 这个配置会被在底层service层再执行一次，为了以后有人改错，在这里再做一次排除这里虽然是在根部做这个配置，但实质上却只读命令执行目录的 addtionnallib
 * 下面这一段 直到 println留在这里的意义是：以防有一天构建模块不再在底层某一module，而它又需要差异化地使用 addtionnallib 式的 jar 时
 *
 * 不能这样使用
 * ext {
 *  excludeHighJar = false
 * }
 * ext.excludeHighJar = false 必须写在这里才能被覆写
 */
ext.excludeHighJar = false
// 需要激活这个功能的项目的流水线参数： ../../gradlew clean build -x test -PexcludeHighJar=true
ext.excludeHighJar = project.hasProperty('excludeHighJar') ? project.getProperty('excludeHighJar') : false

if (excludeHighJar && excludeHighJar.trim()) {
    // ${excludeHighJar}
    jars = jars.minus(file("addtionnallib/a.jar"))
} else {
    // 默认情况下排除 fat jar
    jars = jars.minus(file("addtionnallib/a.fat.jar"))
}
api files(jars)
println "Excluding jar: ${excludeHighJar}"

把多重 group by 转成单重 group by

老的group by a, b, day，实际产出是一个以 day 聚合的曲线图。
a、b出现在这里本义是为了按照 a, b 聚合，然后选出特定的 a、b 组合，这实际上是一种叉乘关系。
所以如果我们能转化 a、b 到where 里，我们就能直接group by day。

基于函数来管理 go 版本（适用于 Linux）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
# 安装指定版本
# go_version_manage install 1.21.6

# 切换版本
# go_version_manage switch 1.21.6

# 列出已安装版本
# go_version_manage list

# 查看帮助
# go_version_manage

# FILEPATH: ~/.bashrc 或 ~/.zshrc
# Go版本管理函数集
go_version_manage() {
    case $1 in
        install)
            __go_install_version "$2"
            ;;
        switch)
            __go_switch_version "$2"
            ;;
        list)
            __go_list_versions
            ;;
        *)
            echo "Usage: go_version_manage [install|switch|list] <version>"
            return 1
            ;;
    esac
}

# 安装Go版本
__go_install_version() {
    local version=$1
    # 校验版本格式
    if ! [[ "$version" =~ ^[0-9]+\.[0-9]+(\.[0-9]+)?$ ]]; then
        echo "Invalid version format. Expected format: 1.22.0 or 1.22"
        return 1
    fi

    local install_dir="/opt/go-versions/go$version"
    local tar_file="go$version.linux-amd64.tar.gz"
    local url="https://go.dev/dl/$tar_file"

    # 创建安装目录
    sudo mkdir -p "$install_dir" || return 1

    # 下载并解压
    if ! (wget -qO- "$url" | sudo tar -xz -C "$install_dir" --strip-components 1); then
        echo "Failed to install Go $version"
        sudo rm -rf "$install_dir"
        return 1
    fi

    echo "Successfully installed Go $version in $install_dir"
    
    # 更新自动补全列表
    if [ -n "$ZSH_VERSION" ]; then
        rehash
    elif [ -n "$BASH_VERSION" ]; then
        hash -r
    fi
}

# 切换版本函数
__go_switch_version() {
    local version=$1
    local go_path="/opt/go-versions/go$version"
    
    if [ -d "$go_path" ]; then
        export GOROOT="$go_path"
        export PATH="$GOROOT/bin:$PATH"
        echo "Switched to Go $version"
        go version
    else
        echo "Go $version not installed. Available versions:"
        __go_list_versions
        return 1
    fi
}

# 列出已安装版本
__go_list_versions() {
    echo "Installed Go versions:"
    ls -1 /opt/go-versions | sed 's/go//' | sort -V
}

# 自动补全函数
_go_version_manage() {
    local cur=${words[CURRENT]}
    case ${words[2]} in
        switch)
            if [ -d /opt/go-versions ]; then
                COMPREPLY=($(ls /opt/go-versions | grep '^go' | cut -c3- | grep "^$cur"))
            fi
            ;;
        install)
            # 获取线上最新版本列表
            local remote_versions=$(curl -s https://go.dev/VERSION?m=text | grep -Eo 'go[0-9]+\.[0-9]+(\.[0-9]+)?' | sed 's/go//' | sort -Vr | uniq)
            COMPREPLY=($(compgen -W "$remote_versions" -- "$cur"))
            ;;
        *)
            COMPREPLY=($(compgen -W "install switch list" -- "$cur"))
            ;;
    esac
}

范式是为了平衡读和写

写多的时候，人们就不喜欢冗余列，因为这会增加同步的难度，而且扩大事务的范围。
读多的时候，大家就不喜欢不符合第一范式的列，因为这会导致列内部不可查询。

OLAP 数仓查询应用倾向于多冗余，但是加字段和回溯数据比较麻烦。

使用移动来代替删除

使用移动来代替恢复。