Redis频次访问控制器
设计思路
频次控制旨在控制某个用户接触到某个广告的次数,以达到提高广告性价比的目的,一般来说,随着某个用户看到同一个广告频次的逐渐上升,点击率呈逐渐下降的趋势,因此在按照CPM采买流量时,广告主有时会要求根据品次控制某个用户接触到某次广告的次数
- 首先,使用redis的hash类型来构建用户,广告,频次访问限制
- 其次,使用用户+广告id为key,来构建用户对某广告的访问频次统计
# HMSET userID adID reqFrequency,使用HMSET构建用户,广告和访问频次的关系
127.0.0.1:6379> HMSET 12345 1 3
OK
# 初始化广告的访问频次
127.0.0.1:6379> set 12345_1 0
OK
#设置过期时间
127.0.0.1:6379> EXPIREAT 12345_1 1513239705
(integer) 1
#增加广告访问频次
127.0.0.1:6379> INCR 12345_1
(integer) 1
#获取用户访问的某个广告的频次
127.0.0.1:6379> HMGET 12345 1
1) "3"
Java源码
明天使用springclou分布式和schedule定时任务
可以的话在加上caffeine二级缓存
整体结构
数据库代码
### 模拟redis频次过滤数据库
CREATE TABLE ad_user(
uid INT(10) PRIMARY KEY NOT NULL,
aid INT(10) NOT NULL
)
INSERT INTO ad_user VALUES(1000,2000);
INSERT INTO ad_user VALUES(1001,2001);
INSERT INTO ad_user VALUES(1002,2002);
每个部分的代码
启动类
package com.xfgg.demo;
import org.apache.ibatis.annotations.Mapper;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
@MapperScan("com.xfgg.demo.dao")
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
配置文件
spring:
redis:
host: 127.0.0.1
port: 6379
database: 0
datasource:
url: jdbc:mysql://localhost:3306/ad_user_time
driver-class-name: com.mysql.jdbc.Driver
username: root
password: 123456
server:
port: 8900
config
package com.xfgg.demo.config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;
import java.util.Map;
@Configuration
public class RedisConfig {
@Value("${spring.redis.host}")
private String host;
@Value("${spring.redis.port}")
private int port;
@Value("${spring.redis.database}")
private int databaseId;
@Bean
@ConfigurationProperties(prefix = "spring.redis")
public JedisPoolConfig getRedisConfig() {
JedisPoolConfig config = new JedisPoolConfig();
return config;
}
@Bean
public JedisConnectionFactory jedisConnectionFactory() {
JedisConnectionFactory factory = new JedisConnectionFactory();
factory.setUsePool(true);
JedisPoolConfig config = getRedisConfig();
factory.setPoolConfig(config);
factory.setHostName(host);
factory.setPort(port);
factory.setDatabase(databaseId);
return factory;
}
@Bean
public RedisTemplate<?, ?> getRedisTemplate(){
return new StringRedisTemplate(jedisConnectionFactory());
}
@Bean("user_test")
public RedisTemplate<String, Map<String, String>> redisTemplate() {
final RedisTemplate<String, Map<String, String>> template = new RedisTemplate<>();
template.setConnectionFactory(jedisConnectionFactory());
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
template.setKeySerializer(stringRedisSerializer);
template.setHashKeySerializer(stringRedisSerializer);
template.setHashValueSerializer(stringRedisSerializer);
return template;
}
}
constant
package com.xfgg.demo.constant;
public interface AdShowTimes {
String AD_LIMIT_TIMES="10";
}
controller
AdshowController
package com.xfgg.demo.controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class AdShowController {
@RequestMapping("/show/{uid}/{aid}")
public String show(@PathVariable("uid") String uid,
@PathVariable("aid") String aid){
return "调用了广告服务接口,频次加1";
}
}
AdUserController
package com.xfgg.demo.controller;
import com.xfgg.demo.entity.AdUser;
import com.xfgg.demo.service.AdUserService;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.util.List;
@RestController
public class AdUserController {
@Resource
private AdUserService adUserService;
@RequestMapping("")
public List<AdUser> findAll(){
return adUserService.findAll();
}
}
RedisFilterController
package com.xfgg.demo.controller;
import com.xfgg.demo.service.RedisFilterService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class RedisFilterController {
@Autowired
private RedisFilterService filterService;
@RequestMapping("/redis")
public void setData(){
filterService.setData();
}
@RequestMapping("/re")
public void setData2(){
filterService.setData2();
}
}
dao
package com.xfgg.demo.dao;
import com.xfgg.demo.entity.AdUser;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import java.util.List;
@Mapper
public interface AdUserDao{
@Select("select * from ad_user")
List<AdUser> findAll();
}
entiry
package com.xfgg.demo.entity;
import lombok.Data;
@Data
public class AdUser {
private String uid;
private String aid;
}
service
AdUserService
package com.xfgg.demo.service;
import com.xfgg.demo.entity.AdUser;
import java.util.List;
public interface AdUserService {
List<AdUser> findAll();
}
RedisFilterService
package com.xfgg.demo.service;
public interface RedisFilterService {
将数据库数据加入到redis缓存中
void setData();
uid_aid为key,times为value,放入redis缓存中
void setData2();
//根据传入的广告id和用户id增加指定用户的频次
}
impl
AdUserServiceImpl
package com.xfgg.demo.service.impl;
import com.xfgg.demo.dao.AdUserDao;
import com.xfgg.demo.entity.AdUser;
import com.xfgg.demo.service.AdUserService;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;
@Service
public class AdUserServiceImpl implements AdUserService{
@Resource
private AdUserDao adUserDao;
@Override
public List<AdUser> findAll() {
return adUserDao.findAll();
}
}
RedisFilterServiceImpl
package com.xfgg.demo.service.impl;
import com.xfgg.demo.constant.AdShowTimes;
import com.xfgg.demo.service.AdUserService;
import com.xfgg.demo.service.RedisFilterService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
@Service
public class RedisFilterServiceImpl implements RedisFilterService {
@Autowired
private AdUserService adUserService;
@Resource(name = "user_test")
private RedisTemplate<String, Map<String,String>> redisTemplate;
@Resource
private RedisTemplate<String,String> redisTemplate1;
//将数据库数据加入到redis缓存中
@Override
public void setData(){
for (int i =0;i<adUserService.findAll().size();i++){
Map<String,String> results = new HashMap<>();
results.put(adUserService.findAll().get(i).getUid(),"0");
redisTemplate.opsForHash().putAll(adUserService.findAll().get(i).getAid(),results);
//设置过期时间
redisTemplate.expire(adUserService.findAll().get(i).getAid(),60*10,TimeUnit.SECONDS);
}
}
//uid_aid为key,times为value,放入redis缓存中
//后续改为caffeine缓存,重置操作也加入定时任务中,每天清零
@Override
public void setData2(){
for (int i=0;i<adUserService.findAll().size();i++){
redisTemplate1.opsForValue().set(adUserService.findAll().get(i).getUid()+"_"+adUserService.findAll().get(i).getAid()
, AdShowTimes.AD_LIMIT_TIMES);
}
}
}
效果图
具体页面效果还没做