bash复制代码docker search redis
docker pull redis

bash复制代码docker network create myredis

bash复制代码docker network ls

bash复制代码docker network inspect myredis

bash复制代码docker network rm myredis #删除网卡命令 多个中间 空格隔开
docker network --help #显示可带参数等

bash复制代码for port in $(seq 6379 6384); 
do 
mkdir -p /home/redis/node-${port}/conf
touch /home/redis/node-${port}/conf/redis.conf
cat  << EOF > /home/redis/node-${port}/conf/redis.conf
port ${port}
requirepass 1234
bind 0.0.0.0
protected-mode no
daemonize no
appendonly yes
cluster-enabled yes 
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip  服务器就填公网ip，或者内部对应容器的ip
cluster-announce-port ${port}
cluster-announce-bus-port 1${port}
EOF
done

bash复制代码for port in $(seq 6379 6384); \
do \
   docker run -it -d -p ${port}:${port} -p 1${port}:1${port} \
  --privileged=true -v /home/redis/node-${port}/conf/redis.conf:/usr/local/etc/redis/redis.conf \
  --privileged=true -v /home/redis/node-${port}/data:/data \
  --restart always --name redis-${port} --net myredis \
  --sysctl net.core.somaxconn=1024 redis redis-server /usr/local/etc/redis/redis.conf
done

bash复制代码docker exec -it redis-6379 /bin/bash

bash复制代码redis-cli  -a 之前设置的密码 --cluster create 配置文件中的IP地址:6379 IP地址:6380 IP地址:6381 IP地址:6382 IP地址:6383 IP地址:6384   --cluster-replicas 1

bash复制代码 for port in $(seq 6379 6384); 
 do 
 docker stop redis-${port}
 done

bash复制代码 for port in $(seq 6379 6384); 
 do 
 docker rm redis-${port}
 done

typescript复制代码@Componentpublic class FormDataHandlerFactory {
    private static final     Map<String, FormDataHandler> FORM_DATA_HANDLER_MAP = new HashMap<>(16);
    /**     * 根据表单标识，获取对应的 Handler     *     * @param formCode 表单标识     * @return 表单对应的 Handler     */    public FormDataHandler getHandler(String formCode) {        return FORM_DATA_HANDLER_MAP.get(formCode);    }
    @Autowired    public void setFormDataHandlers(List<FormDataHandler> handlers) {        for (FormDataHandler handler : handlers) {            FORM_DATA_HANDLER_MAP.put(handler.getFormCode(), handler);        }    }}

typescript复制代码@Componentpublic class FormItemConverterFactory {
    private static final     EnumMap<FormItemTypeEnum, FormItemConverter> CONVERTER_MAP = new EnumMap<>(FormItemTypeEnum.class);
    /**     * 根据表单项类型获得对应的转换器     *     * @param type 表单项类型     * @return 表单项转换器     */    public FormItemConverter getConverter(FormItemTypeEnum type) {        return CONVERTER_MAP.get(type);    }
    @Autowired    public void setConverters(List<FormItemConverter> converters) {        for (final FormItemConverter converter : converters) {            CONVERTER_MAP.put(converter.getType(), converter);        }    }}

csharp复制代码public interface Strategy<T> {
    /**     * 获得策略的标识     */    T getId();}

java复制代码public abstract class StrategyFactory<T, S extends Strategy<T>>                 implements InitializingBean, ApplicationContextAware {
    private Map<T, S> strategyMap;
    private ApplicationContext appContext;
    /**     * 根据策略 id 获得对应的策略的 Bean     *     * @param id 策略 id     * @return 策略的 Bean     */    public S getStrategy(T id) {        return strategyMap.get(id);    }
    /**     * 获取策略的类型（交给子类去实现）     *     * @return 策略的类型     */    protected abstract Class<S> getStrategyType();
    @Override    public void afterPropertiesSet() {        // 获取 Spring 容器中，所有 S 类型的 Bean        Collection<S> strategies = appContext.getBeansOfType(getStrategyType()).values();
        strategyMap = Maps.newHashMapWithExpectedSize(strategies.size());
        // 将所有 S 类型的 Bean 放入到 strategyMap 中        for (final S strategy : strategies) {            T id = strategy.getId();            strategyMap.put(id, strategy);        }    }
    @Override    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {        appContext = applicationContext;    }}

scala复制代码@Componentpublic class FormDataHandlerFactory extends StrategyFactory<String, FormDataHandler> {
    @Override    protected Class<FormDataHandler> getStrategyType() {        return FormDataHandler.class;    }}

typescript复制代码public interface FormDataHandler extends Strategy<String> {
    @Override    default String getId() { return getFormCode(); }
    String getFormCode();
    CommonResponse<Object> submit(FormSubmitRequest request);}

scala复制代码@Componentpublic class FormItemConverterFactory extends StrategyFactory<FormItemTypeEnum, FormItemConverter> {
    @Override    protected Class<FormItemConverter> getStrategyType() {        return FormItemConverter.class;    }}

csharp复制代码public interface FormItemConverter extends Strategy<FormItemTypeEnum> {
    @Override    default FormItemTypeEnum getId() { return getType(); }
    FormItemTypeEnum getType();
    FormItem convert(FormItemConfig config);}

typescript复制代码public interface ListDataFetcher extends Strategy<String> {        CommonResponse<JSONObject> fetchData(ListDataFetchRequest request);}

scala复制代码@Componentpublic class ListDataFetcherFactory extends StrategyFactory<String, ListDataFetcher> {
    @Override    protected Class<ListDataFetcher> getStrategyType() {        return ListDataFetcher.class;    }}

scala复制代码public abstract class StrategyFactory<T, S extends Strategy<T>>                implements InitializingBean, ApplicationContextAware {
    ...
    /**     * 通过反射获取策略的类型     *     * @return 策略的类型     */    protected Class<S> getStrategyType() {        // getClass 获取当前运行时实例的类，getGenericSuperclass 获得泛型父类        Type superclass = getClass().getGenericSuperclass();        ParameterizedType pt = (ParameterizedType) superclass;        Type[] actualTypeArguments = pt.getActualTypeArguments();        // 获得索引为 1 的实际参数类型，即第二个实际参数的类型        Type actualTypeArgument = actualTypeArguments[1];        @SuppressWarnings("unchecked")        Class<S> result = (Class<S>) actualTypeArgument;
        return result;    }
    ...}

java复制代码@Componentpublic class FormDataHandlerFactory extends StrategyFactory<String, FormDataHandler> {}

scala复制代码@Componentpublic class FormItemConverterFactory extends StrategyFactory<FormItemTypeEnum, FormItemConverter> {}

scala复制代码@Componentpublic class ListDataFetcherFactory extends StrategyFactory<String, ListDataFetcher> {}

java复制代码public class StrategyFactory<T, S extends Strategy<T>>        implements InitializingBean, ApplicationContextAware {
    private final Class<S> strategyType;
    private Map<T, S> strategyMap;
    private ApplicationContext appContext;
    /**     * 创建一个策略工厂     *      * @param strategyType 策略的类型     */    public StrategyFactory(Class<S> strategyType) {        this.strategyType = strategyType;    }
    /**     * 根据策略 id 获得对应的策略的 Bean     *     * @param id 策略 id     * @return 策略的 Bean     */    public S getStrategy(T id) {        return strategyMap.get(id);    }
    @Override    public void afterPropertiesSet() {        // 获取 Spring 容器中，所有 S 类型的 Bean        Collection<S> strategies = appContext.getBeansOfType(strategyType).values();
        strategyMap = Maps.newHashMapWithExpectedSize(strategies.size());
        // 将 所有 S 类型的 Bean 放入到 strategyMap 中        for (final S strategy : strategies) {            T id = strategy.getId();
            strategyMap.put(id, strategy);        }    }
    @Override    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {        appContext = applicationContext;    }}

csharp复制代码@Configurationpublic class FactoryConfig {
    @Bean    public StrategyFactory<String, FormDataHandler> formDataHandlerFactory() {        return new StrategyFactory<>(FormDataHandler.class);    }
    @Bean    public StrategyFactory<FormItemTypeEnum, FormItemConverter> formItemConverterFactory() {        return new StrategyFactory<>(FormItemConverter.class);    }
    @Bean    public StrategyFactory<String, ListDataFetcher> listDataFetcherFactory() {        return new StrategyFactory<>(ListDataFetcher.class);    }}

ini复制代码public class FormItemConverter {
    /**     * 将输入的配置转变为表单项     *     * @param config 前端输入的配置     * @return 表单项     */    public FormItem convert(FormItemConfig config) {        FormItem formItem = new FormItem();
        // 公共的表单项属性        formItem.setTitle(config.getTitle());        formItem.setCode(config.getCode());        formItem.setComponent(config.getComponent());
        // 创建表单组件的属性        FormComponentProps props = new FormComponentProps();        formItem.setComponentProps(props);                // 公共的组件属性        if (config.isReadOnly()) {            props.setReadOnly(true);        }
        FormItemTypeEnum type = config.getType();
        // 下拉选择框的特殊属性处理        if (type == ComponentTypeEnum.DROPDOWN_SELECT) {            props.setAutoWidth(false);
            if (config.isMultiple()) {                props.setMode("multiple");            }        }
        // 模糊搜索框的特殊属性处理        if (type == ComponentTypeEnum.FUZZY_SEARCH) {            formItem.setFuzzySearch(true);            props.setAutoWidth(false);        }
        // ...  其他组件的特殊处理
        // 创建约束规则        List<FormItemRule> rules = new ArrayList<>(2);        formItem.setRules(rules);
        // 每个表单项都可有的约束规则        if (config.isRequired()) {            FormItemRule requiredRule = new FormItemRule();            requiredRule.setRequired(true);            requiredRule.setMessage("请输入" + config.getTitle());
            rules.add(requiredRule);        }
        // 文本输入框才有的规则        if (type == ComponentTypeEnum.TEXT_INPUT || type == ComponentTypeEnum.TEXT_AREA) {            Integer minLength = config.getMinLength();
            if (minLength != null && minLength > 0) {                FormItemRule minRule = new FormItemRule();                minRule.setMin(minLength);                minRule.setMessage("请至少输入 " + minLength + " 个字");
                rules.add(minRule);            }
            Integer maxLength = config.getMaxLength();
            if (maxLength != null && maxLength > 0) {                FormItemRule maxRule = new FormItemRule();                maxRule.setMax(maxLength);                maxRule.setMessage("请最多输入 " + maxLength + " 个字");
                rules.add(maxRule);            }        }
        // ... 其他约束规则
        return formItem;    }}

scss复制代码public abstract class FormItemConverter {
    /**     * 子类可处理的表单项类型     */    public abstract FormItemTypeEnum getType();
    /**     * 将输入的配置转变为表单项的操作流程     *     * @param config 前端输入的配置     * @return 表单项     */    public final FormItem convert(FormItemConfig config) {        FormItem item = createItem(config);        // 表单项创建完成之后，子类如果需要特殊处理，可覆写该方法        afterItemCreate(item, config);
        FormComponentProps props = createComponentProps(config);        item.setComponentProps(props);        // 组件属性创建完成之后，子类如果需要特殊处理，可覆写该方法        afterPropsCreate(props, config);
        List<FormItemRule> rules = createRules(config);        item.setRules(rules);        // 约束规则创建完成之后，子类如果需要特殊处理，可覆写该方法        afterRulesCreate(rules, config);
        return item;    }
    /**     * 共用逻辑：创建表单项、设置通用的表单项属性     */    private FormItem createItem(FormItemConfig config) {        FormItem formItem = new FormItem();
        formItem.setCode(config.getCode());        formItem.setTitle(config.getTitle());        formItem.setComponent(config.getComponent());
        return formItem;    }
    /**     * 表单项创建完成之后，子类如果需要特殊处理，可覆写该方法     */    protected void afterItemCreate(FormItem item, FormItemConfig config) { }
    /**     * 共用逻辑：创建组件属性、设置通用的组件属性     */    private FormComponentProps createComponentProps(FormItemConfig config) {        FormComponentProps props = new FormComponentProps();
        if (config.isReadOnly()) {            props.setReadOnly(true);        }
        if (StringUtils.isNotBlank(config.getPlaceholder())) {            props.setPlaceholder(config.getPlaceholder());        }
        return props;    }
    /**     * 组件属性创建完成之后，子类如果需要特殊处理，可覆写该方法     */    protected void afterPropsCreate(FormComponentProps props, FormItemConfig config) { }
    /**     * 共用逻辑：创建约束规则、设置通用的约束规则     */    private List<FormItemRule> createRules(FormItemConfig config) {        List<FormItemRule> rules = new ArrayList<>(4);
        if (config.isRequired()) {            FormItemRule requiredRule = new FormItemRule();            requiredRule.setRequired(true);            requiredRule.setMessage("请输入" + config.getTitle());
            rules.add(requiredRule);        }
        return rules;    }
    /**     * 约束规则创建完成之后，子类如果需要特殊处理，可覆写该方法     */    protected void afterRulesCreate(List<FormItemRule> rules, FormItemConfig config) { }}

scala复制代码/** * 下拉选择框的转换器 */@Componentpublic class DropdownSelectConverter extends FormItemConverter {
    @Override    public FormItemTypeEnum getType() {        return FormItemTypeEnum.DROPDOWN_SELECT;    }
    @Override    protected void afterPropsCreate(FormComponentProps props, FormItemConfig config) {        props.setAutoWidth(false);
        if (config.isMultiple()) {            props.setMode("multiple");        }    }}
/** * 模糊搜索框的转换器 */@Componentpublic class FuzzySearchConverter extends FormItemConverter {
    @Override    public FormItemTypeEnum getType() {        return FormItemTypeEnum.FUZZY_SEARCH;    }
    @Override    protected void afterItemCreate(FormItem item, FormItemConfig config) {        item.setFuzzySearch(true);    }
    @Override    protected void afterPropsCreate(FormComponentProps props, FormItemConfig config) {        props.setAutoWidth(false);    }}
/** * 通用文本类转换器 */public abstract class CommonTextConverter extends FormItemConverter {
    @Override    protected void afterRulesCreate(List<FormItemRule> rules, FormItemConfig config) {        Integer minLength = config.getMinLength();
        if (minLength != null && minLength > 0) {            FormItemRule minRule = new FormItemRule();            minRule.setMin(minLength);            minRule.setMessage("请至少输入 " + minLength + " 个字");
            rules.add(minRule);        }
        Integer maxLength = config.getMaxLength();
        if (maxLength != null && maxLength > 0) {            FormItemRule maxRule = new FormItemRule();            maxRule.setMax(maxLength);            maxRule.setMessage("请最多输入 " + maxLength + " 个字");
            rules.add(maxRule);        }    }}
/** * 单行文本框的转换器 */@Componentpublic class TextInputConverter extends CommonTextConverter {
    @Override    public FormItemTypeEnum getType() {        return FormItemTypeEnum.TEXT_INPUT;    }}
/** * 多行文本框的转换器 */@Componentpublic class TextAreaConvertor extends FormItemConverter {
    @Override    public FormItemTypeEnum getType() {        return FormItemTypeEnum.TEXT_AREA;    }}

typescript复制代码@Componentpublic class FormItemConverterFactory {
    private static final     EnumMap<FormItemTypeEnum, FormItemConverter> CONVERTER_MAP = new EnumMap<>(FormItemTypeEnum.class);
    /**     * 根据表单项类型获得对应的转换器     *     * @param type 表单项类型     * @return 表单项转换器     */    public FormItemConverter getConverter(FormItemTypeEnum type) {        return CONVERTER_MAP.get(type);    }
    @Autowired    public void setConverters(List<FormItemConverter> converters) {        for (final FormItemConverter converter : converters) {            CONVERTER_MAP.put(converter.getType(), converter);        }    }}

java复制代码@Componentpublic class FormItemManagerImpl implements FormItemManager {
    @Autowired    private FormItemConverterFactory converterFactory;
    @Override    public List<FormItem> convertFormItems(JSONArray inputConfigs) {        return IntStream.range(0, inputConfigs.size())                        .mapToObj(inputConfigs::getJSONObject)                        .map(this::convertFormItem)                        .collect(Collectors.toList());    }
    private FormItem convertFormItem(JSONObject inputConfig) {        FormItemConfig itemConfig = inputConfig.toJavaObject(FormItemConfig.class);        FormItemConverter converter = converterFactory.getConverter(itemConfig.getType());
        if (converter == null) {            throw new IllegalArgumentException("不存在转换器：" + itemConfig.getType());        }
        return converter.convert(itemConfig);    }}

scala复制代码@Componentpublic class NumberPickerConverter extends FormItemConverter {
    @Override    public FormItemTypeEnum getType() {        return FormItemTypeEnum.NUMBER_PICKER;    }
    @Override    protected void afterRulesCreate(List<FormItemRule> rules, FormItemConfig config) {        Integer minNumber = config.getMinNumber();        // 处理最小值        if (minNumber != null) {            FormItemRule minNumRule = new FormItemRule();
            minNumRule.setMinimum(minNumber);            minNumRule.setMessage("输入数字不能小于 " + minNumber);
            rules.add(minNumRule);        }
        Integer maxNumber = config.getMaxNumber();        // 处理最大值        if (maxNumber != null) {            FormItemRule maxNumRule = new FormItemRule();
            maxNumRule.setMaximum(maxNumber);            maxNumRule.setMessage("输入数字不能大于 " + maxNumber);
            rules.add(maxNumRule);        }    }}

properties复制代码# 切换数据库
	SELECT index
# 当前数据库有的数据量
	DBSIZE
# 清空当前数据库内容
	FLUSHDB
# 清空所有数据库内容
	FLUSHALL

properties复制代码# 删除指定key（一个或多个）
	DEL key [key ...]	
# 序列化指定key的值
	DUMP key	
# 查询key是否存在
	EXISTS key	

# 设置一个key的过期时间（s）
	EXPIRE key seconds	
# 获取key的有效时间（s）（-1，永久有效；-2，无效，没有该key）
	TTL key		
# 移除key的过期时间
	PERSIST key

# 查找所有匹配给定的模式的键（通配符: *: 代表所有;  ?: 代表一个字符）
	KEYS pattern	
# 返回一个随机的key
	RANDOMKEY
# 将一个key重命名
	RENAME key newkey
# 重命名一个key，新的key必须是一个不存在的key
	RENAMENX key newkey
# 移动一个key到另一个数据库
	MOVE key db

properties复制代码# 赋值语法
# 设置给定 key的值，如果key已经存在值，覆盖旧值，且无视类型
	SET key value
# key不存在时，为key赋值；key存在，命令失效
	SETNX key value // 重要，分布式锁问题
# 为多个key-value赋值
	MSET key value [key value...]
# 追加一个值到key上，返回字符串长度
	APPEND key value

properties复制代码# 取值语法
# 返回 key 的value
	GET key
# 获取存储在key上的值的一个字符串，start - end表示取值范围（0-x） 
	GETRANGE key start end
# 设置一个key的值，并获取设置前的值（应用场景广泛）
	GETSET key value
# 获取指定key值的长度
	STRLEN key
# 返回位的值存储在关键的字符串值的偏移量
	GETBIT key offset

properties复制代码# 删除语法
# 删除指定key，如果存在，返回数字类型（删除的个数）
	DEL key

properties复制代码# 自增、自减，并返回结果数
# 将key存储的值自增加一，如果key不存在，那么key的值会先初始为0，再执行incr操作
	INCR key
# 将key存储的值自增自定义的数，如果key不存在，那么key的值会先初始为0，在执行incrby操作
	INCRBY key increment
# 自减一
	DECR key
# 自减自定义的值
	DECRBY key increment

properties复制代码# 赋值语法
# 为指定的key，设定key/value.相当于 key:对象名 field:属性名 value:属性值
	HSET key field value
# 同时将多个 field-value(域-值)对设置到哈希表key中
	HMSET key field value [field value]...

properties复制代码# 取值语法
# 取出 key 的field的值
	HGET key field
# 取出 key 中多个field的值
	HMGET key field [field...]
# 获取 key 的所有 field 和 value
	HGETALL key
# 获取key中所有field
	HKEYS key
# 获取 key 中field的数量
	HLEN key

properties复制代码# 删除语法
# 删除key中一个或多个field，当key的所有field的值都删除完了，redis会删除这个key
		HDEL key field [field...]

properties复制代码# 其他语法
# 只有key不存在时，设置字段的值 
	HSETNX key field value
# 为哈希表key中的指定字段的整数值加上增量increment
	HINCRBY key field increment
# 为哈希表key中的指定字段的浮点数值加上增量increment
	HINCRBYFLOAT key field increment
# 查看哈希表key中，指定的field是否存在
	HEXISTS key field

properties复制代码例：
key:user:id    1
    user:name  xiaojian
    user:age   22

properties复制代码127.0.0.1:6379> lpush list2 1
(integer) 1
127.0.0.1:6379> lpush list2 2
(integer) 2
127.0.0.1:6379> lpush list2 3
(integer) 3
127.0.0.1:6379> lpush list2 3
(integer) 4
127.0.0.1:6379> lrange list2 0 -1
1) "3"
2) "3"
3) "2"
4) "1"

properties复制代码# 赋值语法
# 从列表左边存入一个或多个元素
	LPUSH key value[value...]
# 当列表存在时，从列表左边存入一个（列表不存在，无法存入）
	LPUSHX key value
# 从列表右边存入一个或多个元素
	RPUSH key value[value...]
# 当列表存在时，从列表右边存入一个（列表不存在，无法存入）
	RPUSHX key value

# 在列表中的另一个元素之前或之后插入一个元素
	LINSERT key BEFORE|AFTER pivot value
如：linsert list1 BEFORE "c" "b"		# 在元素 "c" 之前插入 "b"

# 根据索引，设置列表里面一个元素的值
	LSET key index value

properties复制代码# 取值语法
# 通过其索引获取一个元素
	LINDEX key index
# 从列表获取指定范围内的元素，start和stop偏移量为 -1 指最后一个元素，-2指倒数第二个，一次类推
	LRANGE key start stop
# 获取列表长度
	LLEN key
# 截取指定范围的数据，列表中的数据改变成截取的数据
	LTRIM key start stop

properties复制代码# 删除语法
# 从列表最左边移除一个元素，并返回这个元素
	LPOP key
# 从列表最右边移除一个元素，并返回这个元素
	RPOP key
# 从存于 key 的列表里移除前 count 次出现的值为 value 的元素。
# count为正数时，移除前count个；为负数时，移除后count个；为0，移除所有value
	LREM key count value

properties复制代码#任务队列介绍（生产者和消费者模式）：
#	在处理web客户端发送的命令请求时，某些操作的执行时间可能会比我们预期的更长一些，通过将待执行任务的相关信息放入队
列里面，并在之后对队列进行处理，用户可以推迟执行那些需要一段时间才能完成的操作，这种将工作交给任务处理器来执行的做法
被称为任务队列（task queue）。

	RPOPLPUSH source destination
# 一处列表的最后一个元素，并将该元素添加到另一个列表并返回（对同一个list使用，把最后一个元素，调到首个）

properties复制代码# 赋值语法
# 添加一个或多个元素
	SADD key member [member...]

properties复制代码# 取值语法
# 获取集合中所有元素
	SMEMBERS key 
# 获取集合长度
	SCARD key
# 判断 member 元素是否是集合 key 的成员（开发中：验证是否存在判断）
	SISMEMBER key member
# 返回集合中一个或多个随机数
	SRANDMEMBER key [count]

# 差集语法：
	SDIFF key1 [key2] : 返回给定 key1 集合与其他集合的差集
	SDIFFSTORE destination key1 [key2] : 返回给定所有集合的差集并存储在 destination 中（destination是一个新建的key的名称）
# 交集语法：
	SINTER key1 [key2] : 返回给定所有集合的交集（共有数据）
	SINTERSTORE destination key1 [key2] : 返回给定所有集合的交集并存储在 destination 中（destination是一个新建的key的名称）
# 并集语法：
	SUNION key1 [key2] : 返回所有给定集合的并集
	SUNIONSTORE destination key1 [key2] : 返回给定所有集合的并集并存储在 destination

properties复制代码# 删除语法
# 删除一个或多个元素
	SREM key member1 [member2]
# 移除并返回集合的一个随机元素
	SPOP key [count]
# 将 member 元素从 source 集合移动到 destination 集合
	SMOVE source destination member

properties复制代码# 赋值语法
	ZADD key score member [score member...]

properties复制代码# 取值语法
# 获取有序集合的成员数
	ZACARD key 
# 计算在有序集合中指定区间分数的成员数
	ZCOUNT key min max
# 返回有序集合中指定成员的索引
	ZRANK key member

# 通过索引区间返回有序集合中指定区间的成员（0，-1）
	ZRANGE key start end [WITHSCORES]
# 通过分数返回有序集合指定区间内的成员
	ZRANGBYSCORE key min max [WITHSCORES] [LIMIT]

# 返回有序集合指定区间内的成员，通过索引，分数从高到低
	ZREVRANGE key start stop [WITHSCORES]
# 返回有序集合指定分数区间内的成员，通过索引，分数从高到低
	ZREVRANGEBySCORE key max min [WITHSCORES]

properties复制代码# 删除语法
# 移除集合
	DEL key
# 移除有序集合中的一个或多个成员
	ZREM key member [member ...]

复制代码Redis 在2.8.9 版本添加了 HyperLogLog 结构
Redis HyperLogLog 是用来做基数统计的算法，HyperLogLog 的优点是，在输入元素的数量或体积非常大时，计算基数所需的空间总是固定的，并且是很小的

复制代码在 Redis 里面，每个 HyperLogLog 键只需要花费 12 KB内存，就可以计算接近 2^64 个不同元素的基数。这和计算基数时，元素越多耗费内存就越多的集合形成鲜明对比。
但是，因为 HyperLogLog 只会根据输入元素来计算基数，而不会储存输入元素本身，所以 HyperLogLog 不能像集合那样，返回输入的各个元素。

markdown复制代码什么是基数？
	比如数据集{1,3,5,7,5,7,8}，那么这个数据集的基数集为{1,3,5,7,8}，基数（不重复元素）为5。
	基数估计就是在误差可接受的范围内，快速计算基数.

properties复制代码# 添加指定元素到 HyperLogLog 中
	PFADD key element [element ...]
# 返回给定 HyperLogLog 的基数估算值
	PFCOUNT key [key ...]
# 将多个 HyperLogLog 合并为一个 HyperLogLog
	PFMERGE destkey sourcekey [sourcekey ...]

tex复制代码统计注册 IP 数
统计每日访问 IP 数
统计页面实时  UV 数
统计在线用户数
统计用户每天搜索不同词条的个数
统计真是文章阅读数

复制代码这玩意有点四不像，不说了，丢脸～

复制代码资源预热： 通过预先将资源加载到CDN
回源： CDN找不到资源后，会触发源站（商品服务）调用，进行查询对应资源，如果源站存在该资源，则会返回到CDN中进行缓存。
OSS： 实际存储静态资源的服务（可参考阿里云OSS）

css复制代码跨城异地主要问题就是网络传输延迟，例如北京到广州，正常情况下的RTT（Round-Trip Time 往返时延）是50毫秒，
当遇到网络波动等情况，会升到500毫秒甚至1秒，而且会有丢包问题。

物理距离必然导致数据不一致，这就得从“数据”特性来解决，
如果是强一致性要求的数据（如存款余额），就无法做异地多活。

go复制代码func divRoundUp(n, a uintptr) uintptr {
	return (n + a - 1) / a
}

go复制代码func isPowerOfTwo(x uintptr) bool {
	return x&(x-1) == 0
}

go复制代码// 向上将x舍入为a的倍数，例如：x=6，a=4则返回值为8
func alignUp(x, a uintptr) uintptr {
	return (x + a - 1) &^ (a - 1)
}

// 向上将x舍入为a的倍数，例如：x=6，a=4则返回值为4
func alignDown(x, a uintptr) uintptr {
	return x &^ (a - 1)
}

go复制代码// bool2int returns 0 if x is false or 1 if x is true.
func bool2int(x bool) int {
	return int(uint8(*(*uint8)(unsafe.Pointer(&x))))
}

go复制代码var ntz8tab = [256]uint8{
	0x08, ..., 0x00,
}
// Ctz8 returns the number of trailing zero bits in x; the result is 8 for x == 0.
func Ctz8(x uint8) int {
	return int(ntz8tab[x])
}

const deBruijn32ctz = 0x04653adf

var deBruijnIdx32ctz = [32]byte{
	0, 1, 2, 6, 3, 11, 7, 16,
	4, 14, 12, 21, 8, 23, 17, 26,
	31, 5, 10, 15, 13, 20, 22, 25,
	30, 9, 19, 24, 29, 18, 28, 27,
}

// Ctz32 counts trailing (low-order) zeroes,
// and if all are zero, then 32.
func Ctz32(x uint32) int {
	x &= -x                       // isolate low-order bit
	y := x * deBruijn32ctz >> 27  // extract part of deBruijn sequence
	i := int(deBruijnIdx32ctz[y]) // convert to bit index
	z := int((x - 1) >> 26 & 32)  // adjustment if zero
	return i + z
}

const deBruijn64ctz = 0x0218a392cd3d5dbf

var deBruijnIdx64ctz = [64]byte{
	0, 1, 2, 7, 3, 13, 8, 19,
	4, 25, 14, 28, 9, 34, 20, 40,
	5, 17, 26, 38, 15, 46, 29, 48,
	10, 31, 35, 54, 21, 50, 41, 57,
	63, 6, 12, 18, 24, 27, 33, 39,
	16, 37, 45, 47, 30, 53, 49, 56,
	62, 11, 23, 32, 36, 44, 52, 55,
	61, 22, 43, 51, 60, 42, 59, 58,
}

// Ctz64 counts trailing (low-order) zeroes,
// and if all are zero, then 64.
func Ctz64(x uint64) int {
	x &= -x                       // isolate low-order bit
	y := x * deBruijn64ctz >> 58  // extract part of deBruijn sequence
	i := int(deBruijnIdx64ctz[y]) // convert to bit index
	z := int((x - 1) >> 57 & 64)  // adjustment if zero
	return i + z
}

css复制代码// Copied from math/bits to avoid dependence.

go复制代码// Dummy annotation marking that the value x escapes,
// for use in cases where the reflect code is so clever that
// the compiler cannot follow.
func escapes(x interface{}) {
	if dummy.b {
		dummy.x = x
	}
}

var dummy struct {
	b bool
	x interface{}
}

go复制代码
// Gosched yields the processor, allowing other goroutines to run. It does not
// suspend the current goroutine, so execution resumes automatically.
func Gosched() {
	checkTimeouts()
	mcall(gosched_m)
}

sql复制代码CREATE TABLE `test` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

sql复制代码select * from test where id between 1 and 10 for update;

sql复制代码CREATE TABLE `test` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) DEFAULT NULL,
  `class` int(11) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `index_class` (`class`) USING BTREE COMMENT '非唯一索引'
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

sql复制代码select * from test where class = 3 for update;

sql复制代码–A线程
update user set name = “dong”, version = version+1 where id = 2 and version = 1

–B 线程抢先完成，这个时候version = 2，会导致A修改失败！
update user set name = “dong”, version = version+1 where id = 2 and version = 1

sql复制代码@Configuration
public class MyConfig {

    //乐观锁插件
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return interceptor;
    }

}

javascript复制代码service Simple {
    // 接口定义
    rpc SayHello (HelloRequest) returns (HelloReply) {
    }
}

groovy复制代码// 使用springboot插件
plugins {
    id 'org.springframework.boot'
}

dependencies {
    implementation 'org.projectlombok:lombok'
    implementation 'org.springframework.boot:spring-boot-starter'
    // 作为gRPC服务提供方，需要用到此库
    implementation 'net.devh:grpc-server-spring-boot-starter'
    // 依赖自动生成源码的工程
    implementation project(':grpc-lib')
}

yaml复制代码spring:
  application:
    name: local-server
# gRPC有关的配置，这里只需要配置服务端口号
grpc:
  server:
    port: 9898

java复制代码package com.bolingcavalry.grpctutorials;

import io.grpc.Metadata;
import io.grpc.ServerCall;
import io.grpc.ServerCallHandler;
import io.grpc.ServerInterceptor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class LogGrpcInterceptor implements ServerInterceptor {
    @Override
    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> serverCall, Metadata metadata,
                                                                 ServerCallHandler<ReqT, RespT> serverCallHandler) {
        log.info(serverCall.getMethodDescriptor().getFullMethodName());
        return serverCallHandler.startCall(serverCall, metadata);
    }
}

java复制代码package com.bolingcavalry.grpctutorials;

import io.grpc.ServerInterceptor;
import net.devh.boot.grpc.server.interceptor.GrpcGlobalServerInterceptor;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class GlobalInterceptorConfiguration {
    @GrpcGlobalServerInterceptor
    ServerInterceptor logServerInterceptor() {
        return new LogGrpcInterceptor();
    }
}

java复制代码package com.bolingcavalry.grpctutorials;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class LocalServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(LocalServerApplication.class, args);
    }
}

java复制代码package com.bolingcavalry.grpctutorials;

import com.bolingcavalry.grpctutorials.lib.HelloReply;
import com.bolingcavalry.grpctutorials.lib.SimpleGrpc;
import net.devh.boot.grpc.server.service.GrpcService;
import java.util.Date;

@GrpcService
public class GrpcServerService extends SimpleGrpc.SimpleImplBase {

    @Override
    public void sayHello(com.bolingcavalry.grpctutorials.lib.HelloRequest request,
                         io.grpc.stub.StreamObserver<com.bolingcavalry.grpctutorials.lib.HelloReply> responseObserver) {
        HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + request.getName() + ", " + new Date()).build();
        responseObserver.onNext(reply);
        responseObserver.onCompleted();
    }
}

groovy复制代码plugins {
    id 'org.springframework.boot'
}

dependencies {
    implementation 'org.projectlombok:lombok'
    implementation 'org.springframework.boot:spring-boot-starter'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'net.devh:grpc-client-spring-boot-starter'
    implementation project(':grpc-lib')
}

yml复制代码server:
  port: 8080
spring:
  application:
    name: local-grpc-client

grpc:
  client:
    # gRPC配置的名字，GrpcClient注解会用到
    local-grpc-server:
      # gRPC服务端地址
      address: 'static://127.0.0.1:9898'
      enableKeepAlive: true
      keepAliveWithoutCalls: true
      negotiationType: plaintext

java复制代码package com.bolingcavalry.grpctutorials;

import io.grpc.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LogGrpcInterceptor implements ClientInterceptor {

    private static final Logger log = LoggerFactory.getLogger(LogGrpcInterceptor.class);

    @Override
    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method,
            CallOptions callOptions, Channel next) {
        log.info(method.getFullMethodName());
        return next.newCall(method, callOptions);
    }
}

java复制代码package com.bolingcavalry.grpctutorials;

import io.grpc.ClientInterceptor;
import net.devh.boot.grpc.client.interceptor.GrpcGlobalClientInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;

@Order(Ordered.LOWEST_PRECEDENCE)
@Configuration(proxyBeanMethods = false)
public class GlobalClientInterceptorConfiguration {

    @GrpcGlobalClientInterceptor
    ClientInterceptor logClientInterceptor() {
        return new LogGrpcInterceptor();
    }
}

java复制代码package com.bolingcavalry.grpctutorials;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class LocalGrpcClientApplication {

    public static void main(String[] args) {
        SpringApplication.run(LocalGrpcClientApplication.class, args);
    }
}

java复制代码package com.bolingcavalry.grpctutorials;

import com.bolingcavalry.grpctutorials.lib.HelloReply;
import com.bolingcavalry.grpctutorials.lib.HelloRequest;
import com.bolingcavalry.grpctutorials.lib.SimpleGrpc;
import io.grpc.StatusRuntimeException;
import net.devh.boot.grpc.client.inject.GrpcClient;
import org.springframework.stereotype.Service;

@Service
public class GrpcClientService {

    @GrpcClient("local-grpc-server")
    private SimpleGrpc.SimpleBlockingStub simpleStub;

    public String sendMessage(final String name) {
        try {
            final HelloReply response = this.simpleStub.sayHello(HelloRequest.newBuilder().setName(name).build());
            return response.getMessage();
        } catch (final StatusRuntimeException e) {
            return "FAILED with " + e.getStatus().getCode().name();
        }
    }
}

java复制代码package com.bolingcavalry.grpctutorials;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GrpcClientController {

    @Autowired
    private GrpcClientService grpcClientService;

    @RequestMapping("/")
    public String printMessage(@RequestParam(defaultValue = "will") String name) {
        return grpcClientService.sendMessage(name);
    }
}

java复制代码public class Task {

    public static void main(String[] args) {
        // run in a second
        final long timeInterval = 1000;
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("Hello !!");
                    try {
                        Thread.sleep(timeInterval);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

scss复制代码// 在指定延迟时间后执行指定的任务
schedule(TimerTask task,long delay);

// 在指定时间执行指定的任务。（只执行一次）
schedule(TimerTask task, Date time);

// 延迟指定时间（delay）之后，开始以指定的间隔（period）重复执行指定的任务
schedule(TimerTask task,long delay,long period);

// 在指定的时间开始按照指定的间隔（period）重复执行指定的任务
schedule(TimerTask task, Date firstTime , long period);

// 在指定的时间开始进行重复的固定速率执行任务
scheduleAtFixedRate(TimerTask task,Date firstTime,long period);

// 在指定的延迟后开始进行重复的固定速率执行任务
scheduleAtFixedRate(TimerTask task,long delay,long period);

// 终止此计时器，丢弃所有当前已安排的任务。
cancal()；

// 从此计时器的任务队列中移除所有已取消的任务。
purge()；

scala复制代码public class DoSomethingTimerTask extends TimerTask {

    private String taskName;

    public DoSomethingTimerTask(String taskName) {
        this.taskName = taskName;
    }

    @Override
    public void run() {
        System.out.println(new Date() + " : 任务「" + taskName + "」被执行。");
    }
}

typescript复制代码public class DelayOneDemo {

    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new DoSomethingTimerTask("DelayOneDemo"),1000L);
    }
}

typescript复制代码public class PeriodDemo {

    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new DoSomethingTimerTask("PeriodDemo"),2000L,1000L);
    }
}

typescript复制代码public class FixedRateDemo {

    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.scheduleAtFixedRate(new DoSomethingTimerTask("FixedRateDemo"),2000L,1000L);
    }
}

arduino复制代码ScheduledFuture<?> schedule(Runnable command,long delay, TimeUnit unit);
<V> ScheduledFuture<V> schedule(Callable<V> callable,long delay, TimeUnit unit);
ScheduledFuture<?> scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnitunit);
ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnitunit);

arduino复制代码public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
				long initialDelay,
				long period,
				TimeUnit unit);

typescript复制代码public class ScheduleAtFixedRateDemo implements Runnable{

    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        executor.scheduleAtFixedRate(
                new ScheduleAtFixedRateDemo(),
                0,
                1000,
                TimeUnit.MILLISECONDS);
    }

    @Override
    public void run() {
        System.out.println(new Date() + " : 任务「ScheduleAtFixedRateDemo」被执行。");
        try {
            Thread.sleep(2000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

arduino复制代码public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
				long initialDelay,
				long delay,
				TimeUnit unit);

typescript复制代码public class ScheduleAtFixedRateDemo implements Runnable{

    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        executor.scheduleWithFixedDelay(
                new ScheduleAtFixedRateDemo(),
                0,
                1000,
                TimeUnit.MILLISECONDS);
    }

    @Override
    public void run() {
        System.out.println(new Date() + " : 任务「ScheduleAtFixedRateDemo」被执行。");
        try {
            Thread.sleep(2000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

xml复制代码<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.2</version>
</dependency>
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz-jobs</artifactId>
    <version>2.3.2</version>
</dependency>

java复制代码public class PrintJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println(new Date() + " : 任务「PrintJob」被执行。");
    }
}

scss复制代码public class MyScheduler {

    public static void main(String[] args) throws SchedulerException {
        // 1、创建调度器Scheduler
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();
        // 2、创建JobDetail实例，并与PrintJob类绑定(Job执行内容)
        JobDetail jobDetail = JobBuilder.newJob(PrintJob.class)
                .withIdentity("job", "group").build();
        // 3、构建Trigger实例，每隔1s执行一次
        Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger", "triggerGroup")
                .startNow()//立即生效
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(1)//每隔1s执行一次
                        .repeatForever()).build();//一直执行

        //4、Scheduler绑定Job和Trigger，并执行
        scheduler.scheduleJob(jobDetail, trigger);
        System.out.println("--------scheduler start ! ------------");
        scheduler.start();
    }
}

typescript复制代码@Component("taskJob")
public class TaskJob {

    @Scheduled(cron = "0 0 3 * * ?")
    public void job1() {
        System.out.println("通过cron定义的定时任务");
    }

    @Scheduled(fixedDelay = 1000L)
    public void job2() {
        System.out.println("通过fixedDelay定义的定时任务");
    }

    @Scheduled(fixedRate = 1000L)
    public void job3() {
        System.out.println("通过fixedRate定义的定时任务");
    }
}