Springboot使用redis实现接口Api限流的实例

<!--用于redis数据库连接-->

<dependency>

     <groupid>org.springframework.boot</groupid>

     <artifactid>spring-boot-starter-data-redis</artifactid>

</dependency>

<!--用于redis lettuce 连接池pool使用-->

<dependency>

     <groupid>org.apache测试数据mons</groupid>

     <artifactid>commons-pool2</artifactid>

</dependency>

<dependency>

     <groupid>org.springframework.boot</groupid>

     <artifactid>spring-boot-starter-web</artifactid>

</dependency>

spring:

   redis:

     lettuce:

       pool:

         #连接池最大连接数 使用负值代表无限制 默认为 8

         max-active: 10

         #最大空闲连接 默认 8

         max-idle: 10

         #最小空闲连接 默认 0

         min-idle: 1

     host: 127.0 . 0.1

     password: 123456

     port: 6379

     database: 0

     timeout: 2000ms

server:

   port: 8710

import com.fasterxml.jackson.annotation.jsonautodetect;

import com.fasterxml.jackson.annotation.propertyaccessor;

import com.fasterxml.jackson.databind.objectmapper;

import org.springframework.cache.cachemanager;

import org.springframework.cache.annotation.enablecaching;

import org.springframework.context.annotation.bean;

import org.springframework.context.annotation.configuration;

import org.springframework.data.redis.cache.rediscacheconfiguration;

import org.springframework.data.redis.cache.rediscachemanager;

import org.springframework.data.redis.connection.redisconnectionfactory;

import org.springframework.data.redis.core.redistemplate;

import org.springframework.data.redis.core.stringredistemplate;

import org.springframework.data.redis.serializer.jackson2jsonredisserializer;

import org.springframework.data.redis.serializer.redisserializationcontext;

import org.springframework.data.redis.serializer.stringredisserializer;

import static org.springframework.data.redis.cache.rediscacheconfiguration.defaultcacheconfig;

/**

  * @author: jcccc

  * @createtime: 2018-09-11

  * @description:

  */

@configuration

@enablecaching

public class redisconfig {

     @bean

     public cachemanager cachemanager(redisconnectionfactory connectionfactory) {

         rediscacheconfiguration cacheconfiguration =

                 defaultcacheconfig()

                         .disablecachingnullvalues()

                         .serializevalueswith(redisserializationcontext.serializationpair.fromserializer( new jackson2jsonredisserializer(object. class )));

         return rediscachemanager.builder(connectionfactory).cachedefaults(cacheconfiguration).build();

     }

     @bean

     public redistemplate<string, object> redistemplate(redisconnectionfactory factory) {

         redistemplate<string, object> redistemplate = new redistemplate<>();

         redistemplate.setconnectionfactory(factory);

         jackson2jsonredisserializer jackson2jsonredisserializer = new jackson2jsonredisserializer(object. class );

         objectmapper om = new objectmapper();

         om.setvisibility(propertyaccessor.all, jsonautodetect.visibility.any);

         om.enabledefaulttyping(objectmapper.defaulttyping.non_final);

         jackson2jsonredisserializer.setobjectmapper(om);

         //序列化设置 ，这样为了存储操作对象时正常显示的数据，也能正常存储和获取

         redistemplate.setkeyserializer( new stringredisserializer());

         redistemplate.setvalueserializer(jackson2jsonredisserializer);

         redistemplate.sethashkeyserializer( new stringredisserializer());

         redistemplate.sethashvalueserializer(jackson2jsonredisserializer);

         return redistemplate;

     }

     @bean

     public stringredistemplate stringredistemplate(redisconnectionfactory factory) {

         stringredistemplate stringredistemplate = new stringredistemplate();

         stringredistemplate.setconnectionfactory(factory);

         return stringredistemplate;

     }

}

import java.lang.annotation.*;

/**

  * @author jcccc

  * @description

  * @date 2021/7/23 11:46

  */

@inherited

@documented

@target ({elementtype.field, elementtype.type, elementtype.method})

@retention (retentionpolicy.runtime)

public @interface requestlimit {

     /**

      * 时间内  秒为单位

      */

     int second() default 10 ;

     /**

      *  允许访问次数

      */

     int maxcount() default 5 ;

     //默认效果 ： 10秒内 对于使用该注解的接口，只能总请求访问数 不能大于 5次

}

import com.elegant.testdemo.annotation.requestlimit;

import com.elegant.testdemo.utils.iputil;

import com.fasterxml.jackson.databind.objectmapper;

import org.slf4j.logger;

import org.slf4j.loggerfactory;

import org.springframework.beans.factory.annotation.autowired;

import org.springframework.data.redis.core.redistemplate;

import org.springframework.stereotype测试数据ponent;

import org.springframework.web.method.handlermethod;

import org.springframework.web.servlet.handlerinterceptor;

import javax.servlet.http.httpservletrequest;

import javax.servlet.http.httpservletresponse;

import java.io.ioexception;

import java.util.concurrent.timeunit;

/**

  * @author jcccc

  * @description

  * @date 2021/7/23 11:49

  */

@component

public class requestlimitinterceptor implements handlerinterceptor {

     private final logger log = loggerfactory.getlogger( this .getclass());

     @autowired

     private redistemplate<string, object> redistemplate;

     @override

     public boolean prehandle(httpservletrequest request, httpservletresponse response, object handler) throws exception {

         try {

             if (handler instanceof handlermethod) {

                 handlermethod handlermethod = (handlermethod) handler;

                 // 获取requestlimit注解

                 requestlimit requestlimit = handlermethod.getmethodannotation(requestlimit. class );

                 if ( null ==requestlimit) {

                     return true ;

                 }

                 //限制的时间范围

                 int seconds = requestlimit.second();

                 //时间内的 最大次数

                 int maxcount = requestlimit.maxcount();

                 string ipaddr = iputil.getipaddr(request);

                 // 存储key

                 string key =  ipaddr+ ":" +request.getcontextpath() + ":" + request.getservletpath();

                 // 已经访问的次数

                 integer count = (integer) redistemplate.opsforvalue().get(key);

                 log.info( "检测到目前ip对接口={}已经访问的次数" , request.getservletpath() , count);

                 if ( null == count || - 1 == count) {

                     redistemplate.opsforvalue().set(key, 1 , seconds, timeunit.seconds);

                     return true ;

                 }

                 if (count < maxcount) {

                     redistemplate.opsforvalue().increment(key);

                     return true ;

                 }

                 log.warn( "请求过于频繁请稍后再试" );

                 returndata(response);

                 return false ;

             }

             return true ;

         } catch (exception e) {

             log.warn( "请求过于频繁请稍后再试" );

             e.printstacktrace();

         }

         return true ;

     }

     public void returndata(httpservletresponse response) throws ioexception {

         response.setcharacterencoding( "utf-8" );

         response.setcontenttype( "application/json; charset=utf-8" );

         objectmapper objectmapper = new objectmapper();

         //这里传提示语可以改成自己项目的返回数据封装的类

         response.getwriter().println(objectmapper.writevalueasstring( "请求过于频繁请稍后再试" ));

         return ;

     }

}

import com.elegant.testdemo.interceptor.requestlimitinterceptor;

import org.springframework.beans.factory.annotation.autowired;

import org.springframework.context.annotation.configuration;

import org.springframework.web.servlet.config.annotation.interceptorregistry;

import org.springframework.web.servlet.config.annotation.webmvcconfigurer;

/**

  * @author jcccc

  * @description

  * @date 2021/7/23 11:52

  */

@configuration

public class webconfig implements webmvcconfigurer {

     @autowired

     private requestlimitinterceptor requestlimitinterceptor;

     @override

     public void addinterceptors(interceptorregistry registry) {

         registry.addinterceptor(requestlimitinterceptor)

                 //拦截所有请求路径

                 .addpathpatterns( "/**" )

                 //再设置 放开哪些路径

                 .excludepathpatterns( "/static/**" , "/auth/login" );

     }

}

import com.elegant.testdemo.annotation.requestlimit;

import org.springframework.web.bind.annotation.getmapping;

import org.springframework.web.bind.annotation.restcontroller;

/**

  * @author jcccc

  * @description

  * @date 2021/7/23 11:55

  */

@restcontroller

public class testcontroller {

     @getmapping ( "/test" )

     @requestlimit (maxcount = 3 ,second = 60 )

     public string test() {

         return "你好，如果对你有帮助，请点赞加关注。" ;

     }

}