public class IpFilterRuleHandler extends RuleBasedIpFilter {
    private BlackService blackService = SpringUtil.getBean(BlackService.class);
    @Override
    protected boolean accept(ChannelHandlerContext ctx, InetSocketAddress remoteAddress) throws Exception {
        String hostAddress = remoteAddress.getHostString();//ip信息
        IpFilterRuleType filterRuleType = IpFilterRuleType.ACCEPT;//通过
        if(StrUtil.isNotBlank(hostAddress)){
            boolean isReject = blackService.checkBlackList(hostAddress);//检测实时黑名单
            if(isReject){
                filterRuleType = IpFilterRuleType.REJECT;//拒绝创建
            }
        }
        return filterRuleType == IpFilterRuleType.ACCEPT;
    }
}

 //代码片段
ServerBootstrap b = new ServerBootstrap();
 b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
         .childHandler(new ChannelInitializer<NioSocketChannel>() {
             @Override
             public void initChannel(NioSocketChannel ch) throws Exception {
                 // 注册handler
                 ch.pipeline().addLast(new IpFilterRuleHandler());//添加IP过滤
             }
         })
     );

//此处省略N行代码
ServletOutputStream os = response.getOutputStream();
File zipFileDownLoad = //此处省略下载文件代码
IoUtil.write(os,true,FileUtil.readBytes(zipFileDownLoad));//读取文件下载

java.lang.OutOfMemoryError: Java heap space //这个很熟悉吧

InputStream is = new FileInputStream(fileDownLoad);//需要下载文件，读取固定的字节数，写入os中
int read;
byte[] bytes = new byte[2048];
while((read = is.read(bytes))!=-1){//按字节逐个写入，避免内存占用过高
os.write(bytes, 0, read);
}
os.flush();
is.close();//记得关闭流

RRateLimiter rateLimiter = redisson.getRateLimiter("myRateLimiter");
// 初始化
// 最大流速 = 每1秒钟产生10个令牌
rateLimiter.trySetRate(RateType.OVERALL, 10, 1, RateIntervalUnit.SECONDS);

CountDownLatch latch = new CountDownLatch(2);
limiter.acquire(3);
// ...

Thread t = new Thread(() -> {
    limiter.acquire(2);
    // ...        
});

@Component
@Scope
@Aspect
public class RateLimitAop {

    @Autowired
    private RedissonClient redissonClient;

    @Pointcut("@annotation(com.data.estimated.limiter.RateLimitAspect)")
    public void serviceLimit() {

    }

    @Around("serviceLimit()")
    public Object around(ProceedingJoinPoint joinPoint) {
        ServletRequestAttributes servletRequestAttributes = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes());
        HttpServletRequest request = servletRequestAttributes.getRequest();//获取请求
        HttpServletResponse response = servletRequestAttributes.getResponse();//获取响应
        StringBuffer buffer = new StringBuffer();
        String url = request.getRequestURI();
        buffer.append(StrUtil.replace(url,"/","_"));
        buffer.append("_");
        buffer.append(IPUtil.getIpAddr(request));//获取请求IP信息
        RRateLimiter rRateLimiter = getRRateLimiter(joinPoint,buffer.toString());//获取配置RRateLimiter信息
        boolean flag = rRateLimiter.tryAcquire();
        Object obj = null;
        try {
            if (flag) {
                obj = joinPoint.proceed();
            }else{
                outRateLimiterMsg(response,new JSONObject(BaseResult.LIMIT_FAIL()).toString());//响应浏览器,超频请求
            }
        } catch (Throwable e) {
            e.printStackTrace();
            outRateLimiterMsg(response,new JSONObject(BaseResult.FAIL()).toString());//响应浏览器,错误
        }
        return obj;
    }

    /**
     *
     * @param joinPoint
     * @param limitKey
     * @return
     */
    private RRateLimiter getRRateLimiter(ProceedingJoinPoint joinPoint,String limitKey){
        RateLimitAspect rateLimit = getRateLimitAspect(joinPoint);
        long count = rateLimit.count();//限流次数
        long time = rateLimit.time();//限流时间
        RRateLimiter rRateLimiter = redissonClient.getRateLimiter(StrUtil.isBlank(rateLimit.key()) ? limitKey : rateLimit.key());
        if(rRateLimiter.isExists()){
            RateLimiterConfig rateLimiterConfig = rRateLimiter.getConfig();//读取已经存在配置
            long rateInterval = rateLimiterConfig.getRateInterval();//限时时间
            long rate = rateLimiterConfig.getRate();//次数
            if(time != rateInterval || rate != count){
                rRateLimiter.delete();//移除配置，重新加载配置
                rRateLimiter.trySetRate(RateType.OVERALL, count ,time , RateIntervalUnit.SECONDS);
            }
        }
        rRateLimiter.trySetRate(RateType.OVERALL, count ,time , RateIntervalUnit.SECONDS);
        return rRateLimiter;
    }

    /**
     * 获取脚注配置信息
     * @param joinPoint
     * @return
     */
    private RateLimitAspect getRateLimitAspect(ProceedingJoinPoint joinPoint){
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        RateLimitAspect rateLimit = method.getAnnotation(RateLimitAspect.class);
        return rateLimit;
    }

    /**
     * 客户端返回数据
     */
    private void outRateLimiterMsg(HttpServletResponse response,String message){
        PrintWriter writer = null;
        try {
            response.reset();
            response.setCharacterEncoding("utf-8");
            response.setHeader("content-type", "application/json;charset=utf-8");
            response.addHeader("Access-Control-Allow-Origin", "*");
            response.addHeader("Access-Control-Allow-Headers", "X-Requested-With");
            response.addHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS");
            writer = response.getWriter();
            writer.write(message);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            IoUtil.close(writer);
        }
    }
}

/**
 * 自定义注解可以不包含属性，成为一个标识注解
 */
@Inherited
@Documented
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimitAspect {
    /**
     * 限流唯一标示
     *
     * @return
     */
    String key() default "";

    /**
     * 限流时间
     * @return
     */
    long time() default 5;

    /**
     * 限流次数
     * @return
     */
    long count() default 1;
}

//默认无参数方法
@RateLimitAspect

//有参数
@RateLimitAspect(key = "RateLimitAspect",count = 2,time = 10)

//如果可以多个方法key均为RateLimitAspect这采用同一个限制。

//第一步引入
@Autowired
private RedissonClient redissonClient;

//第二部消息发布
RTopic rTopic = redissonClient.getTopic("RTopicTest", new SerializationCodec());
JSONObject msg = new JSONObject();
msg.put("msg","订阅测试");
rTopic.publish(msg);

//第三部消息订阅
 RTopic rTopic = redissonClient.getTopic("RTopicTest",new SerializationCodec());
    rTopic.addListener(JSONObject.class,new MessageListener<JSONObject>(){
        @Override
        public void onMessage(CharSequence charSequence, JSONObject msg) {
            System.out.println("MSG:"msg.get("msg"));
        }
    });

redissonClient.getBucket("MY_LOCK_VALUES").set("1111111");
RLock lock = redissonClient.getLock("myLock");

// traditional lock method
//lock.lock();

// or acquire lock and automatically unlock it after 10 seconds
//lock.lock(10, TimeUnit.SECONDS);

// or wait for lock aquisition up to 100 seconds
// and automatically unlock it after 10 seconds
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
String result = "";
if (res) {
try {
    result = redissonClient.getBucket("MY_LOCK_VALUES").get().toString();
} finally {
    lock.unlock();
}
}

package com.laowj.websocket;

import com.laowj.websocket.handler.WebSocketServerHandler;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.handler.stream.ChunkedWriteHandler;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

/**
 * web socket 服务类
 */
@Component
public class WebSocketService implements ApplicationRunner {

    @Value("${websocket.port}")
    private int socketPort;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch)
                                throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast("http-codec",
                                    new HttpServerCodec());
                            pipeline.addLast("aggregator",
                                    new HttpObjectAggregator(65536));
                            pipeline.addLast("http-chunked",
                                    new ChunkedWriteHandler());
                            pipeline.addLast("handler",
                                    new WebSocketServerHandler());
                            pipeline.addLast("logger",new LoggingHandler(LogLevel.INFO));
                        }
                    });

            Channel ch = b.bind(socketPort).sync().channel();
            System.out.println("Web socket server started at port " + socketPort
                    + '.');
            System.out
                    .println("Open your browser and navigate to http://localhost:"
                            + socketPort + '/');

            ch.closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

package com.laowj.websocket.handler;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.FullHttpResponse;
import io.netty.handler.codec.http.QueryStringDecoder;
import io.netty.handler.codec.http.websocketx.*;
import io.netty.util.Attribute;
import io.netty.util.AttributeKey;
import io.netty.util.CharsetUtil;
import io.netty.util.concurrent.GlobalEventExecutor;

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;

import static io.netty.handler.codec.http.HttpHeaderNames.HOST;
import static io.netty.handler.codec.http.HttpMethod.GET;
import static io.netty.handler.codec.http.HttpResponseStatus.*;
import static io.netty.handler.codec.http.HttpUtil.isKeepAlive;
import static io.netty.handler.codec.http.HttpUtil.setContentLength;
import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1;

public class WebSocketServerHandler extends SimpleChannelInboundHandler<Object> {
    private static final Logger logger = Logger
            .getLogger(WebSocketServerHandler.class.getName());

    private WebSocketServerHandshaker handshaker;

    // websocket 服务的 uri
    private static final String WEBSOCKET_PATH = "/ws_protocol";

    // 一个 ChannelGroup 代表一个频道
    public static Map<String, ChannelGroup> channelGroupMap = new ConcurrentHashMap<>();

    // 本次请求的 code
    private static final String HTTP_REQUEST_STRING = "token";

    /**
     * 存储token
     */
    private static AttributeKey<String> TOKEN_CHANNEL_KEYS = AttributeKey.valueOf("TOKEN.CHANNEL.KEYS");

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 传统的HTTP接入
        if (msg instanceof FullHttpRequest) {
            handleHttpRequest(ctx, (FullHttpRequest) msg);
        }
        // WebSocket接入
        else if (msg instanceof WebSocketFrame) {
            handleWebSocketFrame(ctx, (WebSocketFrame) msg);
        }
    }

    private void handleHttpRequest(ChannelHandlerContext ctx,
                                   FullHttpRequest req) throws Exception {

        // 如果HTTP解码失败，返回HTTP异常
        if (!req.decoderResult().isSuccess()
                || (!"websocket".equals(req.headers().get("Upgrade")))) {
            sendHttpResponse(ctx, req, new DefaultFullHttpResponse(HTTP_1_1,
                    BAD_REQUEST));
            return;
        }

        // Allow only GET methods.
        if (req.method() != GET) {
            sendHttpResponse(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, FORBIDDEN));
            return;
        }

        if ("/favicon.ico".equals(req.uri()) || ("/".equals(req.uri()))) {
            sendHttpResponse(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, NOT_FOUND));
            return;
        }

        QueryStringDecoder queryStringDecoder = new QueryStringDecoder(req.uri());
        Map<String, List<String>> parameters = queryStringDecoder.parameters();

        if (parameters.size() == 0 || !parameters.containsKey(HTTP_REQUEST_STRING)) {
            System.err.printf(HTTP_REQUEST_STRING + "参数不可缺省");
            sendHttpResponse(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, NOT_FOUND));
            return;
        }

        String token = parameters.get(HTTP_REQUEST_STRING).get(0);

        // 用户唯一标识不存在返回,则新增一个频道 ChannelGroup
        if (!channelGroupMap.containsKey(token)) {
            channelGroupMap.put(token, new DefaultChannelGroup(GlobalEventExecutor.INSTANCE));
        }
        // 确定有唯一标识,才将客户端加入到频道中
        channelGroupMap.get(token).add(ctx.channel());
        Attribute<String> tokenAttr = ctx.channel().attr(TOKEN_CHANNEL_KEYS);
        tokenAttr.setIfAbsent(token);

        // 构造握手响应返回
        WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
                getWebSocketLocation(req), null, false);
        handshaker = wsFactory.newHandshaker(req);
        if (handshaker == null) {
            WebSocketServerHandshakerFactory
                    .sendUnsupportedVersionResponse(ctx.channel());
        } else {
            handshaker.handshake(ctx.channel(), req);
        }
    }

    private void handleWebSocketFrame(ChannelHandlerContext ctx,
                                      WebSocketFrame frame) throws Exception {

        // 判断是否是关闭链路的指令
        if (frame instanceof CloseWebSocketFrame) {
            handshaker.close(ctx.channel(),
                    (CloseWebSocketFrame) frame.retain());
            return;
        }
        // 判断是否是Ping消息
        if (frame instanceof PingWebSocketFrame) {
            ctx.channel().write(
                    new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        // 本例程仅支持文本消息，不支持二进制消息
        if (!(frame instanceof TextWebSocketFrame)) {
            throw new UnsupportedOperationException(String.format(
                    "%s frame types not supported", frame.getClass().getName()));
        }

        // 返回应答消息
        String request = ((TextWebSocketFrame) frame).text();
        if (logger.isLoggable(Level.FINE)) {
            logger.fine(String.format("%s received %s", ctx.channel(), request));
        }
        ctx.channel().write(new TextWebSocketFrame(" 收到客户端请求："+ request ));
    }

    private static void sendHttpResponse(ChannelHandlerContext ctx,
                                         FullHttpRequest req, FullHttpResponse res) {
        // 返回应答给客户端
        if (res.status().code() != 200) {
            ByteBuf buf = Unpooled.copiedBuffer(res.status().toString(),
                    CharsetUtil.UTF_8);
            res.content().writeBytes(buf);
            buf.release();
            setContentLength(res, res.content().readableBytes());
        }

        // 如果是非Keep-Alive，关闭连接
        ChannelFuture f = ctx.channel().writeAndFlush(res);
        if (!isKeepAlive(req) || res.status().code() != 200) {
            f.addListener(ChannelFutureListener.CLOSE);
        }
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
            throws Exception {
        cause.printStackTrace();
        close(ctx);
    }

    private void close(ChannelHandlerContext ctx){
        Attribute<String> tokenAttr = ctx.channel().attr(TOKEN_CHANNEL_KEYS);
        String token = tokenAttr.get();
        if (token != null && channelGroupMap.containsKey(token)) {//从群组中移除
            ChannelGroup channelGroup = channelGroupMap.get(token);
            int len = channelGroup.size();
            if (len <= 1) {//群组就一个人直接移除群主
                channelGroupMap.remove(token);
            }else{
                channelGroupMap.get(token).remove(ctx.channel());
            }
        }
        ctx.close();
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        close(ctx);
    }

    private static String getWebSocketLocation(FullHttpRequest req) {
        String location = req.headers().get(HOST) + WEBSOCKET_PATH;
        return "ws://" + location;
    }
}