Spring Boot项目实现轻量级消息队列（RedisTemplate）

点击上方 Java后端，选择 设为星标

优质文章，及时送达

---

背景

公司项目有个需求, 前端上传excel文件, 后端读取数据、处理数据、返回错误数据, 最简单的方式同步处理, 客户端上传文件后一直阻塞等待响应, 但用户体验无疑很差, 处理数据可能十分耗时, 没人愿意傻等, 由于项目暂未使用ActiveMQ等消息队列中间件, 而redis的lpush和rpop很适合作为一种轻量级的消息队列实现, 所以用它完成此次功能开发

一、本文涉及知识点

1. excel文件读写--阿里easyexcel sdk

2. 文件上传、下载--腾讯云对象存储

3. 远程服务调用--restTemplate

4. 生产者、消费者--redisTemplate leftPush和rightPop操作

5. 异步处理数据--Executors线程池

6. 读取网络文件流--HttpClient

7. 自定义注解实现用户身份认证--JWT token认证, 拦截器拦截标注有@LoginRequired注解的请求入口

当然, Java实现咯

涉及的知识点比较多, 每一个知识点都可以作为专题进行学习分析, 本文将完整实现呈现出来, 后期拆分与小伙伴分享学习。公众号 Java后端 历史发布过很多近百篇 Spring Boot 相关文章，欢迎关注公众号 Java后端 回复「666」获取。

二、项目目录结构

说明: 数据库DAO层放到另一个模块了, 不是本文重点

三、主要maven依赖

1. easyexcel

1.1.2-beta4


   com.alibaba
   easyexcel
   ${easyexcel-latestVersion}

2. JWT

   io.jsonwebtoken
   jjwt
   0.7.0

3. redis

   org.springframework.boot
   spring-boot-starter-redis
   1.3.5.RELEASE

4. 腾讯cos

   com.qcloud
   cos_api
   5.4.5

四、流程

1. 用户上传文件

2. 将文件存储到腾讯cos

3. 将上传后的文件id及上传记录保存到数据库

4. redis生产一条导入消息, 即保存文件id到redis

5. 请求结束, 返回"处理中"状态

6. redis消费消息

7. 读取cos文件, 异步处理数据

8. 将错误数据以excel形式上传至cos, 以供用户下载, 并更新处理状态为"处理完成"

9. 客户端轮询查询处理状态, 并可以下载错误文件

10. 结束

五、实现效果

1. 上传文件

2. 数据库导入记录

3. 导入的数据

4. 下载错误文件

5. 错误数据提示

6. 查询导入记录

六、代码实现

1. 导入excel控制层

@LoginRequired
    @RequestMapping(value = "doImport", method = RequestMethod.POST)
    public JsonResponse doImport(@RequestParam("file") MultipartFile file, HttpServletRequest request) {
        PLUser user = getUser(request);
        return orderImportService.doImport(file, user.getId());
    }

2、service层

@Override
    public JsonResponse doImport(MultipartFile file, Integer userId) {
        if (null == file || file.isEmpty()) {
            throw new ServiceException("文件不能为空");
        }

        String filename = file.getOriginalFilename();
        if (!checkFileSuffix(filename)) {
            throw new ServiceException("当前仅支持xlsx格式的excel");
        }

        
        String fileId = saveToOss(file);
        if (StringUtils.isBlank(fileId)) {
            throw new ServiceException("文件上传失败, 请稍后重试");
        }

        
        saveRecordToDB(userId, fileId, filename);

        
        redisProducer.produce(RedisKey.orderImportKey, fileId);

        return JsonResponse.ok("导入成功, 处理中...");
    }

    
    private static boolean checkFileSuffix(String fileName) {
        if (StringUtils.isBlank(fileName) || fileName.lastIndexOf(".") <= 0) {
            return false;
        }

        int pointIndex = fileName.lastIndexOf(".");
        String suffix = fileName.substring(pointIndex, fileName.length()).toLowerCase();
        if (".xlsx".equals(suffix)) {
            return true;
        }

        return false;
    }

   
    private String saveToOss(MultipartFile file) {
        InputStream ins = null;
        try {
            ins = file.getInputStream();
        } catch (IOException e) {
            e.printStackTrace();
        }

        String fileId;
        try {
            String originalFilename = file.getOriginalFilename();
            File f = new File(originalFilename);
            inputStreamToFile(ins, f);
            FileSystemResource resource = new FileSystemResource(f);

            MultiValueMap param = new LinkedMultiValueMap<>();
            param.add("file", resource);

            ResponseResult responseResult = restTemplate.postForObject(txOssUploadUrl, param, ResponseResult.class);
            fileId = (String) responseResult.getData();
        } catch (Exception e) {
            fileId = null;
        }

        return fileId;
    }

3、redis生产者

@Service
public class RedisProducerImpl implements RedisProducer {

    @Autowired
    private RedisTemplate redisTemplate;

    @Override
    public JsonResponse produce(String key, String msg) {
        Map map = Maps.newHashMap();
        map.put("fileId", msg);
        redisTemplate.opsForList().leftPush(key, map);
        return JsonResponse.ok();
    }

}

4、redis消费者

@Service
public class RedisConsumer {

    @Autowired
    public RedisTemplate redisTemplate;

    @Value("${txOssFileUrl}")
    private String txOssFileUrl;

    @Value("${txOssUploadUrl}")
    private String txOssUploadUrl;

    @PostConstruct
    public void init() {
        processOrderImport();
    }

    
    private void processOrderImport() {
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(() -> {
            while (true) {
                Object object = redisTemplate.opsForList().rightPop(RedisKey.orderImportKey, 1, TimeUnit.SECONDS);
                if (null == object) {
                    continue;
                }
                String msg = JSON.toJSONString(object);
                executorService.execute(new OrderImportTask(msg, txOssFileUrl, txOssUploadUrl));
            }
        });
    }

}

5、处理任务线程类

public class OrderImportTask implements Runnable {
    public OrderImportTask(String msg, String txOssFileUrl, String txOssUploadUrl) {
        this.msg = msg;
        this.txOssFileUrl = txOssFileUrl;
        this.txOssUploadUrl = txOssUploadUrl;
    }
}

    
    private void autowireBean() {
        this.restTemplate = BeanContext.getApplicationContext().getBean(RestTemplate.class);
        this.transactionTemplate = BeanContext.getApplicationContext().getBean(TransactionTemplate.class);
        this.orderImportService = BeanContext.getApplicationContext().getBean(OrderImportService.class);
    }

    @Override
    public void run() {
        
        autowireBean();

        JSONObject jsonObject = JSON.parseObject(msg);
        String fileId = jsonObject.getString("fileId");

        MultiValueMap param = new LinkedMultiValueMap<>();
        param.add("id", fileId);

        ResponseResult responseResult = restTemplate.postForObject(txOssFileUrl, param, ResponseResult.class);
        String fileUrl = (String) responseResult.getData();
        if (StringUtils.isBlank(fileUrl)) {
            return;
        }

        InputStream inputStream = HttpClientUtil.readFileFromURL(fileUrl);
        List