springboot整合redis分页，消息中间件使用

业务场景：将班级下的学生信息存储进缓存，同时也是方便于对其进行分页操作
具体的流程：将符合条件的数据查询出来，在查询出来之后，再将数据存储进缓存中进行，例如按照报名时间，学生年龄倒序或者是顺序进行进行存储，
具体的代码实现流程： 先从缓存中查找，没有就从数据库中查询，查询出来的数据在保存到redis中，以后分页的情况都是从redis中拿取，主要涉及的代码就是redis的操作，一个是存，一个是取区间范围，一个删除redis区间的数据，都是用Zset中进行的

/**
     * 将元素添加进指定的key,并且指定元素的分值----这是存数据的方法
     * @param key
     * @param obj
     * @param score
     * @return
     */
    public boolean hZSet(String key, Object obj, double score){
        return  redisTemplate.opsForZSet().add(key, obj, score);
    }


/**
     * 对数据库中的元素进行分页处理-------这是取数据的操作
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set hZget(String key, double start, double end){
       return redisTemplate.opsForZSet().rangeByScore(key, start, end);
    }


 /**
     * 根据指定的数据来删除掉数据-------这是删除数据的方法
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Long hZDel(String key, double start, double end){
        return  redisTemplate.opsForZSet().removeRangeByScore(key, start, end);
    }

由于只是实验性质的，所以我在controller层中做缓存的操作：

/**
     * 关于 List<?>与List<Object> 以及 List</Object>
     * List<?>只能与List进行转换它与List<Object>是没有关系的
     * @return
     * @throws Exception
     */
    @DataSource("master")
    @RequestMapping(value = "page")
    public List<Student> redisPage(Integer page1, Integer pageSize){
//        List<Student> students = studentMapper.queryDatas();

        //redis中的数据进行分页数据
        Set studentPage = redisUtil.hZget("studentPage", (page1 - 1) * pageSize + 1, page1 * pageSize);
        Object[] objects = studentPage.toArray();
//        List<?> objects1 = CollectionUtils.arrayToList(objects);
//        List<Object> objects2 = Arrays.asList(objects);
        List<Student> students = new ArrayList<Student>(studentPage);
        //将redis中的数据进行删除操作
        redisUtil.hZDel("studentPage",(page1 - 1) * pageSize + 1, page1 * pageSize);
        return students;
    }

由于涉及到数组与集合之间的转换，所以我在这里编写了一个工具类:

@Component
public class ArraysUtils {


    /**
     * 将数组转换为集合的方法
     * @param arrays
     * @return
     */
    private static List arraysToList(Object[] arrays){
        return Arrays.asList(arrays);
        //另外一种转换方法,这个方法不是静态的方法
        //List<?> objects = CollectionUtils.arrayToList(arrays);
    }


    /**
     * 将数组转换为Set类型
     * @param arrays
     * @return
     */
    private static Set arraysToSet(Object[] arrays){
        return new HashSet(Arrays.asList(arrays));
    }


    /**
     * 将集合转换为数组
     * @param list
     * @return
     */
    private static Object[] listToArrays(List list){
        return list.toArray();
    }

    /**
     * 将list转换为Set
     * @param list
     * @return
     */
    private static Set listToSet(List list){
        return new HashSet(list);
    }


    /**
     * set转换为数组
     * @param set
     * @return
     */
    private static Object[] setToArray(Set set){
        return set.toArray();
    }

    /**
     * set转换为list
     * @param set
     * @return
     */
    private static List setToList(Set set){
        return new ArrayList(set);
    }

---

redis中的消息中间件的使用：
主要的流程就是:定义一个消息实体类， 在redis配置中配置好配置消息监听类， 定义一个消息接收类
消息实体类：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Message implements Serializable {

    //会话id
    private String sessionId;

    //消息体
    private String message;
}

redis配置类：

/**
     * redis消息监听器
     * 可以添加多个监听不同话题的redis监听器
     * 通过反射技术调用消息订阅处理器的相关方法进行一些业务处理
     * @param connectionFactory
     * @param listenerAdapter
     * @return
     */
    @Bean
    RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory, MessageListenerAdapter listenerAdapter){
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        //订阅通道的地方
        container.addMessageListener(listenerAdapter, new PatternTopic("chat"));
        //这个container 可以添加多个 messageLister
        return container;
    }


    /**
     * 消息监听器适配器，绑定消息处理器，利用反射技术调用消息处理器的业务方法
     * @param receiveMessage
     * @return
     */
    @Bean
    MessageListenerAdapter  listenerAdapter(MessageReceive receiveMessage){
        //作用是给messageListernerAdater传入一个消息接收的处理器，利用反射调用方法
        return new MessageListenerAdapter(receiveMessage, "receive");
    }

消息接收类：

@Slf4j
@Component
public class MessageReceive {


    /**
     * 接收消息並且将他转换为一个Map类型
     * @param message
     * @return
     */
    public void receive(String message){
        Map<String, String> map = JSON.parseObject(message, Map.class);
        log.info("获取到的信息为:{}", map);
        String sessionId = map.get("sessionId");
        String message1 = map.get("message");
        log.info("其中会话id为：{}, 消息数据为:{}", sessionId, message1);
    }
}

访问controller层，调用方法中来调用方法中作用：

 	@DataSource("master")
    @RequestMapping("redisMessage")
    public void sendMessage(){
        List<UserLogConfig> all = userLogConfigService.findAll();
        Message message = new Message("122", JSON.toJSONString(all));
        messageSend.messageSend(message);
    }