python复制代码from flask import Flask, flash, get_flashed_messages

app = Flask(__name__,static_url_path='/')


if __name__ == '__main__':

    app.run(host='0.0.0.0',port=443,ssl_context=('域名.pem','域名.key'))

java复制代码package com.zchi.customizeAuthentication.security.smsCode;

import lombok.Setter;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.util.AntPathMatcher;
import org.springframework.web.bind.ServletRequestBindingException;
import org.springframework.web.bind.ServletRequestUtils;
import org.springframework.web.context.request.ServletWebRequest;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @Description 短信验证码过滤器，验证短信登录验证码是否正确
 * @Author 张弛
 * @Datee 2021/7/4
 * @Version 1.0
 **/
@Setter
public class SmsValidateCodeFilter extends OncePerRequestFilter implements InitializingBean {

    private AntPathMatcher pathMatcher = new AntPathMatcher();

    private AuthenticationFailureHandler authenticationFailureHandler;

    @Override
    protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
        boolean action = false;
        String url = "/authentication/smsLogin";
        if (pathMatcher.match(url, httpServletRequest.getRequestURI())) {
            action = true;
        }

        if (action) {

            try {
                validate(new ServletWebRequest(httpServletRequest));
            } catch (ValidateCodeException e) {
                authenticationFailureHandler.onAuthenticationFailure(httpServletRequest, httpServletResponse, e);
                return;
            }

        }

        filterChain.doFilter(httpServletRequest, httpServletResponse);
    }

    private void validate(ServletWebRequest request) throws ServletRequestBindingException {

        // todo 获取验证码，现在先写死，之后改成从session或者redis中获取
        String codeInSession = "f123";

        String codeInRequest = ServletRequestUtils.getStringParameter(request.getRequest(), "smsCode");

        if (StringUtils.isBlank(codeInRequest)) {
            throw new ValidateCodeException("验证码的值不能为空");
        }

        if(codeInSession == null){
            throw new ValidateCodeException("验证码不存在");
        }

        // todo 验证码是否过期

        if(!StringUtils.equals(codeInSession, codeInRequest)) {
            throw new ValidateCodeException("验证码不匹配");
        }

        // todo 使用完这个验证码就删除
    }

    public void setFailureHandler(AuthenticationFailureHandler authenticationFailureHandler) {
        this.authenticationFailureHandler = authenticationFailureHandler;
    }
}

java复制代码package com.zchi.customizeAuthentication.security.smsCode;

import org.springframework.security.authentication.AbstractAuthenticationToken;
import org.springframework.security.core.GrantedAuthority;

import javax.security.auth.Subject;
import java.util.Collection;

/**
 * @Description 直接照着UsernamePasswordAuthenticationToken写就行
 * @Author 张弛
 * @Datee 2021/7/3
 * @Version 1.0
 **/
public class SmsCodeAuthenticationToken extends AbstractAuthenticationToken {

    private final Object principal;

    public SmsCodeAuthenticationToken(String mobile) {
        super(null);
        this.principal = mobile;
        setAuthenticated(false);
    }

    public SmsCodeAuthenticationToken(Object principal, Collection<? extends GrantedAuthority> authorities) {
        super(authorities);
        this.principal = principal;
        setAuthenticated(true);
    }

    @Override
    public Object getCredentials() {
        return this.principal;
    }

    @Override
    public Object getPrincipal() {
        return null;
    }

    @Override
    public boolean implies(Subject subject) {
        return false;
    }
}

java复制代码package com.zchi.customizeAuthentication.security.smsCode;

import lombok.Data;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.InternalAuthenticationServiceException;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;

/**
 * @Description Authentication的提供者，根据之前SmsCodeAuthenticationFilter中存入token中的信息获取当前用户信息。声明支持的token类型
 * @Author 张弛
 * @Datee 2021/7/3
 * @Version 1.0
 * @see SmsCodeAuthenticationFilter,SmsCodeAuthenticationToken
 **/
@Data
public class SmsCodeAuthenticationProvider implements AuthenticationProvider {

    private UserDetailsService userDetailsService;

    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        SmsCodeAuthenticationToken token = (SmsCodeAuthenticationToken) authentication;
        UserDetails user = userDetailsService.loadUserByUsername((String) token.getPrincipal());
        if(user == null){
            throw new InternalAuthenticationServiceException("无法获取用户信息");
        }
        SmsCodeAuthenticationToken authenticationResult = new SmsCodeAuthenticationToken(user, user.getAuthorities());
        // 需要把未认证中的一些信息copy到已认证的token中
        authenticationResult.setDetails(token);
        return authenticationResult;
    }

    // 该provider支持的token
    @Override
    public boolean supports(Class<?> authentication) {
        return SmsCodeAuthenticationToken.class.isAssignableFrom(authentication);
    }
}

java复制代码package com.zchi.customizeAuthentication.security.smsCode;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.SecurityConfigurerAdapter;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.DefaultSecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.stereotype.Component;

/**
 * @Description 将自己写的这些类配置到过滤器链上
 * @Author 张弛
 * @Datee 2021/7/3
 * @Version 1.0
 **/
@Component
public class SmsCodeAuthenticationSecurityConfig extends SecurityConfigurerAdapter<DefaultSecurityFilterChain, HttpSecurity> {

    @Autowired
    private SmsCodeAuthenticationSuccessHandler authenticationSuccessHandler;

    @Autowired
    private SmsCodeAuthenctiationFailureHandler authenticationFailureHandler;

    @Autowired
    private UserDetailsService userDetailsService;

    @Override
    public void configure(HttpSecurity httpSecurity) {
        SmsCodeAuthenticationFilter filter = new SmsCodeAuthenticationFilter();
        filter.setAuthenticationManager(httpSecurity.getSharedObject(AuthenticationManager.class));
        filter.setAuthenticationFailureHandler(authenticationFailureHandler);
        filter.setAuthenticationSuccessHandler(authenticationSuccessHandler);

        SmsCodeAuthenticationProvider smsCodeAuthenticationProvider = new SmsCodeAuthenticationProvider();
        smsCodeAuthenticationProvider.setUserDetailsService(userDetailsService);

        SmsValidateCodeFilter smsValidateCodeFilter = new SmsValidateCodeFilter();
        smsValidateCodeFilter.setAuthenticationFailureHandler(authenticationFailureHandler);
        httpSecurity.addFilterBefore(smsValidateCodeFilter, UsernamePasswordAuthenticationFilter.class);
        httpSecurity.authenticationProvider(smsCodeAuthenticationProvider)
                .addFilterAt(filter, UsernamePasswordAuthenticationFilter.class);
    }
}

java复制代码package com.zchi.customizeAuthentication.security;

import com.zchi.customizeAuthentication.security.smsCode.SmsCodeAuthenticationSecurityConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.stereotype.Component;

import java.util.Collection;

/**
 * @Description 项目的安全配置
 * @Author 张弛
 * @Datee 2021/7/3
 * @Version 1.0
 **/
@Component
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    AuthenticationFailureHandler authenticationFailureHandler;
    @Autowired
    private SmsCodeAuthenticationSecurityConfig smsCodeAuthenticationSecurityConfigs;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .antMatchers("/authentication/require",
                        "/login",
                        "/code/*",
                        "/error",
                        "/authentication/smsLogin"
                )
                .permitAll()
                .anyRequest()
                .authenticated()
                .and()
                .csrf().disable()
                // 将我们自己的短信登录配置到项目的过滤器链上
                .apply(smsCodeAuthenticationSecurityConfigs);
    }

    @Bean
    public UserDetailsService userDetailsService() {
        //获取登录用户信息
        return username -> {
            return new UserDetails() {
                @Override
                public Collection<? extends GrantedAuthority> getAuthorities() {
                    return null;
                }

                @Override
                public String getPassword() {
                    return null;
                }

                @Override
                public String getUsername() {
                    return null;
                }

                @Override
                public boolean isAccountNonExpired() {
                    return false;
                }

                @Override
                public boolean isAccountNonLocked() {
                    return false;
                }

                @Override
                public boolean isCredentialsNonExpired() {
                    return false;
                }

                @Override
                public boolean isEnabled() {
                    return false;
                }
            };
        };
    }
}

c复制代码#include <stdio.h> 
#include <string.h> 
int main()
{
int x = 2; 
char * str = "abcd"; 
int y = (x - strlen(str) ) / 2;
//注：原作者这样写，编译器可能会对其优化，直接使用右移移位指令而不是采用除法指令，改成3即可看到
printf("%d\n",y);
}

java复制代码/**
 * groupKey -> cacheData.
 */
private final AtomicReference<Map<String, CacheData>> cacheMap = new AtomicReference<Map<String, CacheData>>(new HashMap<>());

java复制代码@Override
public String getConfig(String dataId, String group, long timeoutMs) throws NacosException {
    return getConfigInner(namespace, dataId, group, timeoutMs);
}

@Override
public String getConfigAndSignListener(String dataId, String group, long timeoutMs, Listener listener)
        throws NacosException {
    String content = getConfig(dataId, group, timeoutMs);
    worker.addTenantListenersWithContent(dataId, group, content, Arrays.asList(listener));
    return content;
}

JAVA复制代码public void addTenantListenersWithContent(String dataId, String group, String content,
                                          List<? extends Listener> listeners) throws NacosException {
    group = blank2defaultGroup(group);
    String tenant = agent.getTenant();
    // 1、获取dataId对应的CacheData，如没有则向服务端发起长轮询请求获取配置
    CacheData cache = addCacheDataIfAbsent(dataId, group, tenant);
    synchronized (cache) {
        // 2、注册对dataId的数据变更监听
        cache.setContent(content);
        for (Listener listener : listeners) {
            cache.addListener(listener);
        }
        cache.setSyncWithServer(false);
        agent.notifyListenConfig();
    }
}

java复制代码public void addListener(Listener listener) {
    ManagerListenerWrap wrap =
        (listener instanceof AbstractConfigChangeListener) ? new ManagerListenerWrap(listener, md5, content)
            : new ManagerListenerWrap(listener, md5);
}

java复制代码void checkListenerMd5() {
    for (ManagerListenerWrap wrap : listeners) {
        if (!md5.equals(wrap.lastCallMd5)) {
            safeNotifyListener(dataId, group, content, type, md5, encryptedDataKey, wrap);
        }
    }
}

java复制代码configService.addListener(dataId, group, new Listener() {
    @Override
    public void receiveConfigInfo(String configInfo) {
        System.out.println("receive:" + configInfo);
    }

    @Override
    public Executor getExecutor() {
        return null;
    }
});

java复制代码public static void main(String[] args) throws NacosException, InterruptedException {
    String serverAddr = "localhost";
    String dataId = "test";
    String group = "DEFAULT_GROUP";
    Properties properties = new Properties();
    properties.put("serverAddr", serverAddr);
    ConfigService configService = NacosFactory.createConfigService(properties);
    String content = configService.getConfig(dataId, group, 5000);
    System.out.println(content);
    configService.addListener(dataId, group, new Listener() {
        @Override
        public void receiveConfigInfo(String configInfo) {
            System.out.println("数据变更 receive:" + configInfo);
        }
        @Override
        public Executor getExecutor() {
            return null;
        }
    });

    boolean isPublishOk = configService.publishConfig(dataId, group, "我是新配置内容～");
    System.out.println(isPublishOk);

    Thread.sleep(3000);
    content = configService.getConfig(dataId, group, 5000);
    System.out.println(content);
}

java复制代码数据变更 receive:我是新配置内容～
true
我是新配置内容～

Java复制代码MD5Util.compareMd5(req, rsp, clientMd5Map)

Java复制代码ConfigExecutor.executeLongPolling(
                new ClientLongPolling(asyncContext, clientMd5Map, ip, probeRequestSize, timeout, appName, tag));

java复制代码ConfigChangePublisher.notifyConfigChange(new ConfigDataChangeEvent(false, dataId, group, tenant, time.getTime()));

java复制代码
/**
 * 数据权限验证注解
 * @author xiaohua
 * @date 2021/6/23
 */
@Documented
@Target({METHOD, ANNOTATION_TYPE, TYPE})
@Retention(RUNTIME)
public @interface DataPermission {
    /**
     * 是否要进行数据权限隔离
     */
    boolean isPermi() default true;
}

java复制代码@Component
@Intercepts({@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})})
public class DataPermissionInterceptor implements Interceptor {
    private static final Logger logger = LoggerFactory.getLogger(DataPermissionInterceptor.class);

    @Autowired
    private TokenService tokenService;

    //扫描的包路径（根据自己的项目路径来），这里是取的配置里的包路径
    @Value("${permission.package-path}")
    private String packagePath;

    private final static String DEPT_ID = "dept_id";

    private final static String USER_ID = "create_user";

    private static List<String> classNames;

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        try {
            LoginInfo user = tokenService.getLoginInfo();
            if (user == null){
                return invocation.proceed();
            }

            List<Long> deptIds = (List<Long>) Convert.toList(user.getDataScope());
            if (deptIds == null){
                deptIds = new ArrayList<>();
            }
            //反射扫包会比较慢，这里做了个懒加载
            if (classNames == null) {
                synchronized (LazyInit.class){
                    if (classNames == null){
                        //扫描指定包路径下所有包含指定注解的类
                        Set<Class<?>> classSet = ClassUtil.scanPackageByAnnotation(packagePath, DataPermission.class);
                        if (classSet == null && classSet.size() == 0){
                            classNames = new ArrayList<>();
                        } else {
                            //取得类全名
                            classNames =  classSet.stream().map(Class::getName).collect(Collectors.toList());
                        }
                    }
                }
            }

            // 拿到mybatis的一些对象
            StatementHandler statementHandler = PluginUtils.realTarget(invocation.getTarget());
            MetaObject metaObject = SystemMetaObject.forObject(statementHandler);
            MappedStatement mappedStatement = (MappedStatement) metaObject.getValue("delegate.mappedStatement");

            // mappedStatement.getId()为执行的mapper方法的全路径名,newId为执行的mapper方法的类全名
            String newId = mappedStatement.getId().substring(0, mappedStatement.getId().lastIndexOf("."));
            // 如果不是指定的方法，直接结束拦截
            if (!classNames.contains(newId)) {
                return invocation.proceed();
            }
            String newName = mappedStatement.getId().substring(mappedStatement.getId().lastIndexOf(".") + 1, mappedStatement.getId().length());
            //是否开启数据权限
            boolean isPermi = true;
            Class<?> clazz = Class.forName(newId);
            //遍历方法
            for (Method method : clazz.getDeclaredMethods()) {
                //方法是否含有DataPermission注解，如果含有注解则将数据结果过滤
                if (method.isAnnotationPresent(DataPermission.class) && newName.equals(method.getName())) {
                    DataPermission dataPermission =  method.getAnnotation(DataPermission.class);
                    if (dataPermission != null) {
                        //不验证
                        if (!dataPermission.isPermi()) {
                            isPermi = false;
                        } else { //开启验证
                            isPermi = true;
                        }
                    }
                }
            }

            if (isPermi){
                // 获取到原始sql语句
                String sql = statementHandler.getBoundSql().getSql();

                // 解析并返回新的SQL语句，只处理查询sql
                if (mappedStatement.getSqlCommandType().toString().equals("SELECT")) {
    //                    String newSql = getNewSql(sql,deptIds,user.getUserId());
                    sql = getSql(sql,deptIds,user.getUserId());
                }
                // 修改sql
                metaObject.setValue("delegate.boundSql.sql", sql);
            }
            return invocation.proceed();
        } catch (Exception e){
            logger.error("数据权限隔离异常：", e);
            return invocation.proceed();
        }

    }
    
    
    /**
     * 解析SQL语句，并返回新的SQL语句
     * 注意，该方法使用了JSqlParser来操作SQL，该依赖包Mybatis-plus已经集成了。如果要单独使用，请先自行导入依赖
     *
     * @param sql 原SQL
     * @return 新SQL
     */
    private String getSql(String sql,List<Long> deptIds,Long userId) {

        try {
            String condition = "";
            String permissionSql = "(";
            if (deptIds.size() > 0){
                for (Long deptId : deptIds) {
                    if ("(".equals(permissionSql)){
                        permissionSql = permissionSql + deptId;
                    } else {
                        permissionSql = permissionSql + "," + deptId;
                    }
                }
                permissionSql = permissionSql + ")";
                // 修改原语句
                condition = DEPT_ID +" in " + permissionSql;
            } else {
                condition = USER_ID +" = " + userId;
            }

            if (StringUtils.isBlank(condition)){
                return sql;
            }
            Select select = (Select)CCJSqlParserUtil.parse(sql);
            PlainSelect plainSelect = (PlainSelect)select.getSelectBody();
            //取得原SQL的where条件
            final Expression expression = plainSelect.getWhere();
            //增加新的where条件
            final Expression envCondition = CCJSqlParserUtil.parseCondExpression(condition);
            if (expression == null) {
                plainSelect.setWhere(envCondition);
            } else {
                AndExpression andExpression = new AndExpression(expression, envCondition);
                plainSelect.setWhere(andExpression);
            }
            return plainSelect.toString();
        } catch (JSQLParserException e) {
            logger.error("解析原SQL并构建新SQL错误：" + e);
            return sql;
        }
    }

typescript复制代码

public static void main(String\[\] args) {   
       String uuid = UUID.randomUUID().toString().replaceAll("-","");  
       System.out.println(uuid);  
 }

sql复制代码

CREATE DATABASE \`SEQ\_ID\`;  
CREATE TABLE SEQID.SEQUENCE\_ID (  
    id bigint(20) unsigned NOT NULL auto\_increment,   
    value char(10) NOT NULL default '',  
    PRIMARY KEY (id),  
) ENGINE=MyISAM;

sql复制代码
insert into SEQUENCE\_ID(value)  VALUES ('values');

ini复制代码set @@auto\_increment\_offset = 1;     -- 起始值  
set @@auto\_increment\_increment = 2;  -- 步长

ini复制代码set @@auto\_increment\_offset = 2;     -- 起始值  
set @@auto\_increment\_increment = 2;  -- 步长

sql复制代码CREATE TABLE id\_generator (  
  id int(10) NOT NULL,  
  max\_id bigint(20) NOT NULL COMMENT '当前最大id',  
  step int(20) NOT NULL COMMENT '号段的布长',  
  biz\_type    int(20) NOT NULL COMMENT '业务类型',  
  version int(20) NOT NULL COMMENT '版本号',  
  PRIMARY KEY (\`id\`)  
)

python复制代码update id\_generator set max\_id = #{max\_id+step}, version = version + 1 where version = # {version} and biz\_type = XXX

bash复制代码127.0.0.1:6379\> set seq\_id 1     // 初始化自增ID为1  
OK  
127.0.0.1:6379\> incr seq\_id      // 增加1，并返回递增后的数值  
(integer) 2

go复制代码`/**`
 `* Twitter的SnowFlake算法,使用SnowFlake算法生成一个整数，然后转化为62进制变成一个短地址URL`
 `*`
 `* https://github.com/beyondfengyu/SnowFlake`
 `*/`
`public class SnowFlakeShortUrl {`
 `/**`
 `* 起始的时间戳`
 `*/`
 `private final static long START_TIMESTAMP = 1480166465631L;`
 `/**`
 `* 每一部分占用的位数`
 `*/`
 `private final static long SEQUENCE_BIT = 12;   //序列号占用的位数`
 `private final static long MACHINE_BIT = 5;     //机器标识占用的位数`
 `private final static long DATA_CENTER_BIT = 5; //数据中心占用的位数`
 `/**`
 `* 每一部分的最大值`
 `*/`
 `private final static long MAX_SEQUENCE = -1L ^ (-1L << SEQUENCE_BIT);`
 `private final static long MAX_MACHINE_NUM = -1L ^ (-1L << MACHINE_BIT);`
 `private final static long MAX_DATA_CENTER_NUM = -1L ^ (-1L << DATA_CENTER_BIT);`
 `/**`
 `* 每一部分向左的位移`
 `*/`
 `private final static long MACHINE_LEFT = SEQUENCE_BIT;`
 `private final static long DATA_CENTER_LEFT = SEQUENCE_BIT + MACHINE_BIT;`
 `private final static long TIMESTAMP_LEFT = DATA_CENTER_LEFT + DATA_CENTER_BIT;`
 `private long dataCenterId;  //数据中心`
 `private long machineId;     //机器标识`
 `private long sequence = 0L; //序列号`
 `private long lastTimeStamp = -1L;  //上一次时间戳`
 `private long getNextMill() {`
 `long mill = getNewTimeStamp();`
 `while (mill <= lastTimeStamp) {`
 `mill = getNewTimeStamp();`
 `}`
 `return mill;`
 `}`
 `private long getNewTimeStamp() {`
 `return System.currentTimeMillis();`
 `}`
 `/**`
 `* 根据指定的数据中心ID和机器标志ID生成指定的序列号`
 `*`
 `* @param dataCenterId 数据中心ID`
 `* @param machineId    机器标志ID`
 `*/`
 `public SnowFlakeShortUrl(long dataCenterId, long machineId) {`
 `if (dataCenterId > MAX_DATA_CENTER_NUM || dataCenterId < 0) {`
 `throw new IllegalArgumentException("DtaCenterId can't be greater than MAX_DATA_CENTER_NUM or less than 0！");`
 `}`
 `if (machineId > MAX_MACHINE_NUM || machineId < 0) {`
 `throw new IllegalArgumentException("MachineId can't be greater than MAX_MACHINE_NUM or less than 0！");`
 `}`
 `this.dataCenterId = dataCenterId;`
 `this.machineId = machineId;`
 `}`
 `/**`
 `* 产生下一个ID`
 `*`
 `* @return`
 `*/`
 `public synchronized long nextId() {`
 `long currTimeStamp = getNewTimeStamp();`
 `if (currTimeStamp < lastTimeStamp) {`
 `throw new RuntimeException("Clock moved backwards.  Refusing to generate id");`
 `}`
 `if (currTimeStamp == lastTimeStamp) {`
 `//相同毫秒内，序列号自增`
 `sequence = (sequence + 1) & MAX_SEQUENCE;`
 `//同一毫秒的序列数已经达到最大`
 `if (sequence == 0L) {`
 `currTimeStamp = getNextMill();`
 `}`
 `} else {`
 `//不同毫秒内，序列号置为0`
 `sequence = 0L;`
 `}`
 `lastTimeStamp = currTimeStamp;`
 `return (currTimeStamp - START_TIMESTAMP) << TIMESTAMP_LEFT //时间戳部分`
 `| dataCenterId << DATA_CENTER_LEFT       //数据中心部分`
 `| machineId << MACHINE_LEFT             //机器标识部分`
 `| sequence;                             //序列号部分`
 `}`
 `public static void main(String[] args) {`
 `SnowFlakeShortUrl snowFlake = new SnowFlakeShortUrl(2, 3);`
 `for (int i = 0; i < (1 << 4); i++) {`
 `//10进制`
 `System.out.println(snowFlake.nextId());`
 `}`
 `}`
`}`

sql复制代码DROP TABLE IF EXISTS \`leaf\_alloc\`;  
  
CREATE TABLE \`leaf\_alloc\` (  
  \`biz\_tag\` varchar(128)  NOT NULL DEFAULT '' COMMENT '业务key',  
  \`max\_id\` bigint(20) NOT NULL DEFAULT '1' COMMENT '当前已经分配了的最大id',  
  \`step\` int(11) NOT NULL COMMENT '初始步长，也是动态调整的最小步长',  
  \`description\` varchar(256)  DEFAULT NULL COMMENT '业务key的描述',  
  \`update\_time\` timestamp NOT NULL DEFAULT CURRENT\_TIMESTAMP ON UPDATE CURRENT\_TIMESTAMP COMMENT '数据库维护的更新时间',  
  PRIMARY KEY (\`biz\_tag\`)  
) ENGINE=InnoDB;

ini复制代码leaf.name=com.sankuai.leaf.opensource.test  
leaf.segment.enable=true  
leaf.jdbc.url=jdbc:mysql://localhost:3306/leaf\_test?useUnicode=true&characterEncoding=utf8&characterSetResults=utf8  
leaf.jdbc.username=root  
leaf.jdbc.password=root  
  
leaf.snowflake.enable=false  
#leaf.snowflake.zk.address=  
#leaf.snowflake.port=

ini复制代码
leaf.snowflake.enable=true  
leaf.snowflake.zk.address=127.0.0.1  
leaf.snowflake.port=2181

r复制代码CREATE TABLE \`tiny\_id\_info\` (  
  \`id\` bigint(20) unsigned NOT NULL AUTO\_INCREMENT COMMENT '自增主键',  
  \`biz\_type\` varchar(63) NOT NULL DEFAULT '' COMMENT '业务类型，唯一',  
  \`begin\_id\` bigint(20) NOT NULL DEFAULT '0' COMMENT '开始id，仅记录初始值，无其他含义。初始化时begin\_id和max\_id应相同',  
  \`max\_id\` bigint(20) NOT NULL DEFAULT '0' COMMENT '当前最大id',  
  \`step\` int(11) DEFAULT '0' COMMENT '步长',  
  \`delta\` int(11) NOT NULL DEFAULT '1' COMMENT '每次id增量',  
  \`remainder\` int(11) NOT NULL DEFAULT '0' COMMENT '余数',  
  \`create\_time\` timestamp NOT NULL DEFAULT '2010-01-01 00:00:00' COMMENT '创建时间',  
  \`update\_time\` timestamp NOT NULL DEFAULT '2010-01-01 00:00:00' COMMENT '更新时间',  
  \`version\` bigint(20) NOT NULL DEFAULT '0' COMMENT '版本号',  
  PRIMARY KEY (\`id\`),  
  UNIQUE KEY \`uniq\_biz\_type\` (\`biz\_type\`)  
) ENGINE=InnoDB AUTO\_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT 'id信息表';  
  
CREATE TABLE \`tiny\_id\_token\` (  
  \`id\` int(11) unsigned NOT NULL AUTO\_INCREMENT COMMENT '自增id',  
  \`token\` varchar(255) NOT NULL DEFAULT '' COMMENT 'token',  
  \`biz\_type\` varchar(63) NOT NULL DEFAULT '' COMMENT '此token可访问的业务类型标识',  
  \`remark\` varchar(255) NOT NULL DEFAULT '' COMMENT '备注',  
  \`create\_time\` timestamp NOT NULL DEFAULT '2010-01-01 00:00:00' COMMENT '创建时间',  
  \`update\_time\` timestamp NOT NULL DEFAULT '2010-01-01 00:00:00' COMMENT '更新时间',  
  PRIMARY KEY (\`id\`)  
) ENGINE=InnoDB AUTO\_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT 'token信息表';  
  
INSERT INTO \`tiny\_id\_info\` (\`id\`, \`biz\_type\`, \`begin\_id\`, \`max\_id\`, \`step\`, \`delta\`, \`remainder\`, \`create\_time\`, \`update\_time\`, \`version\`)  
VALUES  
    (1, 'test', 1, 1, 100000, 1, 0, '2018-07-21 23:52:58', '2018-07-22 23:19:27', 1);  
  
INSERT INTO \`tiny\_id\_info\` (\`id\`, \`biz\_type\`, \`begin\_id\`, \`max\_id\`, \`step\`, \`delta\`, \`remainder\`, \`create\_time\`, \`update\_time\`, \`version\`)  
VALUES  
    (2, 'test\_odd', 1, 1, 100000, 2, 1, '2018-07-21 23:52:58', '2018-07-23 00:39:24', 3);  
  
  
INSERT INTO \`tiny\_id\_token\` (\`id\`, \`token\`, \`biz\_type\`, \`remark\`, \`create\_time\`, \`update\_time\`)  
VALUES  
    (1, '0f673adf80504e2eaa552f5d791b644c', 'test', '1', '2017-12-14 16:36:46', '2017-12-14 16:36:48');  
  
INSERT INTO \`tiny\_id\_token\` (\`id\`, \`token\`, \`biz\_type\`, \`remark\`, \`create\_time\`, \`update\_time\`)  
VALUES  
    (2, '0f673adf80504e2eaa552f5d791b644c', 'test\_odd', '1', '2017-12-14 16:36:46', '2017-12-14 16:36:48');

ini复制代码datasource.tinyid.names=primary  
datasource.tinyid.primary.driver-class\-name\=com.mysql.jdbc.Driver  
datasource.tinyid.primary.url=jdbc:mysql://ip:port/databaseName?autoReconnect=true&useUnicode=true&characterEncoding=UTF-8  
datasource.tinyid.primary.username=root  
datasource.tinyid.primary.password=123456

makefile复制代码获取分布式自增ID: http://localhost:9999/tinyid/id/nextIdSimple?bizType=test&token=0f673adf80504e2eaa552f5d791b644c'  
返回结果: 3  
  
批量获取分布式自增ID:  
http://localhost:9999/tinyid/id/nextIdSimple?bizType=test&token=0f673adf80504e2eaa552f5d791b644c&batchSize=10'  
返回结果:  4,5,6,7,8,9,10,11,12,13

bash复制代码       <dependency>  
            <groupId\>com.xiaoju.uemc.tinyid</groupId\>  
            <artifactId>tinyid-client</artifactId>  
            <version>${tinyid.version}</version>  
        </dependency\>

ini复制代码tinyid.server =localhost:9999  
tinyid.token =0f673adf80504e2eaa552f5d791b644c

ini复制代码// 获取单个分布式自增ID  
Long id =  TinyId . nextId( " test " );  
  
// 按需批量分布式自增ID  
List< Long > ids =  TinyId . nextId( " test " , 10 );

python复制代码x, y = 10, 20
print(x, y)
 
x, y = y, x
print(x, y)
 
#1 (10, 20)
#2 (20, 10)

python复制代码n = 10 
result = 1 < n < 20 
print(result) 

# True 

result = 1 > n <= 9 
print(result) 

# False

```[回到目录](#mulu)

---


技巧3 使用三元运算符进行条件赋值。
------------------


三元运算符是 if-else 语句的快捷方式，也称为条件运算符。

以下是一些示例，您可以使用它们使代码紧凑简洁。


下面的语句与它的意思相同，即“如果 y 为 9，则将 10 分配给 x，否则将 20 分配给 x ”。如果需要，我们可以扩展运算符的链接。

同样，我们可以对类对象做同样的事情。

在上面的例子中，classA 和 classB 是两个类，其中一个类构造函数将被调用。


下面是一个没有的例子。加入评估最小数字的条件。

我们甚至可以在列表推导式中使用三元运算符。

---


技巧4 使用多行字符串
-----------


基本方法是使用从 C 语言派生的反斜杠。

另一个技巧是使用三引号。

上述方法的共同问题是缺乏适当的缩进。如果我们尝试缩进，它会在字符串中插入空格。


所以最终的解决方案是将字符串拆分成多行，并将整个字符串括在括号中。

---


技巧5 将列表元素存储到新变量中
----------------


我们可以使用一个列表来初始化一个 no。的变量。在解压列表时，变量的数量不应超过编号。列表中的元素。

---


技巧6 打印导入模块的文件路径
---------------


如果您想知道代码中导入的模块的绝对位置，请使用以下技巧。

---


技巧7 使用交互式“\_”运算符
----------------


这是一个有用的功能，我们很多人都不知道。


在 Python 控制台中，每当我们测试表达式或调用函数时，结果都会发送到临时名称 \_（下划线）。

“\_”引用上次执行的表达式的输出。[回到目录](#mulu)

---


技巧8 字典/集合理解
-----------


就像我们使用列表推导一样，我们也可以使用字典/集合推导。它们易于使用且同样有效。这是一个例子。

注意 -两个语句中只有 <:> 的区别。此外，要在 Python3 中运行上述代码，请将 替换为 。[回到目录](#mulu)

---


技巧9 调试脚本
--------


我们可以在 模块的帮助下在 Python 脚本中设置断点。请按照以下示例进行操作。

我们可以在脚本的任何地方指定 <pdb.set\_trace()> 并在那里设置断点。这是非常方便的。[回到目录](#mulu)

---


技巧10 设置文件共享
-----------


Python 允许运行 HTTP 服务器，您可以使用它从服务器根目录共享文件。下面是启动服务器的命令。


### Python 2

### Python 3

以上命令将在默认端口 8000 上启动服务器。您还可以通过将自定义端口作为最后一个参数传递给上述命令来使用自定义端口。[回到目录](#mulu)

---


技巧11 在 Python 中检查对象
-------------------


我们可以通过调用 dir() 方法来检查 Python 中的对象。这是一个简单的例子。

---


技巧12 简化 if 语句
-------------


要验证多个值，我们可以通过以下方式进行。

代替：

或者，我们可以使用 '{1,3,5,7}' 而不是 '[1,3,5,7]' 作为 'in' 运算符，因为 'set' 可以通过 O(1) 访问每个元素。[回到目录](#mulu)

---


技巧13 在运行时检测 Python 版本
---------------------


有时，如果当前运行的 Python 引擎低于支持的版本，我们可能不想执行我们的程序。为此，您可以使用以下代码片段。它还以可读格式打印当前使用的 Python 版本。

或者，您可以在上面的代码中使用sys.version\_info >= (3, 5)替换sys.hexversion!= 50660080。这是一位知情读者的建议。


在 Python 2.7 上运行时的输出。

在 Python 3.5 上运行时的输出。

---


技巧14 组合多个字符串
------------


如果您想连接列表中所有可用的标记，请参见以下示例。

现在，让我们从上面给出的列表中的元素创建一个字符串。

---


技巧15 反转 string/list 的四种方法
-------------------------


### 反转列表本身

### 在循环中迭代时反转

### 反转一个字符串

这使输出为“nohtyP tseT”


### 使用切片反转列表

上面的命令将输出 [5, 3, 1]。[回到目录](#mulu)

---


技巧16 玩枚举
--------


使用枚举器，在循环中很容易找到索引。

---


技巧17 在 Python 中使用枚举。
--------------------


我们可以使用以下方法来创建枚举定义。

---


技巧18 从函数返回多个值。
--------------


支持此功能的编程语言并不多。但是，Python 中的函数确实会返回多个值。


请参考以下示例以查看它的工作情况。

#-> 1 2 3 4[回到目录](#mulu)

---


技巧19 使用 splat 运算符解包函数参数。
------------------------


splat 运算符提供了一种解压参数列表的艺术方式。为清楚起见，请参阅以下示例。

---


技巧20 使用字典来存储 switch。
--------------------


我们可以制作一个字典存储表达式。

---


技巧21 计算一行中任意数字的阶乘。
------------------


### Python 2.x.

### Python 3.x.

---


技巧22 查找列表中出现频率最高的值。
-------------------

---


技巧23 重置递归限制。
------------


Python 将递归限制限制为 1000。我们可以重置它的值。

请仅在需要时应用上述技巧。[回到目录](#mulu)

---


技巧24 检查对象的内存使用情况。
-----------------


在 Python 2.7 中，32 位整数消耗 24 字节，而在 Python 3.5 中使用 28 字节。为了验证内存使用情况，我们可以调用 方法。


### Python 2.7.

### Python 3.5.

---


技巧25 使用 \_\_slots\_\_ 减少内存开销。
-----------------------------


你有没有观察到你的 Python 应用程序消耗了大量资源，尤其是内存？这是使用`<__slots__>`类变量在一定程度上减少内存开销的一种技巧。

显然，您可以从结果中看到内存使用量有所节省。但是当一个类的内存开销不必要地大时，你应该使用 `__slots__` 。仅在分析应用程序后执行此操作。否则，您将使代码难以更改并且没有真正的好处。[回到目录](#mulu)

---


技巧26 Lambda 模仿打印功能。
-------------------

---


技巧27 从两个相关序列创建字典。
-----------------

---


技巧28 在线搜索字符串中的多个前缀。
-------------------

---


技巧29 形成一个统一的列表，不使用任何循环。
-----------------------

如果您有一个包含嵌套列表或元组作为元素的输入列表，请使用以下技巧。但是，这里的限制是它使用了 for 循环。

统一包含列表和元组的列表的另一种更简单的方法是使用 Python 的 < more\_itertools > 包。它不需要循环。只需执行 < pip install more\_itertools >，如果还没有的话。

---


技巧30 在 Python 中实现真正的 switch-case 语句。
------------------------------------


这是使用字典来模仿 switch-case 构造的代码。

ini复制代码示例 1：
输入：buckets = 1000, minutesToDie = 15, minutesToTest = 60
输出：5

示例 2：
输入：buckets = 4, minutesToDie = 15, minutesToTest = 15
输出：2

示例 3：
输入：buckets = 4, minutesToDie = 15, minutesToTest = 30
输出：2

c++复制代码class Solution {
public:
    int poorPigs(int buckets, int minutesToDie, int minutesToTest) {
        int states = minutesToTest / minutesToDie + 1;
        return ceil(log(buckets) / log(states));
    }
};