javacoo
javacoo

基于Redis+Lua实现分布式限流组件

limit-spring-boot-starter

limit-spring-boot-starter是一个基于springboot starter机制，结合SPI 接口设计思想(内部集成：Redis+Lua实现限流算法(令牌桶,固定窗口,滑动窗口)以及限流回退默认实现)，支持注解方式/配置文件方式接入限流，扩展方便，集成使用简单的分布式限流组件。
开源地址：https://gitee.com/javacoo/limit-spring-boot-starter

背景介绍

业务背景

1、随着业务的快速发展，对接的第三方合作机构越来越多，对外提供服务API访问量成倍增加，导致服务器压力也不断增加，而服务器资源是有限的，当请求量达到设计的极限时，如果不采取措施，轻则导致服务响应时间变长，重则可能造成整个系统瘫痪。

生产环境背景

1、账单日批量业务接口访问量暴增，特别是某个时间段
2、业务方调用接口的速度未知，QPS可能达到400/s，600/s，或者更高
3、对外服务API性能上限是 QPS 300/s
4、已经出现服务不可用，应用崩溃的事故

需求分析

1、鉴于业务方对接口的调用频率未知，而我方的接口服务有上限，为保证服务的可用性，业务层需要对接口调用方的流量进行限制—–接口限流。

2、尽量少改或者不改造已有功能：少侵入或者0侵入式开发。

3、扩展方便，集成简单，开发速率高，使用简单。

设计思路

主流思路

  • 在开发高并发系统时有三把利器用来保护系统：缓存、降级和限流。缓存的目的是提升系统访问速度和增大系统能处理的容量，可谓是抗高并发流量的银弹；而降级是当服务出问题或者影响到核心流程的性能则需要暂时屏蔽掉，待高峰或者问题解决后再打开；而有些场景并不能用缓存和降级来解决，比如稀缺资源（秒杀、抢购）、写服务（如评论、下单）、频繁的复杂查询（评论的最后几页），因此需有一种手段来限制这些场景的并发/请求量，即限流。

  • 常见的限流有：限制总并发数（比如数据库连接池、线程池）、限制瞬时并发数（如nginx的limit_conn模块，用来限制瞬时并发连接数）、限制时间窗口内的平均速率（如Guava的RateLimiter、nginx的limit_req模块，限制每秒的平均速率）；其他还有如限制远程接口调用速率、限制MQ的消费速率。另外还可以根据网络连接数、网络流量、CPU或内存负载等来限流。

  • 如果是单节点我们可以使用google为我们提供的guava包下的RateLimiter进行限流，它使用的是令牌桶算法，分布式场景下也可以使用网关进行限流，如Spring Clound Gateway，其实还有很多开源的限流框架如阿里的Sentinel，甚至我们可以利用redis+lua脚本自己来实现限流。

前面的话

在实际应用时也不要太纠结算法问题，因为一些限流算法实现是一样的只是描述不一样；具体使用哪种限流技术还是要根据实际场景来选择，不要一味去找最佳模式，白猫黑猫能解决问题的就是好猫 ：)

我的思路

组件基于springboot starter机制，结合SPI 接口设计思想(内部集成：Redis+Lua实现限流算法(令牌桶,固定窗口,滑动窗口)以及限流回退默认实现)，支持注解方式/配置文件方式接入限流，主要分为以下部分：

  • 新建 springboot starter工程
  • 基于SPI思想设计扩展接口
  • redis+lua实现分布式限流
  • 支持接口添加注解方式限流
  • 支持配置文件方式限流
  • 支持限流回退
  • ...

具体实现见 实施步骤 一节，由于实施步骤较多，故放在后面章节，我们先来看看如何集成及使用。

集成及使用

集成

   com.javacoo
   limit-spring-boot-starter
   1.0.0
使用

  • 配置文件接入限流

    主要配置说明，详见 LimitConfig 限流配置，覆盖原则：有方法级独立配置则使用独立配置，否则使用全局配置，当配置了 limit.expression限流表达式则激活了配置文件接入限流，注解方式失效。

    config.png 
#全局配置
#限流表达式：拦截 com.javacoo.service.example.service 包及子包下所有方法
limit.expression=execution(* com.javacoo.service.example.service..*.*(..))
#全局限流回退实现名称
limit.limit-rule.fallback-impl=globalFallback

#方法级配置：针对getExampleInfo方法 配置独立的限流规则
#给定的时间范围 单位(秒)
limit.limit-method-map[getExampleInfo].period = 60
#一定时间内最多访问次数
limit.limit-method-map[getExampleInfo].count = 5
#限流类型
limit.limit-method-map[getExampleInfo].limitType = CUSTOMER
#降级策略
limit.limit-method-map[getExampleInfo].fallbackStrategy = FALLBACK
#当降级策略为:回退 时回退处理接口实现名称
limit.limit-method-map[getExampleInfo].fallbackImpl = getExampleInfoFallback

  • 使用注解方式接入限流：默认配置情况

        //60秒内，允许访问1次
    @Limit(period = 60,count = 1)
  public Optional getExampleInfo(String id) {
      AbstractAssert.isNotBlank(id, ErrorCodeConstants.SERVICE_GET_EXAMPLE_INFO_ID);
        ExampleDto exampleDto = new ExampleDto();
        exampleDto.setId("1");
        exampleDto.setData("正常数据");
        return Optional.ofNullable(exampleDto);
  }

    限流效果：正常访问

    2021-05-29 15:13:38.553  INFO 16452 --- [           main] c.j.l.c.i.redis.RedisLuaRateLimiter      : [限流交易请求],key:[COM.JAVACOO.SERVICE.EXAMPLE.SERVICE.IMPL.EXAMPLESERVICEIMPL.GETEXAMPLEINFO],60秒内,已访问次数:1,60秒内,限制次数:1
2021-05-29 15:13:38.553  INFO 16452 --- [           main] c.j.l.c.handler.AbstractLimitHandler     : [限流交易请求],尝试获取执行权限成功,开始执行目标方法
...

    限流效果：降级策略:FAIL_FAST

    2021-05-29 15:14:14.413  INFO 16192 --- [           main] c.j.l.c.i.redis.RedisLuaRateLimiter      : [限流交易请求],key:[COM.JAVACOO.SERVICE.EXAMPLE.SERVICE.IMPL.EXAMPLESERVICEIMPL.GETEXAMPLEINFO],60秒内,已访问次数:2,60秒内,限制次数:1
2021-05-29 15:14:14.414  INFO 16192 --- [           main] c.j.l.c.handler.AbstractLimitHandler     : [限流交易请求],尝试获取执行权限失败,服务降级处理,降级策略:FAIL_FAST
2021-05-29 15:14:14.416 ERROR 16192 --- [           main] c.j.l.c.handler.AbstractLimitHandler     : [限流服务执行异常]
com.javacoo.limit.client.exception.LimitException: 访问过于频繁,超出访问限制
...

  • 使用注解接入限流：回退策略情况

    //60秒内，允许访问1次，回退策略，指定回退处理类
@Limit(period = 60,count = 1,fallbackStrategy = FallbackStrategy.FALLBACK,fallbackImpl = "getExampleInfoFallback")
public Optional getExampleInfo(String id) {
      AbstractAssert.isNotBlank(id, ErrorCodeConstants.SERVICE_GET_EXAMPLE_INFO_ID);
        ExampleDto exampleDto = new ExampleDto();
        exampleDto.setId("1");
        exampleDto.setData("正常数据");
        return Optional.ofNullable(exampleDto);
  }

    限流效果：正常访问

    2021-05-29 15:22:44.613  INFO 16720 --- [           main] c.j.l.c.i.redis.RedisLuaRateLimiter      : [限流交易请求],key:[COM.JAVACOO.SERVICE.EXAMPLE.SERVICE.IMPL.EXAMPLESERVICEIMPL.GETEXAMPLEINFO],60秒内,已访问次数:1,60秒内,限制次数:1
2021-05-29 15:22:44.614  INFO 16720 --- [           main] c.j.l.c.handler.AbstractLimitHandler     : [限流交易请求],尝试获取执行权限成功,开始执行目标方法
...

     限流效果：降级策略:FALLBACK

2021-05-29 15:23:09.497  INFO 8592 --- [           main] c.j.l.c.handler.AnnotationLimitHandler   : [AnnotationLimitHandler限流交易请求],尝试获取方法:com.javacoo.service.example.service.impl.ExampleServiceImpl.getExampleInfo,执行权限
2021-05-29 15:23:09.666  INFO 8592 --- [           main] c.j.l.c.i.redis.RedisLuaRateLimiter      : [限流交易请求],key:[COM.JAVACOO.SERVICE.EXAMPLE.SERVICE.IMPL.EXAMPLESERVICEIMPL.GETEXAMPLEINFO],60秒内,已访问次数:2,60秒内,限制次数:1
2021-05-29 15:23:09.666  INFO 8592 --- [           main] c.j.l.c.handler.AbstractLimitHandler     : [限流交易请求],尝试获取执行权限失败,服务降级处理,降级策略:FALLBACK
2021-05-29 15:23:09.668  INFO 8592 --- [           main] c.j.s.e.fallback.GetExampleInfoFallback  : getExampleInfo方法降级处理
...

  • 限流回退扩展实现

    基于xkernel 提供的SPI机制（详见：https://gitee.com/javacoo/xkernel
    ），扩展非常方便，大致步骤如下：

    1. 实现限流回退接口：如 com.javacoo.service.example.fallback.GetExampleInfoFallback,com.javacoo.service.example.fallback.GlobalFallback

    2. 配置限流回退接口：

      • 在项目resource目录新建包->META-INF->services

      • 创建com.javacoo.limit.client.api.Fallback文件，文件内容：实现类的全局限定名，如：

        globalFallback=com.javacoo.service.example.fallback.GlobalFallback
getExampleInfoFallback=com.javacoo.service.example.fallback.GetExampleInfoFallback
      fallback.png 
 - 修改配置文件，添加如下内容:

   ```properties
   #全局配置
   limit.limit-rule.fallback-impl=globalFallback
   #方法级配置
   limit.limit-method-map[getExampleInfo].fallbackImpl = getExampleInfoFallback
   ```

全局实现

/**
 * 全局方法降级处理接口实现
 * 
  • 
 *
 * @author: [email protected]
 * @since: 2021/5/29 14:35
 */
@Slf4j
public class GlobalFallback implements Fallback {
    /**
     * 服务降级处理
     * 
  • 
     *
     * @author [email protected]
     * @date 2021/5/29 10:25
     * @return: R 返回对象
     */
    @Override
    public Object getFallback() {
        log.info("全局降级处理");
        return null;
    }
}
 
 
    指定方法实现
     
 
    /**
 * getExampleInfo方法降级处理接口实现
 * 
  • 
 *
 * @author: [email protected]
 * @since: 2021/5/29 11:20
 */
@Slf4j
public class GetExampleInfoFallback implements Fallback> {
    /**
     * 服务降级处理
     * 
  • 
     *
     * @author [email protected]
     * @date 2021/5/29 10:25
     * @return: java.lang.Object 返回对象
     */
    @Override
    public Optional getFallback() {
        log.info("getExampleInfo方法降级处理");
        ExampleDto exampleDto = new ExampleDto();
        exampleDto.setData("请求过多,请稍后再试");
        return Optional.ofNullable(exampleDto);
    }
}

     
 
    实施步骤
     
 
    1，新建limit-spring-boot-starter工程
     
 
       
  
    • 工程结构
      •  
 
     
 
     
  
     
   
      
   
     
  
     
  
    
    limit.png 
  
     
 
     
 
       
  
    • 类结构图
      •  
 
     
 
     
  
     
   
      
   
     
  
     
  
    
    RateLimiter.png 
  
     
 
     
 
       
  
    •  
      项目结构
       
      limit-spring-boot-starter
 └── src
    ├── main  
    │ ├── java  
    │ │   └── com.javacoo
    │ │   ├────── limit
    │ │   │         ├──────client
    │   │   │         │         ├── api
    │   │   │         │         │    ├── Fallback 服务降级回退处理接口
    │   │   │         │         │    └── RateLimiter 限流接口
    │   │   │         │         ├── annotation
    │   │   │         │         │    └── Limit 限流注解
    │   │   │         │         ├── config
    │   │   │         │         │    ├── LimitRule 限流规则配置
    │   │   │         │         │    └── LimitConfig 限流配置
    │   │   │         │         ├── enums
    │   │   │         │         │    ├── FallbackStrategy 降级策略
    │   │   │         │         │    └── LimitType 限流类型
    │   │   │         │         ├── exception
    │   │   │         │         │    └── LimitException 限流异常
    │   │   │         │         ├── util
    │   │   │         │         │    └── WebUtil 工具类
    │   │   │         │         ├── handler
    │   │   │         │         │    ├── AbstractLimitHandler 抽象限流处理器
    │   │   │         │         │    ├── AnnotationLimitHandler 限流注解处理器
    │   │   │         │         │    ├── ConfigLimitHandler 限流配置处理器
    │   │   │         │         │    └── LimitPointcutAdvisor 限流切面Advisor
    │   │   │         │         └── internal 接口内部实现
    │   │   │         │              ├── redis
    │   │   │         │              │    ├── DefaultFallback 服务降级回退处理接口默认实现
    │   │   │         │              └── redis
    │   │   │         │                   ├── LimitRedisConfig RedisTemplate配置类
    │   │   │         │                   ├── AbstractRateLimiter 抽象限流接口实现
    │   │   │         │                   ├── FixedWindowRateLimiter 固定窗口算法实现类
    │   │   │         │                   ├── LeakyBucketRateLimiter 漏桶算法实现类
    │   │   │         │                   ├── SlidingWindowRateLimiter 滑动窗口算法实现类
    │   │   │         │                   └── TokenBucketRateLimiter 令牌桶算法实现类
    │ │   │         └──────starter
    │   │   │                   ├── LimitAutoConfiguration 自动配置类
    │   │   │                   └── RateLimiterHolder 分布式限流接口对象持有者
    │ └── resource  
    │     ├── META-INF
    │       │      ├── spring.factories
    │       │      └── ext
    │     │           └── internal
    │     │                   ├── com.javacoo.limit.client.api.Fallback
    │     │                   └── com.javacoo.limit.client.api.RateLimiter
    │     └── script
    │             ├── FixedWindow.lua
    │             ├── LeakyBucket.lua
    │             ├── SlidingWindow.lua
    │             └── TokenBucket.lua
    └── test  测试

       
      •  
 
     
 
    2，基于SPI思想设计扩展接口
     
 
       
  
    •  
      限流接口->com.javacoo.limit.client.api.RateLimiter
       
      /**
 * 限流接口
 * 
      说明:
      
 * 
    • 
 * @author duanyong
 * @date 2021/5/6 22:25
 */
@Spi(LimitConfig.DEFAULT_IMPL)
public interface RateLimiter {
    /** 默认时间单位:秒 */
    TimeUnit DEFAULT_TIME_UNIT = TimeUnit.SECONDS;
    /** 默认限流时间范围:1 */
    int DEFAULT_PERIOD = 1;
    /** 默认限流数量: 10 */
    int DEFAULT_LIMIT_COUNT = 10;
    /**
     * 尝试获取
     * 
      说明:
      
     * 
    • 
     * @author duanyong
     * @date 2021/5/6 23:09
     * @param keys key
     * @param count 限制数量
     * @return boolean 是否成功
     */
    boolean tryAcquire(ImmutableList keys ,int count);
    /**
     * 尝试获取
     * 
      说明:
      
     * 
    • 
     * @author duanyong
     * @date 2021/5/7 23:09
     * @param keys key
     * @param count 限制数量
     * @param period 时间周期
     * @return boolean 是否成功
     */
    boolean tryAcquire(ImmutableList keys ,int count,int period);
    /**
     * 尝试获取
     * 
      说明:
      
     * 
    • 
     * @author duanyong
     * @date 2021/5/7 23:09
     * @param keys key
     * @param count 限制数量
     * @param period 时间周期
     * @param timeUnit 时间周期单位
     * @return boolean 是否成功
     */
    boolean tryAcquire(ImmutableList keys ,int count,int period,TimeUnit timeUnit);
}

       
      •  
  
    •  
      服务降级回退处理接口->com.javacoo.limit.client.api.Fallback
       
      /**
 * 服务降级回退处理接口
 * 
    • 
 *
 * @author: [email protected]
 * @since: 2021/5/29 10:20
 */
@Spi(LimitConfig.DEFAULT_IMPL)
public interface Fallback {
    /**
     * 服务降级处理
     * 
    • 
     * @author [email protected]
     * @date 2021/5/29 10:25
     * @return: R 返回对象
     */
    default R getFallback(){ return null;}
}

       
      •  
 
     
 
    3，redis+lua实现分布式限流(内部扩展实现)
     
 
       
  
    •  
      RedisTemplate配置类
       
      /**
 * RedisTemplate配置类
 * 
    • 
 *
 * @author: duanyong
 * @since: 2020/6/22 10:41
 */
@Slf4j
@Configuration
public class LimitRedisConfig {
    private static final String DATA_FORMAT = "yyyy-MM-dd HH:mm:ss";
    @Bean
    public RedisTemplate limitRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        FastJsonRedisSerializer fastJsonRedisSerializer = new FastJsonRedisSerializer(Serializable.class);
        FastJsonConfig fastJsonConfig = new FastJsonConfig();
        fastJsonConfig.setDateFormat(DATA_FORMAT);
        fastJsonRedisSerializer.setFastJsonConfig(fastJsonConfig);
        redisTemplate.setValueSerializer(fastJsonRedisSerializer);
        redisTemplate.setHashValueSerializer(fastJsonRedisSerializer);
        // 设置键（key）的序列化采用StringRedisSerializer。
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

       
      •  
  
    •  
      抽象限流接口实现
       
      /**
 * 抽象限流接口实现
 * 
    • 
 *
 * @author: [email protected]
 * @since: 2021/5/29 9:35
 */
@Slf4j
public abstract class AbstractRateLimiter implements RateLimiter {
    /**
     * RedisScript
     */
    protected RedisScript redisLuaScript;
    /**
     * RedisTemplate
     */
    @Autowired
    protected RedisTemplate redisTemplate;
    @PostConstruct
    public void initLUA() {
        redisLuaScript = new DefaultRedisScript<>(buildLuaScript(), Long.class);
    }

    /**
     * 尝试获取
     * 
      说明:
      
     * 
    • 
     *
     * @param keys key
     * @param count 限制数量
     * @return boolean 是否成功
     * @author duanyong
     * @date 2021/5/6 23:09
     */
    @Override
    public boolean tryAcquire(ImmutableList keys , int count) {
        return tryAcquire(keys,count,RateLimiter.DEFAULT_PERIOD);
    }

    /**
     * 尝试获取
     * 
      说明:
      
     * 
    • 
     *
     * @param keys key
     * @param count  限制数量
     * @param period 时间周期
     * @return boolean 是否成功
     * @author duanyong
     * @date 2021/5/7 23:09
     */
    @Override
    public boolean tryAcquire(ImmutableList keys ,int count, int period) {
        return tryAcquire(keys,count,period,RateLimiter.DEFAULT_TIME_UNIT);
    }

    /**
     * 尝试获取
     * 
      说明:
      
     * 
    • 
     *
     * @param keys key
     * @param count    限制数量
     * @param period   时间周期
     * @param timeUnit 时间周期单位
     * @return boolean 是否成功
     * @author duanyong
     * @date 2021/5/7 23:09
     */
    @Override
    public boolean tryAcquire(ImmutableList keys ,int count, int period, TimeUnit timeUnit) {
        return acquire(keys,count,period,timeUnit);
    }
    /**
     * 构建lua脚本
     * 
    • 
     * @author [email protected]
     * @date 2021/5/29 9:43
     * @return: java.lang.String
     */
    protected abstract String buildLuaScript();
    /**
     * 尝试获取
     * 
      说明:
      
     * 
    • 
     * @author duanyong
     * @date 2021/5/7 22:21
     *
     * @param keys key
     * @param limitCount    限制数量
     * @param limitPeriod   时间周期
     * @param timeUnit 时间周期单位
     * @return boolean 是否成功
     */
    protected abstract boolean acquire(ImmutableList keys ,int limitCount, int limitPeriod, TimeUnit timeUnit);
    /**
     * 加载lua脚本
     * 
    • 
     * @author [email protected]
     * @date 2021/5/29 10:47
     * @param path:
     * @return: java.lang.String
     */
    protected String loadLuaScript(String path){
        try {
            PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(this.getClass().getClassLoader());
            Resource[] resource = resolver.getResources(path);
            String luaScriptContent = StreamUtils.copyToString(resource[0].getInputStream(), StandardCharsets.UTF_8);
            log.info("完成加载Lua脚本:{}",luaScriptContent);
            return luaScriptContent;
        } catch (IOException ioException) {
            ioException.printStackTrace();
            throw new LimitException("加载Lua脚本异常",ioException);
        }
    }
}

       
      •  
  
    •  
      固定窗口算法实现类
       
      **
 * 分布式限流 固定窗口算法实现类
 * 
      说明:
      
 * 
    • 固定窗口，一般来说，如非时间紧迫，不建议选择这个方案，太过生硬。但是，为了能快速止损眼前的问题可以作为临时应急的方案
      • 
 * @author duanyong
 * @date 2021/5/6 22:49
 */
@Slf4j
public class FixedWindowRateLimiter extends AbstractRateLimiter {
    /**
     * 构建lua脚本
     * 
    • 
     * @author [email protected]
     * @date 2021/5/29 9:43
     * @return: java.lang.String
     */
    @Override
    protected String buildLuaScript(){
        return loadLuaScript( "classpath:script/FixedWindow.lua");
    }
    /**
     * 尝试获取
     * 
      说明:
      
     * 
    • 
     * @author duanyong
     * @date 2021/5/7 22:21
     *
     * @param keys key
     * @param limitCount    限制数量
     * @param limitPeriod   时间周期
     * @param timeUnit 时间周期单位
     * @return boolean 是否成功
     */
    @Override
    protected boolean acquire(ImmutableList keys ,int limitCount, int limitPeriod, TimeUnit timeUnit){
        Long count = redisTemplate.execute(redisLuaScript, keys,limitCount,limitPeriod);
        log.info("[固定窗口限流交易请求],key:{},返回:{},{}秒内,限制次数:{}",keys,count,limitPeriod,limitCount);
        if (count != null && count.intValue() == 1) {
            return true;
        } else {
            return false;
        }
    }
}

       
      FixedWindow.lua
       
      --限流KEY
local key = KEYS[1]
--限流大小
local limit = tonumber(ARGV[1])
--时间周期
local period = tonumber(ARGV[2])

local current = tonumber(redis.call('get', key) or "0")
--如果超出限流大小
if current + 1 > limit then
    return 0
else
    redis.call("incr", key)
    if current == 1 then
        redis.call("expire", key,period)
    end
    return 1
end

       
      •  
 
     
 
       
  
    • 漏桶算法实现类
      •  
  
    •  
      滑动窗口算法实现类
       
      /**
 * 分布式限流 滑动窗口算法实现类
 * 
      说明:
      
 * 
    • 滑动窗口。这个方案适用于对异常结果「高容忍」的场景，毕竟相比“两窗”少了一个缓冲区。但是，胜在实现简单
      • 
 * @author duanyong
 * @date 2021/5/29 22:49
 */
@Slf4j
public class SlidingWindowRateLimiter extends AbstractRateLimiter {
    /**
     * 构建lua脚本
     * 
    • 
     * @author [email protected]
     * @date 2021/5/29 9:43
     * @return: java.lang.String
     */
    @Override
    protected String buildLuaScript(){
        return loadLuaScript( "classpath:script/SlidingWindow.lua");
    }
    /**
     * 尝试获取
     * 
      说明:
      
     * 
    • 
     * @author duanyong
     * @date 2021/5/7 22:21
     *
     * @param keys key
     * @param limitCount    限制数量
     * @param limitPeriod   时间周期
     * @param timeUnit 时间周期单位
     * @return boolean 是否成功
     */
    @Override
    protected boolean acquire(ImmutableList keys ,int limitCount, int limitPeriod, TimeUnit timeUnit){
        Long count = redisTemplate.execute(redisLuaScript, keys,"1",limitCount,limitPeriod);
        log.info("[滑动窗口限流交易请求],key:{},{}秒内,返回数量:{},{}秒内,限制次数:{}",keys,limitPeriod,count,limitPeriod,limitCount);
        if (count != null && count.intValue() > 0) {
            return true;
        } else {
            return false;
        }
    }
}

       
      SlidingWindow.lua
       
      local function addToQueue(x,time)
    local count=0
    for i=1,x,1 do
        redis.call('lpush',KEYS[1],time)
        count=count+1
    end
    return count
end
--返回
local result=0
--限流KEY
local key = KEYS[1]
--申请数
local applyCount = tonumber(ARGV[1])
--阀值数量
local limit = tonumber(ARGV[2])
--阀值时间
local period = tonumber(ARGV[3])
redis.replicate_commands()
local now = redis.call('time')[1]
redis.call('SET','now',now);
--当前时间
local current_time = now

local timeBase = redis.call('lindex',key, limit - applyCount)
if (timeBase == false) or (tonumber(current_time) - tonumber(timeBase) > period) then
    result = result + addToQueue(applyCount,tonumber(current_time))
end
if (timeBase ~= false) then
    redis.call('ltrim',key,0,limit)
end
return result

       
      •  
 
     
 
       
  
    •  
      令牌桶算法实现类
       
      /**
 * 分布式限流 令牌桶算法实现类
 * 
      说明:
      
 * 
    • 令牌桶。当你需要尽可能的压榨程序的性能（此时桶的最大容量必然会大于等于程序的最大并发能力），并且所处的场景流量进入波动不是很大（不至于一瞬间取完令牌，压垮后端系统）
      • 
 * @author duanyong
 * @date 2021/5/29 22:49
 */
@Slf4j
public class TokenBucketRateLimiter extends AbstractRateLimiter {
    /**
     * 构建lua脚本
     * 
    • 
     * @author [email protected]
     * @date 2021/5/29 9:43
     * @return: java.lang.String
     */
    @Override
    protected String buildLuaScript(){
        return loadLuaScript( "classpath:script/TokenBucket.lua");
    }
    /**
     * 尝试获取
     * 
      说明:
      
     * 
    • 
     * @author duanyong
     * @date 2021/5/7 22:21
     *
     * @param keys key
     * @param limitCount    限制数量
     * @param limitPeriod   时间周期
     * @param timeUnit 时间周期单位
     * @return boolean 是否成功
     */
    @Override
    protected boolean acquire(ImmutableList keys ,int limitCount, int limitPeriod, TimeUnit timeUnit){
        Long count = redisTemplate.execute(redisLuaScript, keys,limitCount,limitPeriod);
        log.info("[令牌桶限流交易请求],key:{},返回:{},{}秒内,限制次数:{}",keys,count,limitPeriod,limitCount);
        if (count != null && count.intValue() == 1) {
            return true;
        } else {
            return false;
        }
    }
}

       
      TokenBucket.lua
       
      --利用redis的hash结构，存储key所对应令牌桶的上次获取时间和上次获取后桶中令牌数量
local ratelimit_info = redis.pcall('HMGET',KEYS[1],'last_time','current_token_num')
local last_time = ratelimit_info[1]
local current_token_num = tonumber(ratelimit_info[2])

redis.replicate_commands()
local now = redis.call('time')[1]
redis.call('SET','now',now);



--tonumber是将value转换为数字，此步是取出桶中最大令牌数、生成令牌的速率(每秒生成多少个)、当前时间
local max_token_num = tonumber(ARGV[1])
local token_rate = tonumber(ARGV[2])
--local current_time = tonumber(ARGV[3])
local current_time = now
--reverse_time 即多少毫秒生成一个令牌
local reverse_time = 1000/token_rate

--如果current_token_num不存在则说明令牌桶首次获取或已过期，即说明它是满的
if current_token_num == nil then
  current_token_num = max_token_num
  last_time = current_time
else
  --计算出距上次获取已过去多长时间
  local past_time = current_time-last_time
  --在这一段时间内可产生多少令牌
  local reverse_token_num = math.floor(past_time/reverse_time)
  current_token_num = current_token_num +reverse_token_num
  last_time = reverse_time * reverse_token_num + last_time
  if current_token_num > max_token_num then
    current_token_num = max_token_num
  end
end

local result = 0
if(current_token_num > 0) then
  result = 1
  current_token_num = current_token_num - 1
end

--将最新得出的令牌获取时间和当前令牌数量进行存储,并设置过期时间
redis.call('HMSET',KEYS[1],'last_time',last_time,'current_token_num',current_token_num)
redis.call('pexpire',KEYS[1],math.ceil(reverse_time*(max_token_num - current_token_num)+(current_time-last_time)))

return result

       
      •  
 
     
 
    4，支持接口添加注解方式限流
     
 
       
  
    •  
      自定义限流注解
       
      /**
 * 自定义限流注解
 * 
      说明:
      
 * 
    • 
 *
 * @author duanyong
 * @date 2021/5/6 21:47
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Limit {
    /**
     * 名字
     */
    String name() default "";

    /**
     * key
     */
    String key() default "";

    /**
     * Key的前缀
     */
    String prefix() default "";

    /**
     * 给定的时间范围 单位(秒)
     */
    int period();

    /**
     * 一定时间内最多访问次数
     */
    int count();

    /**
     * 限流的类型(用户自定义key 或者 请求ip)
     */
    LimitType limitType() default LimitType.CUSTOMER;

    /**
     * 降级策略:默认快速失败
     */
    FallbackStrategy fallbackStrategy() default FallbackStrategy.FAIL_FAST;

    /**
     * 当降级策略为:回退 时回退处理接口实现名称
     */
    String fallbackImpl() default "";
}

       
      •  
  
    •  
      限流注解处理器
       
      /**
 * 限流注解处理器
 * 
    • 基于aspectj
      • 
 *
 * @author: [email protected]
 * @since: 2021/5/29 17:04
 */
@Slf4j
@Aspect
@Component
public class AnnotationLimitHandler extends AbstractLimitHandler{

    @Around("@annotation(limit)")
    public Object around(ProceedingJoinPoint joinPoint, Limit limit) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        // 获取被拦截的方法
        Method method = signature.getMethod();
        // 获取被拦截的类名
        String className = signature.getDeclaringType().getName();
        // 获取被拦截的方法名
        String methodName = method.getName();
        String defaultKey = StringUtils.join(className,".", methodName);
        log.info("[AnnotationLimitHandler限流交易请求],尝试获取方法:{},执行权限", defaultKey);
        //组装限流规则
        LimitRule limitRule = LimitRule.builder()
            .defaultKey(defaultKey)
            .count(limit.count())
            .key(limit.key())
            .limitType(limit.limitType())
            .period(limit.period())
            .prefix(limit.prefix())
            .fallbackStrategy(limit.fallbackStrategy())
            .fallbackImpl(limit.fallbackImpl())
            .build();
        return handle(limitRule, () -> {
            try {
                return joinPoint.proceed();
            } catch (Throwable throwable) {
                log.error("[AnnotationLimitHandler限流交易请求],方法执行异常",throwable);
            }
            return null;
        });
    }
}
  
  
 
      5，支持配置文件方式限流
       
 
         
  
      •  
        接口限流配置
         
        /**
 * 接口限流配置
 * @author duanyong
 * @date 2021/3/4 15:15
 */
@ConfigurationProperties(prefix = LimitConfig.PREFIX)
public class LimitConfig {
    /** 前缀 */
    public static final String PREFIX = "limit";
    /** 前缀 */
    public static final String EXP = "expression";
    /** limit是否可用,默认值*/
    public static final String ENABLED = "enabled";
    /** 默认实现,默认值*/
    public static final String DEFAULT_IMPL= "default";
    /** PointCut表达式,默认值*/
    public static final String DEFAULT_EXP= "";
    /** limit是否可用*/
    private String enabled = ENABLED;
    /**实现*/
    private String impl = DEFAULT_IMPL;
    /**PointCut表达式*/
    private String expression = DEFAULT_EXP;
    /**全局限流规则配置*/
    @NestedConfigurationProperty
    private LimitRule limitRule = new LimitRule().init();
    /**特殊接口限流规则配置Map*/
    private Map limitMethodMap = new HashMap<>(5);

    public String getEnabled() {
        return enabled;
    }

    public void setEnabled(String enabled) {
        this.enabled = enabled;
    }

    public String getImpl() {
        return impl;
    }

    public void setImpl(String impl) {
        this.impl = impl;
    }

    public String getExpression() {
        return expression;
    }

    public void setExpression(String expression) {
        this.expression = expression;
    }

    public LimitRule getLimitRule() {
        return limitRule;
    }

    public void setLimitRule(LimitRule limitRule) {
        this.limitRule = limitRule;
    }

    public Map getLimitMethodMap() {
        return limitMethodMap;
    }

    public void setLimitMethodMap(Map limitMethodMap) {
        this.limitMethodMap = limitMethodMap;
    }
}

         
        •  
  
      •  
        限流规则配置
         
        /**
 * 限流规则配置
 * 
      • 单个接口方法限流规则配置
        • 
 *
 * @author: [email protected]
 * @since: 2021/5/29 15:31
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class LimitRule {
    /** 给定的时间范围 单位(秒),默认值*/
    public static final int DEFAULT_PERIOD = 1;
    /** 一定时间内最多访问次数,默认值*/
    public static final int DEFAULT_COUNT = 50;
    /**
     * defaultKey
     */
    private String defaultKey = "";
    /**
     * key
     */
    private String key;

    /**
     * Key的前缀
     */
    private String prefix;
    /**
     * 给定的时间范围 单位(秒)
     */
    private int period;

    /**
     * 一定时间内最多访问次数
     */
    private int count;
    /**
     * 限流类型
     */
    private LimitType limitType;
    /**
     * 降级策略:默认快速失败
     */
    private FallbackStrategy fallbackStrategy;
    /**
     * 当降级策略为:回退 时回退处理接口实现名称
     */
    private String fallbackImpl;
    /**
     * 初始化
     * 
      • 
     * @author [email protected]
     * @date 2021/5/29 14:06
     * @return: void
     */
    public LimitRule init(){
        this.setPeriod(DEFAULT_PERIOD);
        this.setCount(DEFAULT_COUNT);
        this.setLimitType(LimitType.CUSTOMER);
        this.setFallbackStrategy(FallbackStrategy.FAIL_FAST);
        this.setFallbackImpl(LimitConfig.DEFAULT_IMPL);
        return this;
    }
}

         
        •  
  
      •  
        限流配置处理器
         
        /**
 * 限流配置处理器
 * 
      • 处理配置方式限流
        • 
 *
 * @author: [email protected]
 * @since: 2021/5/29 17:06
 */
@Slf4j
public class ConfigLimitHandler extends AbstractLimitHandler implements MethodInterceptor {
    @Nullable
    @Override
    public Object invoke(@Nonnull MethodInvocation methodInvocation) throws Throwable {
        // 获取被拦截的类名
        String className = methodInvocation.getClass().getName();
        // 获取被拦截的方法名
        String methodName = methodInvocation.getMethod().getName();
        String defaultKey = StringUtils.join(className,".", methodName);
        //获取配置文件中的限流规则
        LimitRule limitRule = lockConfig.getLimitRule();
        //如果需要特殊处理
        if(lockConfig.getLimitMethodMap().containsKey(methodName)){
            limitRule = lockConfig.getLimitMethodMap().get(methodName);
        }
        limitRule.setDefaultKey(defaultKey);
        log.info("[ConfigLimitHandler限流交易请求],尝试获取方法:{},执行权限", defaultKey);
        return handle(limitRule, () -> {
            try {
                return methodInvocation.proceed();
            } catch (Throwable throwable) {
                log.error("[ConfigLimitHandler限流交易请求],方法执行异常",throwable);
            }
            return null;
        });
    }
}
  
  
      •  
        限流切面Advisor
         
        /**
 * 限流切面Advisor
 * 
      • 
 *
 * @author: [email protected]
 * @since: 2021/5/29 10:52
 */
@Slf4j
public class LimitPointcutAdvisor extends AbstractBeanFactoryPointcutAdvisor {
    @Autowired
    private LimitConfig lockConfig;
    @Override
    public Pointcut getPointcut() {
        AspectJExpressionPointcut adapterPointcut = new AspectJExpressionPointcut();
        //从配置文件中获取PointCut表达式
        adapterPointcut.setExpression(lockConfig.getExpression());
        return adapterPointcut;
    }
}

         
        •  
  
 
        6，支持限流回退
         
 
           
  
        •  
          服务降级回退处理接口默认实现
           
          /**
 * 服务降级回退处理接口默认实现
 * 
        • 
 *
 * @author: [email protected]
 * @since: 2021/5/29 11:00
 */
public class DefaultFallback implements Fallback {
    /**
     * 服务降级处理
     * 
        • 
     *
     * @author [email protected]
     * @date 2021/5/29 10:25
     * @return: java.lang.Object 返回对象
     */
    @Override
    public Object getFallback() {
        return null;
    }
}
  
  
 
          7，其他辅助类
           
 
             
  
          •  
            降级策略枚举类
             
            /**
 * 降级策略
 * 
          • 
 *
 * @author: [email protected]
 * @since: 2021/5/29 10:32
 */
public enum FallbackStrategy {
    /**
     * 快速失败
     */
    FAIL_FAST,
    /**
     * 回退
     */
    FALLBACK;
}

             
            •  
  
          •  
            限流类型枚举类
             
            /**
 * 限流类型
 * 
            说明:
            
 * 
          • 
 *
 * @author duanyong
 * @date 2021/5/6 21:47
 */
public enum LimitType {
    /**
     * 自定义key
     */
    CUSTOMER,

    /**
     * 请求者IP
     */
    IP;
}

             
            •  
  
          •  
            限流异常类
             
            /**
 * 限流异常
 * 
          • 
 *
 * @author: duanyong
 * @since: 2021/4/29 11:20
 */
public class LimitException extends RuntimeException{
    /**错误码*/
    protected String code;
    public LimitException() {
    }

    public LimitException(Throwable ex) {
        super(ex);
    }
    public LimitException(String message) {
        super(message);
    }
    public LimitException(String code, String message) {
        super(message);
        this.code = code;
    }
    public LimitException(String message, Throwable ex) {
        super(message, ex);
    }
}

             
            •  
  
          •  
            抽象限流处理器
             
            /**
 * 抽象限流处理器
 * 
            说明:
            
 * 
          • 
 *
 * @author [email protected]
 * @date 2021/5/29 21:48
 */
@Slf4j
public abstract class AbstractLimitHandler {
    @Autowired
    protected LimitConfig lockConfig;
    @Autowired
    private RateLimiter rateLimiter;

    /**
     * 限流处理
     * 
          • 
     * @author [email protected]
     * @date 2021/5/29 9:34
     * @param limitRule: 限流规则
     * @param function: 结果提供函数
     * @return: R
     */
    protected R handle(LimitRule limitRule, Supplier function){
        //规则整理
        handleLimitRule(limitRule);

        ImmutableList keys = ImmutableList.of(StringUtils.join(limitRule.getPrefix(), limitRule.getKey()));
        try {
            if (rateLimiter.tryAcquire(keys,limitRule.getCount(), limitRule.getPeriod())) {
                log.info("[限流交易请求],尝试获取执行权限成功,开始执行目标方法");
                return function.get();
            }else{
                log.info("[限流交易请求],尝试获取执行权限失败,服务降级处理,降级策略:{}",limitRule.getFallbackStrategy());
                if(FallbackStrategy.FAIL_FAST.equals(limitRule.getFallbackStrategy())){
                    throw new LimitException("访问过于频繁,超出访问限制");
                }
                //获取回退处理接口实现:如果为空则使用默认实现
                Fallback fallback = ExtensionLoader.getExtensionLoader(Fallback.class).getExtension(limitRule.getFallbackImpl());
                fallback = fallback != null ? fallback : ExtensionLoader.getExtensionLoader(Fallback.class).getDefaultExtension();
                return fallback.getFallback();
            }
        } catch (Throwable e) {
            log.error("[限流服务执行异常]",e);
            if (e instanceof LimitException) {
                throw e;
            }
            throw new LimitException("限流服务执行异常",e);
        }
    }
    /**
     * 限流规则整理
     * 
          • 
     * @author [email protected]
     * @date 2021/5/29 14:15
     * @param limitRule: 限流规则
     * @return: void
     */
    private void handleLimitRule(LimitRule limitRule){
        //限流规则整理:如果为空则使用全局配置
        limitRule.setKey(StringUtils.isBlank(limitRule.getKey()) ? lockConfig.getLimitRule().getKey() : limitRule.getKey());
        limitRule.setCount(limitRule.getCount() == 0 ? lockConfig.getLimitRule().getCount() : limitRule.getCount());
        limitRule.setFallbackImpl(StringUtils.isBlank(limitRule.getFallbackImpl()) ? lockConfig.getLimitRule().getFallbackImpl() : limitRule.getFallbackImpl());
        limitRule.setFallbackStrategy(limitRule.getFallbackStrategy() == null ? lockConfig.getLimitRule().getFallbackStrategy() : limitRule.getFallbackStrategy());
        limitRule.setLimitType(limitRule.getLimitType() == null ? lockConfig.getLimitRule().getLimitType() : limitRule.getLimitType());
        limitRule.setPeriod(limitRule.getPeriod() == 0 ? lockConfig.getLimitRule().getPeriod() : limitRule.getPeriod());
        limitRule.setPrefix(StringUtils.isBlank(limitRule.getPrefix()) ? lockConfig.getLimitRule().getPrefix() : limitRule.getPrefix());

        String key = limitRule.getKey();
        //根据限流类型获取不同的key ,如果不传我们会以方法名作为key
        switch (limitRule.getLimitType()) {
            case IP:
                key = WebUtil.getIpAddress();
                break;
            case CUSTOMER:
                key = StringUtils.isBlank(key) ? StringUtils.upperCase(limitRule.getDefaultKey()) : key;
                break;
            default:
                key = StringUtils.upperCase(limitRule.getDefaultKey());
        }
        limitRule.setKey(key);
    }
}

             
            •  
  
          •  
            工具类
             
            /**
 * 工具类
 * 
          • 
 *
 * @author: [email protected]
 * @since: 2021/5/29 15:58
 */
public class WebUtil {
    private static final String UNKNOWN = "unknown";
    /**
     * 获取IP
     * 
            说明:
            
     * 
          • 
     * @author duanyong
     * @date 2021/5/7 22:35
     */
    public static String getIpAddress() {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        return ip;
    }
}

             
            •  
  
          •  
            自动配置类
             
            /**
 * 自动配置类
 * 
          • 
 * @author duanyong
 * @date 2021/3/5 9:50
 */
@Slf4j
@Configuration
@EnableConfigurationProperties(value = LimitConfig.class)
@ConditionalOnClass(RateLimiter.class)
@ConditionalOnProperty(prefix = LimitConfig.PREFIX, value = LimitConfig.ENABLED, matchIfMissing = true)
public class LimitAutoConfiguration {
  @Autowired
    private LimitConfig lockConfig;

  @Bean
  @ConditionalOnMissingBean(RateLimiter.class)
  public RateLimiter createRateLimiter() {
        log.info("初始化分布式限流对象,实现类名称:{}",lockConfig.getImpl());
        RateLimiterHolder.rateLimiter = ExtensionLoader.getExtensionLoader(RateLimiter.class).getExtension(lockConfig.getImpl());
        log.info("初始化分布式限流对象成功,实现类:{}", RateLimiterHolder.rateLimiter);
        return RateLimiterHolder.rateLimiter;
  }
    
    @Bean
    @ConditionalOnProperty(prefix = LimitConfig.PREFIX, value = LimitConfig.EXP)
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public LimitPointcutAdvisor adapterServiceAdvisor() {
        LimitPointcutAdvisor advisor = new LimitPointcutAdvisor();
        advisor.setAdviceBeanName("limitPointcutAdvisor");
        advisor.setAdvice(createConfigLimitHandler());
        advisor.setOrder(Ordered.HIGHEST_PRECEDENCE);
        return advisor;
    }
    @Bean
    public ConfigLimitHandler createConfigLimitHandler() {
        return new ConfigLimitHandler();
    }

    @Bean
    @ConditionalOnMissingBean(LimitPointcutAdvisor.class)
    public AnnotationLimitHandler createAnnotationLimitHandler() {
        return new AnnotationLimitHandler();
    }
}

             
            •  
  
          •  
            限流接口对象持有者
             
            /**
 * 限流接口对象持有者
 * 
            说明:
            
 * 
          • 
 * @author duanyong
 * @date 2021/5/7 22:27
 */
public class RateLimiterHolder {
    /** 限流对象*/
    static RateLimiter rateLimiter;

    public static Optional getRateLimiter() {
        return Optional.ofNullable(rateLimiter);
    }
}

             
            •  
 
           
 
          8，资源文件
           
 
             
  
          •  
            spring.factories
             
            org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.javacoo.limit.client.internal.redis.LimitRedisConfig,\
  com.javacoo.limit.starter.LimitAutoConfiguration


             
            •  
  
          •  
            com.javacoo.limit.client.api.Fallback
             
            default=com.javacoo.limit.client.internal.fallback.DefaultFallback

             
            •  
  
          •  
            com.javacoo.limit.client.api.RateLimiter
             
            default=com.javacoo.limit.client.internal.redis.TokenBucketRateLimiter
fixedWindow=com.javacoo.limit.client.internal.redis.FixedWindowRateLimiter
slidingWindow=com.javacoo.limit.client.internal.redis.SlidingWindowRateLimiter

             
            •  
 
           
 
          问题及局限性
           
 
          问题
           
 
             
  
          • 紧经过小规模生产验证，虽满足业务需求，但是还不算成熟，任需更多测试验证。
            •  
  
          • 仅供学习参考，如需用于生产，请谨慎，并多测试。
            •  
  
          •  
            推荐使用Spring Clound Gateway，Sentinel等专业流量防护组件
             
            局限性
             
            •  
  
          • 限流组件保证了高可用，牺牲了性能，增加了一层 IO 环节的开销，单机限流在本地，分布式限流还要通过网络协议。
            •  
  
          • 限流组件保证了高可用，牺牲了一致性，在大流量的情况下，请求的处理会出现延迟的情况，这种场景便无法保证强一致性。特殊情况下，还无法保证最终一致性，部分请求直接被抛弃。
            •  
  
          • 限流组件拥有流控权，若限流组件挂了，会引起雪崩效应，导致请求与业务的大批量失败。
            •  
  
          • 引入限流组件，增加系统的复杂程度，开发难度增加，限流中间件的设计本身就是一个复杂的体系，需要综合业务与技术去思考与权衡，同时还要确保限流组件本身的高可用与性能，极大增加工作量，甚至需要一个团队去专门开发。
            •  
 
           
 
          一些信息
           
 
          路漫漫其修远兮,吾将上下而求索
码云：https://gitee.com/javacoo
QQ：164863067
作者/微信：javacoo
邮箱：[email protected]

           

                            
                        
                    
                    
                    
          
                    
                    
                    
          
                
                
          
                    
                
          
            
        
    
    
          
        
          你可能感兴趣的:(基于Redis+Lua实现分布式限流组件)
          
        
          
            
          
                
            
                    
          • 基于springboot的在线点餐系统
                        爱编程的小哥
java毕设springboot后端javavue
                        
            全栈在线点餐系统架构解析|SpringBoot+ElementUI后台管理实战（附高并发订单处理方案）一、系统全景透视基于五张效果图分析，该系统是餐饮行业全流程数字化解决方案，采用SpringBoot+MyBatisPlus+Vue2+ElementUI技术栈，实现用户端订餐与商家端管理的双向闭环。通过RBAC权限控制+订单状态机+实时库存预警三大核心机制，支持日均万级订单处理，覆盖从用户选餐、支
            
                    
            • 
                    
          • 根据文件名称查询文件所在位置
                        姚不倒
linux运维数据库
                        
            在Linux中，根据文件名称查询文件所在位置主要通过命令行工具实现，以下是几种常用方法：---###**1.使用`find`命令（最灵活）**`find`命令可以递归搜索指定目录下的文件，支持按名称、类型、时间等条件过滤。####**基础语法**```bashfind[搜索路径]-name"文件名"```####**示例**-全局搜索名为`example.txt`的文件：```bashfind/-
            
                    
            • 
                    
          • Java基础7（解耦、引入工厂模式、代理设计模式、适配器设计模式、内部类）
                        孤影恋长风
java
                        
            类设计的注意事项：类的设计主要是父类的设计子类最好不要继承一个已经完全实现的类，因为一旦发达向上转型，所调用的方法，一定是被子类覆盖过的方法，所以只会继承抽象类和接口。解耦耦合度是什么？两个对象之间相互依赖的程度，是衡量代码独立性的一个指标。软件开发追求高/低耦合度？软件开发追求低耦合度怎么才能降低代码的耦合度？降低代码的耦合度是一个非常重要的实践，它有助于提高代码的可维护性、可读性和可扩展性。引
            
                    
            • 
                    
          • 并发安全的sync.Map
                        不7夜宵
基础知识后端
                        
            对于并发读写map的情况下，map的数据会被写乱造成panic。Go语言原生map并不是线程安全的，因此对它进行并发读写操作时需要加锁。但是当操作频繁且要求性能的情况下，锁的优化已经无法满足业务需求，考虑到互联网应用通常是读多写少的场景，Golang的标准库提供了一个特殊的并发安全的map实现，为了与原生map区分，人们习惯性称为sync.map。一、sync.map与map的区别1.并发安全sy
            
                    
            • 
                    
          • stm32定时器实现 微秒延时
                        随风飘零翼
stm32stm32单片机嵌入式硬件
                        
            Cubemx配置图初始化无需使能定时器中断。代码如下：voiddelay_us(uint16_tus){uint16_tdiffer=0xffff-us-5;__HAL_TIM_SET_COUNTER(&htim17,differ);//清空定时器17HAL_TIM_Base_Start(&htim17);//启动定时器while(differ<0xffff-5){//计算differ=__HAL
            
                    
            • 
                    
          • 基于springboot的社区团购系统设计
                        Olivia-gogogo
springboot后端java
                        
            一、引言在当今数字化时代，信息技术正以前所未有的速度渗透到社会的各个领域，深刻地改变着人们的生活和工作方式。教育领域也不例外，随着高等教育的普及和招生规模的不断扩大，大学生入学审核工作面临着越来越大的挑战。传统的人工入学审核方式已难以满足现代教育管理的需求，暴露出诸多弊端。传统人工入学审核方式效率低下。在每年的招生季，高校招生工作人员需要面对大量的入学申请材料，这些材料不仅数量庞大，而且种类繁多，
            
                    
            • 
                    
          • Vue 表单输入绑定，双向绑定
                        天马3798
Vuevue.jsjavascript前端Vue表单输入绑定Vue表单双向绑定
                        
            一、v-model指令用于Vue表单双向绑定用户Vue组件属性双向绑定v-model还可以用于各种不同类型的输入，、元素。它会根据所使用的元素自动使用对应的DOM属性和事件组合：文本类型的和元素会绑定valueproperty并侦听input事件；和会绑定checkedproperty并侦听change事件；会绑定valueproperty并侦听change事件。二、v-model使用案例文本姓名
            
                    
            • 
                    
          • 【Linux】Hadoop-3.4.1的伪分布式集群的初步配置
                        孤独打铁匠Julian
Linuxlinuxhadoopubuntu
                        
            配置步骤一、检查环境JDK#目前还是JDK8最适合Hadoopjava-versionecho$JAVA_HOMEHadoophadoopversionecho$HADOOP_HOME二、配置SSH免密登录Hadoop需要通过SSH管理节点（即使在伪分布式模式下）sudoaptinstallopenssh-server#安装SSH服务（如未安装）cd~/.ssh/ssh-keygen-trsa#生
            
                    
            • 
                    
          • 秒杀场景的设计思考
                        思无邪6675
后端
                        
            秒杀场景的设计思考在学习Redis的之后，一个绕不开的话题就是秒杀系统的设计。本文将从下面几个方面展开一下个人简单的理解：秒杀场景的介绍设计的核心思路怎么限流、削峰、异步planB总结‍秒杀场景的介绍秒杀场景是大家常说的高并发场景，但是实际上其与单纯的高并发还有一点不同，主要区别就是其流量来的猛增，几乎是一个垂直的增长，而非线性增长的并发。其具有如下特点：瞬时高并发读多写少不能超卖设计的核心思路在
            
                    
            • 
                    
          • golang jwt挖坑
                        qiang527052
golang个人笔记golangjwt
                        
            golangjwt使用golangjwt使用中遇到的一个坑，特此记录。具体描述：因为公司需要，现有架构jwt生成token的代码是java实现的，然后现在在golang中需要对此token进行解析。java用到的jar包：io.jsonwebtoken.jjwt0.9.0golang用到的库：github.com/dgrijalva/jwt-gojava生成token测试代码如下：publicst
            
                    
            • 
                    
          • SQL-触发器(trigger)的详解以及代码演示
                        m0_74823827
面试学习路线阿里巴巴sql数据库服务器
                        
            一、触发器的概念触发器是一种特殊的存储过程，但是触发器不存在输入和输出参数，所以不能被显式的去调用，而是与特定的表相关联，当表中的数据发生变化时，触发器被激活并执行其定义的SQL代码。触发器可以是行级触发器（针对每一行数据变化）或语句级触发器（针对整个SQL语句的变化），行级触发器允许对每一行单独处理，而语句级触发器则在整个操作完成后执行一次。触发器的功能强化约束：触发器能够实现比CHECK语句更
            
                    
            • 
                    
          • H743定时器输出PWM波方法（基于STM32CubeMX）
                        NW嵌入式开发
单片机开发stm32定时器PWM模式
                        
            0工具准备1.STM32CubeMX2.《STM32H743参考手册中文版》3.《stm32h743xi数据手册》1前言本文介绍基于STM32CubeMX，使用stm32h743xi，使用TIM15的通道2输出PWM波的方法。2H743定时器输出PWM波方法（基于STM32CubeMX）《STM32H743参考手册中文版》对PWM模式的描述如下：其中，有关PWM模式1和模式2的介绍见TIM15_C
            
                    
            • 
                    
          • Opencv之计算机视觉一
                        闭月之泪舞
计算机视觉计算机视觉opencvpython
                        
            一、环境准备使用opencv库来实现简单的计算机视觉。需要安装两个库：opencv-python和opencv-contrib-python，版本可以自行选择，注意不同版本的opencv中的某些函数名和用法可能不同pipinstallopencv-python==3.4.18.65-ihttps://pypi.tuna.tsinghua.edu.cn/simplepipinstallopencv-
            
                    
            • 
                    
          • STM8L1xx利用定时器实现毫秒和微妙延时
                        荣070214
STM8单片机单片机毫秒和微妙延时
                        
            采用单片机的定时计数器进行毫秒和微妙级延时，精度较准。检测溢出时产生的标志位来判断延时到达。下面以STM8L101芯片为例及配合代码说明。一、实现原理：1、初始化Timer2时钟源（附上相应代码）voidTIM2Init(void){TIM2_DeInit();CLK_PeripheralClockConfig(CLK_Peripheral_TIM2,ENABLE);TIM2->CR1&=((ui
            
                    
            • 
                    
          • TS类型体操：实现axios的链式调用类型提示
                        console.log 战略储备局局长
前端
                        
            调用方法A调用方法B调用方法C对象实例返回对象自身返回对象自身最终结果一、为什么需要链式调用类型提示？在TypeScript中实现axios的链式调用类型提示，能显著提升开发体验：智能补全：开发者无需记忆API参数顺序，IDE自动提示方法链类型安全：拦截器配置、请求参数、响应数据全程类型校验代码自解释：通过类型声明即可理解API设计规范重构友好：修改底层实现不影响上层调用逻辑痛点场景：//传统方式
            
                    
            • 
                    
          • 入门级带你实现一个安卓智能家居APP（2）kotlin版本
                        一粒程序米
androidkotlin智能家居WiFi单片机
                        
            前言上一篇写过java版本的实现，这一篇就写一下kotlin版本的吧。效果展示本APP是通过tcp/ip协议与连了WiFi的单片机通信。其实除了主活动类和新建项目时有一丢丢不同，其他的都是一样的哈~第一步：你得会一点点kotlin基础，建议看一本书，是郭霖大神些的《第一行代码》第三版，里面除了安卓的基础教学，还有kotlin的。第二步：建议看一本书，是郭霖大神些的《第一行代码》，先入门安卓基础。不
            
                    
            • 
                    
          • vscode如何找letax模板_VScode如何实时预览LaTeX？
                        weixin_39789327

                        
            好像感觉我要火了,这个必须专业回答下啊,看完别忘了点赞啊!!用户友好型实时预览的定义即不用手动编译,不用手动刷新文档(PDF)的LaTeX写作方式.实现方式与工具目前主要用的是Latexmk这个perl脚本或者支持实时预览的Markdown编辑器.关于TeX集成系统的一个建议个人建议用TeXLive而非MikTeX甚至CTeX套装,相比而言我用TeXLive时碰到的问题最少.后两种你可能发现好好的
            
                    
            • 
                    
          • Kubernetes配置全解析：从小白到高手的进阶秘籍
                        ivwdcwso
操作系统与云原生kubernetes容器云原生k8s配置
                        
            导语在Kubernetes（K8s）的世界里，合理且精准的配置是释放其强大功能的关键。无论是搭建集群、部署应用，还是优化资源利用，配置都贯穿始终。然而，K8s配置涉及众多参数与组件，错综复杂，令不少初学者望而却步。本文将带你一步步深入K8s配置领域，从小白进阶为配置高手，轻松驾驭K8s集群。一、Kubernetes集群配置Master节点配置kube-api-server：这是K8s集群的“门面”
            
                    
            • 
                    
          • Nginx 接入 Keepalived 实现高可用，让你的网站稳如泰山！
                        OutOfMemory~~
nginx服务器前端
                        
            一、往期内容回顾前面提到nginx可以实现后端服务的负载均衡，来使得后端的服务能力得到水平的扩展。但是怎么保证nginx的高可用呢，如果nginx挂了，还怎么持续提供服务呢？今天我们就来讲一讲Keepalived实现高可用的方案。二、什么是高可用？Keepalived高可用架构是什么？简单来说，高可用就是让你的网站服务时刻在线，即使出现硬件故障、网络波动等问题，也能快速恢复，保证用户访问不受影响。
            
                    
            • 
                    
          • 【深入理解 SpringBoot3】第一弹：SpringBoot3 快速入门
                        敖云岚
springboot后端java
                        
            一、SpringBoot是什么SpringBoot帮我们简单、快速地创建一个独立的、生产级别的Spring应用大多数SpringBoot应用只需要编写少量配置即可快速整合Spring平台以及第三方技术。特性：直接嵌入Tomcat、Jetty或Undertow（无需部署war包）提供可选的starter（场景启动器）简化应用的整合实现按需的自动配置Spring以及第三方库（约定大于配置）：appli
            
                    
            • 
                    
          • MyBatis——基于MyBatis注解的学生管理程序
                        基础较差的cs菜鸟
JavaEE实验mybatisjavamysql
                        
            MyBatis——基于MyBatis注解的学生管理程序Resourcedao层pojo层utils层测试层实验要求  本实验要求根据学生表在数据库中创建一个s_student表，根据班级表在数据库中创建一个c_class表，班级表c_class和学生表s_student是一对多的关系。实验内容表1学生表（s_student）学生编号（id）学生名称（name）学生年龄（age）所属班级（cid）1
            
                    
            • 
                    
          • Go 1.24 新特性一览
                        
go资讯编程语言程序员
                        
            Go1.24震撼登场，带来显著性能提升与诸多新功能，如泛型类型别名、优化工具链及标准库增强。可借助os.Root实现安全文件系统操作，运用testing.B.Loop优化基准测试，利用runtime.AddCleanup完善资源管理，还有weak包优化内存、crypto包保障FIPS140-3合规。速升级，提升Go应用效率与安全！文章目录语言特性更新泛型类型别名(GenericTypeAliase
            
                    
            • 
                    
          • springboot基于bs 架构的母婴用户商城全程服务管理系统(源码+lw+部署文档+讲解等)
                        源码哆哆V+ymhydo
Java毕设优质源码springboot架构后端
                        
            具体实现截图技术栈后端框架SpringBoot采用springboot作为后台的框架，java框架具有简化配置和开发的效率。Spring框架目前是很多java开发者的首选框架，Spring主要有两大功能，控制反转和面向切面的编程。控制反转（IOC）可以实现代码的依赖注入，减少代码的耦合性，大大提高了软件质量，面向切面编程（AOP）主要是应用动态代理的技术对代码逻辑进行分离，可以实现对代码的重用，适
            
                    
            • 
                    
          • 事务回滚核心技术
                        KBkongbaiKB
java
                        
            一、事务回滚的数学本质与核心挑战1.1事务状态机模型操作执行持久化完成系统故障事务回滚ActivePartiallyCommittedCommittedFailedAborted1.2核心技术挑战矩阵问题维度单机事务分布式事务原子性保证存储引擎WAL日志二阶段提交协议隔离性实现MVCC多版本控制全局锁调度机制可见性管理事务ID版本链向量时钟同步回滚触发条件SQL执行异常/死锁网络分区/节点故障二、
            
                    
            • 
                    
          • HTML语言的贪心算法
                        宇瞳月
包罗万象golang开发语言后端
                        
            HTML语言的贪心算法：理论与实践引言在编程和算法研究中，贪心算法是一种广泛应用的解决问题的方法。它通过对每一阶段选择最优解的方式来构建整个问题的解决方案。贪心算法不一定能在所有情况下得到最优解，但在许多实际问题中，它能够提供一个足够好的近似解。本文将探讨贪心算法的基本概念、典型应用、优缺点，并结合HTML语言的特点，提出一些具体的实现示例和思考。一、贪心算法的基本概念贪心算法是一种求解最优化问题
            
                    
            • 
                    
          • 如何用 Python 实现树结构
                        不辉放弃
python开发语言
                        
            一、树结构基础认知1.1树的四大特征层级关系：父子节点的从属关系唯一根节点：访问起点无循环：从根到叶的路径不形成环N叉分支：每个节点可有多个子节点1.2核心组件解析classTreeNode:def__init__(self,data):self.data=data#节点存储的数据self.children=[]#子节点容器（多叉树特性）defadd_child(self,node):self.c
            
                    
            • 
                    
          • Echarts map3D 禁止鼠标滚轮缩放
                        程序媛小白白
javascript前端vueecharts
                        
            Echartstype为map3D在使用时发现会存在鼠标滚轮缩放的情况zoomSensitivity属性本质上是是否开启map3D的缩放和平移所以也可以禁止鼠标滚轮缩放的情况zoomSensitivity:false,//是否开启缩放和平移/鼠标滑动缩放禁止禁用这个属性就可以实现map3D禁止鼠标滚轮缩放的需求了
            
                    
            • 
                    
          • 【网络】数据流（Data Workflow）Routes（路由）、Controllers（控制器）、Models（模型） 和 Middleware（中间件）
                        一袋米扛几楼98
网络工程/安全中间件
                        
            在图片中，数据流（DataWorkflow）描述了应用程序中数据的流动过程，涉及Routes（路由）、Controllers（控制器）、Models（模型）和Middleware（中间件）。作为初学者，理解这些组件及其联系是掌握Web应用程序开发的关键。以下是对每个技术点的详细解释，以及它们如何相互关联的分析。1.Routes（路由）定义：路由定义了应用程序的URL端点（Endpoints）以及服
            
                    
            • 
                    
          • dv-scroll-board 鼠标移入单元格显示单元格所有数据
                        mengfei-super
计算机外设前端vue.js
                        
            前言：在使用大屏组件库data-v开发大屏驾驶舱系统，dv-scroll-board实现表格数据滚动的效果，但是某一列数据较多，需求提出：鼠标移上去要显示对应的问题，完全展示出来。奈何以前没有搞过这个问题，随即立马找向百度麻麻！实现效果及方法如下：{{dvTextName}}exportdefault{data(){return{dvText:{keyX:"15px",keyY:"0px",},d
            
                    
            • 
                    
          • Python 用户账户(让用户拥有自己的数据)
                        钢铁男儿
Python从入门到精通python数据库sqlite
                        
            Web应用程序的核心是让任何用户都能够注册账户并能够使用它，不管用户身处何方。在本章中，你将创建一些表单，让用户能够添加主题和条目，以及编辑既有的条目。你还将学习Django如何防范对基于表单的网页发起的常见攻击，这让你无需花太多时间考虑确保应用程序安全的问题。然后，我们将实现一个用户身份验证系统。你将创建一个注册页面，供用户创建账户，并让有些页面只能供已登录的用户访问。接下来，我们将修改一些视图
            
                    
            • 
                                
          • 关于旗正规则引擎中的MD5加密问题
                                    何必如此
jspMD5规则加密
                                    
            一般情况下，为了防止个人隐私的泄露，我们都会对用户登录密码进行加密，使数据库相应字段保存的是加密后的字符串，而非原始密码。 
在旗正规则引擎中，通过外部调用，可以实现MD5的加密，具体步骤如下： 
1.在对象库中选择外部调用，选择“com.flagleader.util.MD5”，在子选项中选择“com.flagleader.util.MD5.getMD5ofStr({arg1})”； 
2.在规
            
                                
            • 
                                
          • 【Spark101】Scala Promise/Future在Spark中的应用
                                    bit1129
Promise
                                    
            Promise和Future是Scala用于异步调用并实现结果汇集的并发原语，Scala的Future同JUC里面的Future接口含义相同，Promise理解起来就有些绕。等有时间了再仔细的研究下Promise和Future的语义以及应用场景，具体参见Scala在线文档：http://docs.scala-lang.org/sips/completed/futures-promises.html
            
                                
            • 
                                
          • spark sql 访问hive数据的配置详解
                                    daizj
spark sqlhivethriftserver
                                    
            spark sql 能够通过thriftserver 访问hive数据，默认spark编译的版本是不支持访问hive，因为hive依赖比较多，因此打的包中不包含hive和thriftserver,因此需要自己下载源码进行编译，将hive，thriftserver打包进去才能够访问，详细配置步骤如下： 
  
1、下载源码 
  
2、下载Maven,并配置 
此配置简单，就略过
            
                                
            • 
                                
          • HTTP 协议通信
                                    周凡杨
javahttpclienthttp通信
                                    
              
                      
一：简介 
 HTTPCLIENT，通过JAVA基于HTTP协议进行点与点间的通信！ 
  
  
二： 代码举例 
  
   测试类： 
 
import java
            
                                
            • 
                                
          • java unix时间戳转换
                                    g21121
java
                                    
            把java时间戳转换成unix时间戳： 
Timestamp appointTime=Timestamp.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()))
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:m
            
                                
            • 
                                
          • web报表工具FineReport常用函数的用法总结（报表函数）
                                    老A不折腾
web报表finereport总结
                                    
            说明：本次总结中，凡是以tableName或viewName作为参数因子的。函数在调用的时候均按照先从私有数据源中查找，然后再从公有数据源中查找的顺序。 
  
CLASS 
CLASS(object):返回object对象的所属的类。 
  
CNMONEY 
CNMONEY(number,unit)返回人民币大写。 
number:需要转换的数值型的数。 
unit:单位，
            
                                
            • 
                                
          • java jni调用c++ 代码 报错
                                    墙头上一根草
javaC++jni
                                    
            # 
# A fatal error has been detected by the Java Runtime Environment: 
# 
#  EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x00000000777c3290, pid=5632, tid=6656 
# 
# JRE version: Java(TM) SE Ru
            
                                
            • 
                                
          • Spring中事件处理de小技巧
                                    aijuans
springSpring 教程Spring 实例Spring 入门Spring3
                                    
            Spring   中提供一些Aware相关de接口，BeanFactoryAware、 ApplicationContextAware、ResourceLoaderAware、ServletContextAware等等，其中最常用到de匙ApplicationContextAware.实现ApplicationContextAwaredeBean，在Bean被初始后，将会被注入 Applicati
            
                                
            • 
                                
          • linux shell ls脚本样例
                                    annan211
linuxlinux ls源码linux 源码
                                    
            
#! /bin/sh -
#查找输入文件的路径
#在查找路径下寻找一个或多个原始文件或文件模式
# 查找路径由特定的环境变量所定义

#标准输出所产生的结果 通常是查找路径下找到的每个文件的第一个实体的完整路径
# 或是filename :not found 的标准错误输出。

#如果文件没有找到 则退出码为0
#否则 即为找不到的文件个数
#语法 pathfind [--
            
                                
            • 
                                
          • List,Set,Map遍历方式 (收集的资源,值得看一下)
                                    百合不是茶
listsetMap遍历方式
                                    
            List特点：元素有放入顺序，元素可重复
Map特点：元素按键值对存储，无放入顺序
Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的）
List接口有三个实现类：LinkedList，ArrayList，Vector
LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身
            
                                
            • 
                                
          • 解决SimpleDateFormat的线程不安全问题的方法
                                    bijian1013
javathread线程安全
                                    
            在Java项目中，我们通常会自己写一个DateUtil类，处理日期和字符串的转换，如下所示： 
public class DateUtil01 {

	private SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

	public void format(Date d
            
                                
            • 
                                
          • http请求测试实例（采用fastjson解析）
                                    bijian1013
http测试
                                    
                    在实际开发中，我们经常会去做http请求的开发，下面则是如何请求的单元测试小实例，仅供参考。 
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.httpclient.HttpClient;
import 
            
                                
            • 
                                
          • 【RPC框架Hessian三】Hessian 异常处理
                                    bit1129
hessian
                                    
            RPC异常处理概述   
RPC异常处理指是，当客户端调用远端的服务，如果服务执行过程中发生异常，这个异常能否序列到客户端？ 
  
如果服务在执行过程中可能发生异常，那么在服务接口的声明中，就该声明该接口可能抛出的异常。 
  
在Hessian中，服务器端发生异常，可以将异常信息从服务器端序列化到客户端，因为Exception本身是实现了Serializable的
            
                                
            • 
                                
          • 【日志分析】日志分析工具
                                    bit1129
日志分析
                                    
            1. 网站日志实时分析工具 GoAccess 
http://www.vpsee.com/2014/02/a-real-time-web-log-analyzer-goaccess/ 
2. 通过日志监控并收集 Java 应用程序性能数据(Perf4J) 
http://www.ibm.com/developerworks/cn/java/j-lo-logforperf/ 
3.log.io 
和
            
                                
            • 
                                
          • nginx优化加强战斗力及遇到的坑解决
                                    ronin47
nginx 优化
                                    
            　　　先说遇到个坑，第一个是负载问题，这个问题与架构有关，由于我设计架构多了两层，结果导致会话负载只转向一个。解决这样的问题思路有两个：一是改变负载策略，二是更改架构设计。 
　　　由于采用动静分离部署，而nginx又设计了静态，结果客户端去读nginx静态，访问量上来，页面加载很慢。解决：二者留其一。最好是保留apache服务器。 
  
　　　来以下优化： 
  
　　　 
            
                                
            • 
                                
          • java-50-输入两棵二叉树A和B，判断树B是不是A的子结构
                                    bylijinnan
java
                                    
            思路来自： 
http://zhedahht.blog.163.com/blog/static/25411174201011445550396/ 
 

import ljn.help.*;
public class HasSubtree {

	/**Q50.
	 * 输入两棵二叉树A和B，判断树B是不是A的子结构。

例如，下图中的两棵树A和B，由于A中有一部分子树的结构和B是一
            
                                
            • 
                                
          • mongoDB 备份与恢复
                                    开窍的石头
mongDB备份与恢复
                                    
            Mongodb导出与导入 
 
1: 导入/导出可以操作的是本地的mongodb服务器,也可以是远程的. 
所以,都有如下通用选项: 
-h host   主机 
--port port    端口 
-u username 用户名 
-p passwd   密码 
 
 
2: mongoexport 导出json格式的文件 
            
                                
            • 
                                
          • [网络与通讯]椭圆轨道计算的一些问题
                                    comsci
网络
                                    
             
     如果按照中国古代农历的历法，现在应该是某个季节的开始，但是由于农历历法是3000年前的天文观测数据，如果按照现在的天文学记录来进行修正的话，这个季节已经过去一段时间了。。。。。 
 
      也就是说，还要再等3000年。才有机会了，太阳系的行星的椭圆轨道受到外来天体的干扰，轨道次序发生了变
            
                                
            • 
                                
          • 软件专利如何申请
                                    cuiyadll
软件专利申请
                                    
            软件技术可以申请软件著作权以保护软件源代码，也可以申请发明专利以保护软件流程中的步骤执行方式。专利保护的是软件解决问题的思想，而软件著作权保护的是软件代码（即软件思想的表达形式）。例如，离线传送文件，那发明专利保护是如何实现离线传送文件。基于相同的软件思想，但实现离线传送的程序代码有千千万万种，每种代码都可以享有各自的软件著作权。申请一个软件发明专利的代理费大概需要5000-8000申请发明专利可
            
                                
            • 
                                
          • Android学习笔记
                                    darrenzhu
android
                                    
            1.启动一个AVD 
2.命令行运行adb shell可连接到AVD,这也就是命令行客户端 
3.如何启动一个程序 
  am start -n package name/.activityName 
  am start -n com.example.helloworld/.MainActivity 
 
启动Android设置工具的命令如下所示： 
# am start -
            
                                
            • 
                                
          • apache虚拟机配置，本地多域名访问本地网站
                                    dcj3sjt126com
apache
                                    
            现在假定你有两个目录，一个存在于 /htdocs/a，另一个存在于 /htdocs/b 。 
现在你想要在本地测试的时候访问 www.freeman.com 对应的目录是 /xampp/htdocs/freeman ,访问 www.duchengjiu.com 对应的目录是 /htdocs/duchengjiu。 
1、首先修改C盘WINDOWS\system32\drivers\etc目录下的 
            
                                
            • 
                                
          • yii2 restful web服务[速率限制]
                                    dcj3sjt126com
PHPyii2
                                    
            速率限制 
为防止滥用，你应该考虑增加速率限制到您的API。 例如，您可以限制每个用户的API的使用是在10分钟内最多100次的API调用。 如果一个用户同一个时间段内太多的请求被接收， 将返回响应状态代码 429 (这意味着过多的请求)。 
要启用速率限制, [[yii\web\User::identityClass|user identity class]] 应该实现 [[yii\filter
            
                                
            • 
                                
          • Hadoop2.5.2安装——单机模式
                                    eksliang
hadoophadoop单机部署
                                    
            转载请出自出处：http://eksliang.iteye.com/blog/2185414 一、概述 
       Hadoop有三种模式 单机模式、伪分布模式和完全分布模式，这里先简单介绍单机模式 ，默认情况下，Hadoop被配置成一个非分布式模式，独立运行JAVA进程，适合开始做调试工作。 
  二、下载地址 
Hadoop 网址http:
            
                                
            • 
                                
          • LoadMoreListView+SwipeRefreshLayout（分页下拉）基本结构
                                    gundumw100
android
                                    
            一切为了快速迭代 
 
 
 
 

import java.util.ArrayList;

import org.json.JSONObject;

import android.animation.ObjectAnimator;
import android.os.Bundle;
import android.support.v4.widget.SwipeRefreshLayo
            
                                
            • 
                                
          • 三道简单的前端HTML/CSS题目
                                    ini
htmlWeb前端css题目
                                    
            使用CSS为多个网页进行相同风格的布局和外观设置时，为了方便对这些网页进行修改，最好使用（ ）。http://hovertree.com/shortanswer/bjae/7bd72acca3206862.htm 
  
在HTML中加入<table style=”color:red; font-size:10pt”>，此为（ ）。http://hovertree.com/s
            
                                
            • 
                                
          • overrided方法编译错误
                                    kane_xie
override
                                    
             
 问题描述： 
 
在实现类中的某一或某几个Override方法发生编译错误如下： 
Name clash: The method put(String) of type XXXServiceImpl has the same erasure as put(String) of type XXXService but does not override it 
  
当去掉@Over
            
                                
            • 
                                
          • Java中使用代理IP获取网址内容（防IP被封，做数据爬虫）
                                    mcj8089
免费代理IP代理IP数据爬虫JAVA设置代理IP爬虫封IP
                                    
            推荐两个代理IP网站： 
  
1. 全网代理IP：http://proxy.goubanjia.com/ 
  
2. 敲代码免费IP：http://ip.qiaodm.com/ 
  
Java语言有两种方式使用代理IP访问网址并获取内容， 
  
方式一，设置System系统属性 
  
// 设置代理IP
System.getProper
            
                                
            • 
                                
          • Nodejs Express 报错之 listen EADDRINUSE
                                    qiaolevip
每天进步一点点学习永无止境nodejs纵观千象
                                    
            当你启动 nodejs服务报错： 
>node app
Express server listening on port 80
events.js:85
      throw er; // Unhandled 'error' event
            ^
Error: listen EADDRINUSE
    at exports._errnoException (
            
                                
            • 
                                
          • C++中三种new的用法
                                    _荆棘鸟_
C++new
                                    
            转载自：http://news.ccidnet.com/art/32855/20100713/2114025_1.html 
作者: mt 
其一是new operator，也叫new表达式；其二是operator new，也叫new操作符。这两个英文名称起的也太绝了，很容易搞混，那就记中文名称吧。new表达式比较常见，也最常用，例如： 
string* ps = new string("
            
                                
            • 
                                
          • Ruby深入研究笔记1
                                    wudixiaotie
Ruby
                                    
            module是可以定义private方法的 
module MTest
  def aaa
    puts "aaa"
    private_method
  end

  private
    def private_method
      puts "this is private_method"
    end
end


            
                                
            •