Java on 哲学家

Web 实现日志文件实时监听

Wed, 09 Jun 2021 00:00:00 +0000

思路

第一个想法，是 java 接收 tail 命令返回，然后通过 websocket 推送给前端。也搜到了有人利用此方法实现了。

但是个人觉得日志数据量较大，此方法效率偏低。巧的是，Apache Commons 包里已经帮忙实现了这个方法。

要注意的是，2.4 之前不支持中文。Commons 包较为常见，一开始我没有考虑版本，拿着 2.4 的包用，结果乱码，且没有相关参数指定编码，一度打算舍弃它。

实现

Apache Commons 包中的 Tailer 类实现了这个，一旦了解了这个类，实现起来就简单了。直接贴代码了。

websocket 入口

import org.apache.commons.io.input.Tailer;
import org.apache.commons.io.input.TailerListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.File;
import java.util.concurrent.atomic.AtomicInteger;


/**
 * websocket
 */
@ServerEndpoint("/websocket/log/{sid}")
@Component
public class WebSocketServerLog {
    private static Logger LOG = LoggerFactory.getLogger(WebSocketServerLog.class);

    private static AtomicInteger onlineCount = new AtomicInteger(0);

    private Tailer tailer;

    //接收sid
    private String sid="";

    /**
     * 连接建立成功调用的方法
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("sid") String sid) {
        addOnlineCount();
        this.sid = sid;

        //tail listen
        TailerListener listener = new MyTailerListener(session);
        tailer = Tailer.create(new File("C:\\Users\\lenovo\\Desktop\\" + sid), listener, 1000, true);

        LOG.info("sid " + sid + " on open and online count " + getOnlineCount());
    }

    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose() {
        subOnlineCount();
        tailer.stop();
        LOG.info("sid " + sid + " on close and online count " + getOnlineCount());
    }

    @OnError
    public void onError(Throwable error) {
        LOG.error("sid {} error: {}", sid, error.getMessage());
    }

    public static int getOnlineCount() {
        return onlineCount.get();
    }

    public static void addOnlineCount() {
        onlineCount.incrementAndGet();
    }

    public static synchronized void subOnlineCount() {
        onlineCount.decrementAndGet();
    }
}

继承 Tailer

import org.apache.commons.io.input.TailerListenerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.websocket.Session;
import java.io.IOException;

/**
 * 继承 TailerListenerAdapter
 */
public class MyTailerListener extends TailerListenerAdapter {

    private static Logger LOG = LoggerFactory.getLogger(MyTailerListener.class);

    private Session session;

    public MyTailerListener(Session session) {
        this.session = session;
    }

    @Override
    public void handle(String line) {
        try {
            LOG.info(line);
            if (session.isOpen()){
                session.getBasicRemote().sendText(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

参考

Java WebSocket + tail命令实现Web实时日志｜叉叉哥的BLOG

后端接口校验参数异常统一处理

Tue, 02 Feb 2021 00:00:00 +0000

2021-06-01 补充：捕捉文件上传大小限制的异常和参数 key 都不传的情况。

前言

工作的项目中，先前的同事其实已经实现了参数校验异常统一处理。部分实现代码如下。

//全局异常处理类
@RestControllerAdvice
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {

    @ExceptionHandler(value = BaseException.class)
    public S2VJSONResult baseHandler(BaseException e) {
        return S2VJSONResult.msg(false, 400, e.getMessage());
    }

//接口
@PostMapping("/transfer/company")
S2VJSONResult transferCompany(@Validated @RequestBody AdminTransferCompanyVO vo,
                              BindingResult bindingResult) {

    if (bindingResult.hasErrors()) {
        return S2VJSONResult.msg(false, 400, bindingResult.getFieldError().getDefaultMessage());
    }

//参数实体类
public class AdminTransferCompanyVO {

    @NotNull(message = "客户 ID 不能为空")
    private List<Integer> companyIds;
    @NotNull(message = "目标客户经理 ID 不能为空")
    private Integer targetCustomerId;
    @NotNull(message = "管理员 ID 不能为空")
    private Integer operationCustomerId;

//统一返回响应
public class S2VJSONResult<T> {

    private Integer code;//状态码
    private Boolean isSuccess;//状态
    private String message;//消息
    private T data;//数据对象

    public static <T> S2VJSONResult<T> all(Boolean success, Integer code,String message,T data) {
        return new S2VJSONResult<>(success, code, message,  data);
    }

    public static <T> S2VJSONResult<T> msg(Boolean success, Integer code,String message) {
        return new S2VJSONResult<>(success, code, message);
    }

整理了一下其思路，大概如下：

利用 @RestControllerAdvice 全局处理异常
Spring MVC 会将验证结果放入 BindResult 中
封装报错信息返回统一错误响应

我个人很懒，感觉有些地方还是重复代码了，不够优雅，比如 BindingResult 每个接口都要加，既然是异常应该就能够捕捉到，为什么不全局处理？验证的 message 每个字段都要写，可否在不写的情况下，返回特定模板的报错信息？

全局处理

要解决我的问题，思路也很清晰，只要知道校验失败具体抛出的是什么异常，获取异常中有用的的报错信息，然后利用 @RestControllerAdvice 全局处理一下就好了。

这里遇到个坑，同事写的全局处理类继承了 ResponseEntityExceptionHandler，而我要特定捕捉的异常都在这里面，所以我一开始的时候，老是报重复处理异常的错误。。。

1. 处理 RequestParam 和 PathVariable 方式

Controller 层代码示例如下，将需要的约束添加到 @RequestParam 注解的前面，此时需要在类上添加注解 @Validated 才能实现验证。

@Controller
@RequestMapping("/report1")
@ResponseBody
@Validated
public class TestController {

    @PostMapping("/test1")
    S2VJSONResult<String> test1(@Max(3) @RequestParam("id") Integer id){
        return S2VJSONResult.all(true, 200, "success", JSON.toJSONString(id));
    }

    @PostMapping("/test2/{id}")
    S2VJSONResult<String> test2(@Max(value = 3, message = "别瞎填！") @PathVariable("id") Integer id){
        return S2VJSONResult.all(true, 200, "success", JSON.toJSONString(id));
    }

这种情况会抛出 ConstraintViolationException 异常。Spring 会处理这种异常并抛出报错信息，

{
    "timestamp": "2021-02-02 11:34:45",
    "status": 500,
    "error": "Internal Server Error",
    "message": "test1.id: 最大不能超过3",
    // "message": "test2.id: 别瞎填！",
    "path": "/pcg/report1/test1"
}

可以看到 message 字段中有较为完整的报错信息，可以直接拿来用。统一异常处理代码如下，

import javax.validation.ConstraintViolationException;
/**
  * 处理 @RequestParam @PathVariable 参数验证失败
  *
  * @param e
  * @return S2VJSONResult<T>
  * @Author zrr
  * @Date 2021/2/2 10:48
  * @throws
  */
@ExceptionHandler(value = ConstraintViolationException.class)
public <T> S2VJSONResult<T> handlerConstraintViolationException(ConstraintViolationException e) {
    return S2VJSONResult.msg(false, 400, "参数验证未通过（" + e.getMessage() + "）");
}

另外，用户也存在参数 key 都不传的情况，这个时候的异常也需要捕捉。

import org.springframework.web.bind.MissingServletRequestParameterException;
    /**
     * 处理 @RequestParam 参数验证失败（整个不传）
     * @param e
     * @param <T>
     * @return
     */
    @ExceptionHandler(value = MissingServletRequestParameterException.class)
    public <T> S2VJSONResult<T> handlerMissingServletRequestParameterException(MissingServletRequestParameterException e) {
        return S2VJSONResult.msg(false, 400, "参数验证未通过（" + e.getMessage() + "）");
    }

封装报错信息，统一返回响应的结果如下，

{
    "code": 400,
    "isSuccess": false,
    // "message": "参数验证未通过（test1.id: 最大不能超过3）",
    "message": "参数验证未通过（test2.id: 别瞎填！）",
    "data": null
}

基本实现了我想要的结果，不需要通过 BindingResult，只需要添加注解就可以校验参数，并且不写 message 也可以返回较为清楚的报错信息。

但是这只是传参的一种情况，其他的情况抛出的异常还不一样，需要再次处理。

2. 处理实体类接收

接口传入很多参数的时候，通常代码会用实体类接收。Controller 层代码示例如下，这种情况无需在类上添加注解 @Validated。

    @PostMapping("/test3")
    S2VJSONResult<String> test3(@Validated ReportVO vo){
        return S2VJSONResult.all(true, 200, "success", JSON.toJSONString(vo));
    }

实体类添加相应的约束，


import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import java.io.Serializable;

public class ReportVO implements Serializable {

    @NotNull
    private Integer cgeId;

    @NotEmpty(message = "baseinfoSqrxm 不能为空")
    private String baseinfoSqrxm;
}

这种情况会抛出 BindException 异常。Spring 仍然会处理这种异常并抛出报错信息，

{
    "timestamp": "2021-02-02 13:58:18",
    "status": 400,
    "error": "Bad Request",
    "errors": [
        {
            "codes": [
                "NotNull.reportVO.cgeId",
                "NotNull.cgeId",
                "NotNull.java.lang.Integer",
                "NotNull"
            ],
            "arguments": [
                {
                    "codes": [
                        "reportVO.cgeId",
                        "cgeId"
                    ],
                    "arguments": null,
                    "defaultMessage": "cgeId",
                    "code": "cgeId"
                }
            ],
            "defaultMessage": "不能为null",
            "objectName": "reportVO",
            "field": "cgeId",
            "rejectedValue": null,
            "bindingFailure": false,
            "code": "NotNull"
        }
    ],
    "message": "Validation failed for object='reportVO'. Error count: 1",
    "path": "/pcg/report1/test3"
}

可以看到 defaultMessage 中有相应的报错信息，但是不够完整，可以将字段名 field 一起拼接后作为报错信息，统一异常处理代码如下，

import org.springframework.validation.BindException;
/**
  * 处理实体校验失败（multipart/form-data、x-www-form-urlencoded）
  *
  * @param e
  * @return S2VJSONResult<T>
  * @Author zrr
  * @Date 2021/2/2 10:50
  * @throws
  */
@ExceptionHandler(value = BindException.class)
public <T> S2VJSONResult<T> handlerBindException(BindException e) {
    FieldError fieldError = e.getBindingResult().getFieldError();
    assert fieldError != null;
    String message = MessageFormat.format("参数 {0} 有误，{1}", fieldError.getField(), fieldError.getDefaultMessage());
    return S2VJSONResult.msg(false, 400, message);
}

其中，e.getBindingResult() 中会有所有的参数报错信息，对我来说感觉一个就够了，所以我只取了一个，统一错误响应后的结果为，

{
    "code": 400,
    "isSuccess": false,
    "message": "参数 baseinfoSqrxm 有误，baseinfoSqrxm 不能为空",
    // "message": "参数 cgeId 有误，不能为null",
    "data": null
}

3. 处理 RequestBody 情况

RequestBody 情况和上面很类似，但抛出的异常不一样，仍然需要单独处理。Controller 层代码示例如下，

@PostMapping("/test4")
S2VJSONResult<String> test4(@Validated @RequestBody ReportVO vo){
    return S2VJSONResult.ok(JSON.toJSONString(vo));
}

这种情况会抛出 MethodArgumentNotValidException 异常。默认报错消息同 BindException，处理方式基本一致。

import org.springframework.web.bind.MethodArgumentNotValidException;
/**
  * 处理 @RequestBody 参数验证失败（application/json）
  *
  * @param e
  * @return S2VJSONResult<T>
  * @Author zrr
  * @Date 2021/2/2 10:49
  * @throws
  */
@ExceptionHandler(value = MethodArgumentNotValidException.class)
public <T> S2VJSONResult<T> handlerMethodArgumentNotValidException(MethodArgumentNotValidException e) {
    FieldError fieldError = e.getBindingResult().getFieldError();
    assert fieldError != null;
    String message = MessageFormat.format("参数 {0} 有误，{1}", fieldError.getField(), fieldError.getDefaultMessage());
    return S2VJSONResult.msg(false, 400, message);
}

这三种情况基本涵盖了传参的所有方式，后面若是有遗漏的情况，也是同样的原理，再加上就好了。

4. 处理集合

参数是集合如 list 的时候，@Validated 失效，但 @Valid 可以支持。

import javax.validation.Valid;

public S2VJSONResult<Object> batchUpdate(@RequestBody List<@Valid ProductModuleVO> list){
    productModuleService.batchUpdate(list);
    return S2VJSONResult.ok();
}

此时，抛出的异常为 ConstraintViolationException，和第 1 种情况相同。

5. 处理文件上传大小异常

可能由于没有继承 ResponseEntityExceptionHandler，若是项目配置了文件上传大小限制，当超出时，系统没有捕捉异常，需要手动捕捉。

spring:
  servlet:
    multipart:
      max-file-size: 10MB

import org.springframework.web.multipart.MaxUploadSizeExceededException;
import org.springframework.beans.factory.annotation.Value;

@Value("${spring.servlet.multipart.max-file-size}")
private String maxFileSize;

/**
    * 处理文件上传大小限制
    *
    * @param e
    * @return com...entity.S2VJSONResult<T>
    * @Author zrr
    * @Date 2021/5/6 11:48
    * @throws
    */
@ExceptionHandler(value = MaxUploadSizeExceededException.class)
public <T> S2VJSONResult<T> handlerMaxUploadSizeExceededException(MaxUploadSizeExceededException e) {
    logger.error("catch MaxUploadSizeExceededException {}", e.getMessage());
    return S2VJSONResult.msg(false, 400, "文件大小超出限制（" + maxFileSize + "）");
}

校验失败立即返回

上述三种默认情况都是校验全部字段后再返回报错信息，可以通过配置实现当一个参数校验有误时立即返回，提高效率。

import org.hibernate.validator.HibernateValidator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;

/**
 * valid
 *
 * @author: zrr
 * @date: 2021/2/1 16:30
 */
@Configuration
public class ValidConfig {
    @Bean
    public Validator validator() {
        ValidatorFactory validatorFactory = Validation.byProvider( HibernateValidator.class)
                .configure()
                .failFast(true)  //立即返回
                .buildValidatorFactory();
        return validatorFactory.getValidator();
    }
}

Validated 验证组

接口通常有新增和更新，它们字段一致但是约束可能不同，若想要利用同一个实体类，可以通过组的方式实现共用。注意 @Valid 不支持组只有 @Validated 可以。

首先新增两个接口组，

1
2
3

import javax.validation.groups.Default;
public interface ValidGroupCreate extends Default {
}

1
2
3

import javax.validation.groups.Default;
public interface ValidGroupUpdate extends Default {
}

这里我继承了 Default.class 默认分组，可以实现参数没有标明组的情况时，也可以使用组。可以减少一些代码量。

实体类添加约束如下：

public class ReportVO implements Serializable {

    @NotNull
    private Integer cgeId;

    @NotEmpty(groups = ValidGroupCreate.class)
    private String baseinfoSqrxm;

    @NotEmpty(groups = ValidGroupUpdate.class)
    private String baseinfoSfzhm;

    @NotEmpty(groups = {ValidGroupCreate.class, ValidGroupUpdate.class})
    private String baseinfoHyzk;

再然后 Controller 层指定组即可，不填的话则是默认分组，

@PostMapping("/test3")
S2VJSONResult<String> test3(@Validated(ValidGroupUpdate.class) ReportVO vo){
    return S2VJSONResult.all(true, 200, "success", JSON.toJSONString(vo));
}

注解用法

在此列举一些常用的校验注解，方便查看。

@NotNull 验证带注释的属性值不为 null。
@AssertTrue 验证带注释的属性值为 true。
@Size 验证带注释的属性值的大小在属性 min 和 max 之间；可以应用于 String， Collection， Map和数组属性。
@Min 验证带注释的属性的值不小于 value 属性。
@Max 验证带注释的属性的值不大于 value 属性。
@Email 验证带注释的属性是有效的电子邮件地址。
@NotEmpty 验证该属性不为 null 或为空；可以应用于 String， Collection， Map或Array值。
@NotBlank 只能应用于文本值，并验证该属性不是null还是空白。
@Positive 和 @PositiveOrZero 适用于数值，并验证它们严格为正，或包括 0 在内为正。
@Negative 和 @NegativeOrZero 适用于数值，并验证它们严格为负数，或为负数（包括0）。
@Past 和 @PastOrPresent 验证日期值是过去还是现在（包括现在）；可以应用于日期类型，包括 Java 8中添加的日期类型。
@Future 和 @FutureOrPresent 验证日期值是将来的日期还是将来的日期（包括现在）。
@Pattern 字段或属性的值必须与 regexp 元素中定义的正则表达式匹配。

后续

可以创建自定义约束，目前项目大多用到就是非空判断，暂时先不弄

参考

Validations in Spring

MapStruct 实现 Java Bean 映射

Fri, 21 Aug 2020 00:00:00 +0000

介绍

项目中遇到数据库返回的字段不想全部返回给前端，一个一个 setter 挺麻烦，不够优雅。市面上有挺多映射框架如 Dozer，Orika，MapStruct，ModelMapper，JMapper 等，其中 MapStruct 只是代码生成器，使用纯 Java 的方法调用源对象和目标对象之间进行映射，并非 Java 反射机制，所以其性能最好。

实现

Maven 依赖

...
<properties>
    <org.mapstruct.version>1.3.1.Final</org.mapstruct.version>
</properties>
...
<dependencies>
    <dependency>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct</artifactId>
        <version>${org.mapstruct.version}</version>
    </dependency>
</dependencies>
...
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <annotationProcessorPaths>
                    <path>
                        <groupId>org.mapstruct</groupId>
                        <artifactId>mapstruct-processor</artifactId>
                        <version>${org.mapstruct.version}</version>
                    </path>
                </annotationProcessorPaths>
            </configuration>
        </plugin>
    </plugins>
</build>
...

如果项目中有用到 lombok 的话，MapStruct 也支持，添加如下即可。

<annotationProcessorPaths>
    <path>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>${lombok.version}</version>
    </path>
</annotationProcessorPaths>

普通调用

MapStruct 定义非常简单，因为它完全基于代码生成。

import org.mapstruct.Mapper;
import org.mapstruct.Mapping;

@Mapper
public interface MapStructConverter {
    MapStructConverter MAPPER = Mappers.getMapper(MapStructConverter.class);
 
    @Mapping(source = "status", target = "orderStatus")
    @Override
    Order convert(SourceOrder sourceOrder);
 
    @Override
    DestinationCode convert(SourceCode sourceCode);
}

调用也很简单。

`1`	`DestinationCode destinationCode = MapStructConverter.MAPPER.convert(sourceCode);`

Spring 注解调用

Spring 项目的话可以如下参数实现依赖注入。

1
2
3

@Mapper(componentModel = "spring")
public interface MapStructConverter {
}

@Autowired 注入调用更方便。

@Autowired
private MapStructConverter mapStructConverter;

DestinationCode destinationCode = mapStructConverter.convert(sourceCode);

尾巴

其实这个问题困扰我很久了，之前一直想着用多态方式实现，没找到解决方法后也就用一个一个 setter 方式实现，现在想来很懒，以后还是多思考，多找找轮子，尽可能少写垃圾代码。

参考：

进一步了解 RabbitMQ 跨语言通讯

Tue, 28 Jul 2020 00:00:00 +0000

进一步了解

开发中遇到了 RabbitMQ 丢失的情况，另外一端一直说是我的 Java 端的问题，无奈做了验证，本文的主要内容也就是这个：如何验证消息发送成功。

配置

pom.xml 文件中添加依赖。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

application.yml 文件中添加配置开启确认。

spring:
  rabbitmq:
    host: 192.168.0.102
    port: 5672
    username: admin
    password: admin
    virtual-host: sl
    publisher-confirm-type: correlated
    publisher-returns: true
    template:
      mandatory: true

重写方法

RabbitTemplate.ConfirmCallback 确认消息是否到达交换机， RabbitTemplate.ReturnCallback 确认消息是否到达队列中。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

@Component
public class CustomRabbitSend implements RabbitTemplate.ConfirmCallback, RabbitTemplate.ReturnCallback {

    private static final Logger LOG = LoggerFactory.getLogger(CustomRabbitSend.class);

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void init(){
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnCallback(this);
    }

    @Override
    public void confirm(CorrelationData correlationData, boolean b, String s) {
        //到达Exchange交换机，会调用此方法
        if (!b) {
            LOG.error("消息发送异常!");
        } else {
            LOG.info("发送者收到确认，correlationData={} ,ack={}, cause={}", correlationData.getId(), b, s);
        }
    }

    @Override
    public void returnedMessage(Message message, int i, String s, String s1, String s2) {
        //没有到达Queue队列中，会调用此方法
        LOG.info("returnedMessage ===> replyCode={} ,replyText={} ,exchange={} ,routingKey={}", i, s, s1, s2);
    }
}

交换机和队列绑定

Exchange 交换机需要通过 routingKey 才能将消息传递到 Queue 队列中（本文只用到 direct 类型，其实无需绑定，fanout、topic 类型才需要）。

import org.springframework.context.annotation.Configuration;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;


@Configuration
public class DirectRabbitConfig {

    //队列
    @Bean
    public Queue customDirectQueue() {
        return new Queue("testQueue");
    }

    //Direct交换机
    @Bean
    public DirectExchange customDirectExchange() {
        return new DirectExchange("testDirectExchange", true, false);
    }

    //将队列和交换机绑定
    @Bean
    public Binding bindingDirect() {
        return BindingBuilder.bind(customDirectQueue()).to(customDirectExchange()).with("testRoutingKey");
    }

}

发送

传递 CorrelationData 类，包含消息唯一标识（AmqpTemplate 类无法传递，之前一直用的这个，死活找不到方法）。


@Component
public class TestScheduled {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Scheduled(fixedDelay = 3000)
    public void errorSpiderRerun(){
        String content = "test rabbit and now " + LocalDateTime.now().toString();
        CorrelationData cId = new CorrelationData("unique key");
        rabbitTemplate.convertAndSend("testDirectExchange", "testRoutingKey", content, cId);
    }
}

接收

用 Message 类接收。目前我用的是 String 传输，可以配置成 JSON 传输更好些。


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class CustomRabbitReceiver {

    private static final Logger LOG = LoggerFactory.getLogger(CustomRabbitReceiver.class);

    @RabbitListener(queues = "testQueue")
    public void listen(Message message) {
        String body = new String(message.getBody());
        LOG.info("receiver from python:" + body);
    }
}

谁的锅

加了验证后，Java 端没有丢失，另一端消息也确实拿掉了，研究可能是多线程的问题，之前用的是 pika，官方说多线程不安全，后续可以改为 rabbitpy 更安全。

关联阅读

Spring 定时任务

Tue, 02 Jun 2020 00:00:00 +0000

介绍

本文主要记录下 cron 表达式的用法，方便下次使用。

配置

程序主入口添加 @SpringBootApplication 和 @EnableScheduling 注解以启动定时任务。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class SchedulingTasksApplication {

	public static void main(String[] args) {
		SpringApplication.run(SchedulingTasksApplication.class);
	}
}

然后方法上添加 @Scheduled 注解就行了。当然类注解 @Component 也必不可少。

@Scheduled(fixedDelay = 5000)
public void reportCurrentTime() {
  System.out.println(new Date());
}

定时调度

fixedDelay

毫秒单位，以上一个调用的完成时间开始计算。

如间隔 3 秒，每个任务耗时 2 秒：

@Scheduled(fixedDelay = 3000)
public void errorSpiderRerun(){
    LocalDateTime localDateTime = LocalDateTime.now();
    System.out.println("start " + localDateTime);
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("end " + LocalDateTime.now());
}

结果如下：

start 2020-06-02T15:49:59.650
end 2020-06-02T15:50:01.651
start 2020-06-02T15:50:04.653
end 2020-06-02T15:50:06.653
start 2020-06-02T15:50:09.654
end 2020-06-02T15:50:11.655
start 2020-06-02T15:50:14.657

fixedRate

需要固定速率，则使用 fixedRate。

如间隔 3 秒，每个任务耗时 2 秒：

@Scheduled(fixedRate = 3000)
public void errorSpiderRerun(){
    LocalDateTime localDateTime = LocalDateTime.now();
    System.out.println("start " + localDateTime);
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("end " + LocalDateTime.now());
}

结果如下：

start 2020-06-02T15:58:03.563
end 2020-06-02T15:58:05.563
start 2020-06-02T15:58:06.563
end 2020-06-02T15:58:08.563
start 2020-06-02T15:58:09.563
end 2020-06-02T15:58:11.563
start 2020-06-02T15:58:12.563
end 2020-06-02T15:58:14.563

但是若上个任务耗时超过间隔，则下一次也需要在等待，等到结束后下一次立刻执行。

如等待 7 秒后结果如下：

start 2020-06-02T16:02:37.726
end 2020-06-02T16:02:44.727
start 2020-06-02T16:02:44.727
end 2020-06-02T16:02:51.727
start 2020-06-02T16:02:51.727
end 2020-06-02T16:02:58.727
start 2020-06-02T16:02:58.727
end 2020-06-02T16:03:05.728
start 2020-06-02T16:03:05.728

initialDelay

默认项目启动立即执行定时任务，若想要延迟，使用 initialDelay 参数。

`1`	`@Scheduled(initialDelay = 10000, fixedRate = 3000)`

结果如下：

1
2
3

2020-06-02 16:09:00.487 [main] INFO  LabelApplication - Started LabelApplication in 4.901 seconds (JVM running for 5.689)  
start 2020-06-02T16:09:10.467
end 2020-06-02T16:09:15.468

cron 表达式

用法太多了，每次项目用到就记一下吧。

表达式	描述
1 2 3 * * ? *	每天 3 点 2 分 1 秒执行
1 2 3 L * ? *	每月最后一天 3 点 2 分 1 秒执行
1 2 3 4 * ? *	每月 4 号 3 点 2 分 1 秒执行
0 0 12 ? * WED	每周三执行

RabbitMQ 实现跨语言通信

Fri, 15 May 2020 00:00:00 +0000

需求场景

做项目时遇到需要 Java 和 Python 通信的场景，摸索到了三种解决方案，并都正式在项目中实施过、踩坑过、改进过、整个推翻替换过。

其中 RabbitMQ 是我最终的方案，所以会重点阐述，其中略带提一下。

三种方式的实现

1. 直接调用

有 ProcessBuilder 和 Runtime.exec() 两种方法，用法差不多，都可以传一个字符串数组。

1
2

String[] command = new String[]{"python", "C:\\Users\\lenovo\\Desktop\\java2python.py"};
proc = Runtime.getRuntime().exec(command);// 执行py文件

ProcessBuilder 可以是列表，官方推荐 ProcessBuilder。

List<String> command = new ArrayList<>();
command.add("python");
command.add("C:\\Users\\lenovo\\Desktop\\java2python.py");
ProcessBuilder pb = new ProcessBuilder(command);
proc = pb.start();

Process 提供 InputStream 和 ErrorStream 接收返回结果；为方便起见，可以将错误流重定向到输入流。

1
2

pb.redirectErrorStream(true);//错误流重定向
BufferedReader in = new BufferedReader(new InputStreamReader(proc.getInputStream()));

若需要立即获取其返回结果，需要用 waitFor() 方法。

1
2

//导致当前线程等待，如有必要，直到由此Process对象表示的进程已终止
code = proc.waitFor();

坑不坑：

Java 自带，开发方便（这个很重要……老板就给你两天时间你能怎么办）。
作为一个进程开启，效率低，好在是官方类，使用时感觉控制的还行。
返回结果难以接收。可以通过输入流或者写入文件读取，但是都很不好。
目前只尝试了 Java 调用 Python，反过来感觉很难。

完整代码如下：

@Test
public void java2pythonTest(){
  int code = 1;
  Process proc;
  try {
    // Runtime.getRuntime()
//			String[] command = new String[]{"python", "C:\\Users\\lenovo\\Desktop\\java2python.py"};
//      proc = Runtime.getRuntime().exec(command);// 执行py文件

    List<String> command = new ArrayList<>();
    command.add("python");
    command.add("C:\\Users\\lenovo\\Desktop\\java2python.py");
    ProcessBuilder pb = new ProcessBuilder(command);
    pb.redirectErrorStream(true);//错误流重定向
    proc = pb.start();

    //用输入输出流来截取结果
    BufferedReader in = new BufferedReader(new InputStreamReader(proc.getInputStream(), "gbk"));
    String line = null;
    while ((line = in.readLine()) != null) {
      System.out.println("python> " + line);
    }
    in.close();

    //导致当前线程等待，如有必要，直到由此Process对象表示的进程已终止
    code = proc.waitFor();
    System.out.println("python> wait for code: " + code);

  } catch (IOException e) {
    e.printStackTrace();
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
}

2. 通过 API 通信

两端都启动为一个 Web 项目，Java 端可以采用 Spring Boot 框架，Python 端用 Flask 框架。然后通过 Spring Cloud 来连接。

由于 Spring Cloud 非本人搭建，就不讲了。当然，你也没必要非要使用。

坑不坑：

两端通信频繁的情况下，相对于第一种方案更好些
开发有点烦，尤其是数据传输，如果用 Spring Cloud 会好些
不适用于等待的情况，如 Python 端计算量大，没法立刻给出结果。Api 嘛，时间长肯定不太好

3. RabbitMQ 消息队列

因为实际公司开发中，Python 端计算量很大，需要等待很久，所以方法二也不太适用，后面有同事提出用消息队列的方式，可以不必等待，正好满足我的情况。

RabbitMQ 不仅要有接收端、发送端，还需要安装管理器。

管理系统

管理系统各平台都有，也有 docker 镜像。具体不赘述，看官网就行了。

安装后会有 Web 端图形界面，使用很方便，不需要命令行就可以完成。

大概介绍下用到的一些概念，后续深入的话再补充。

Virtual Hosts

相当于 Mysql 的库，相互独立，exchange、queue、message 不能互通。需要账户管理员权限。Web 端操作如下。

Queue

队列，基本通信模块，相当于一个消息缓冲区，消息进到队列里，再被发送出去。

Exchange

生产者发送消息时由 Exchange 来决定要给哪个 Queue。具体有 Direct、Fanout、Topic、Headers 四种类型，我用默认的一对一也就没有仔细了解。

Java 端实现

配置

我采用 Spring Boot 框架，自带 Spring AMQP 兼容 RabbitMQ，很方便推荐使用。直接在 yml 文件中配置相关参数。

spring:
  rabbitmq:
    host: 192.168.0.102
    port: 5672
    username: admin
    password: admin
    virtual-host: test

发送消息

AmqpTemplate 类用于发送消息，我写了个定时 3 秒发送时间：

@Component
public class TestScheduled {

    //rabbitMQ Queue
    public static final String PYTHON2JAVA = "python2java";
    public static final String JAVA2PYTHON = "java2python";

    @Autowired
    private AmqpTemplate rabbitTemplate;

    @Scheduled(fixedDelay = 3000)
    public void errorSpiderRerun(){
        String now = LocalDateTime.now().toString();
        String content = "java2python and now " + now;
        System.out.println(content);
        rabbitTemplate.convertAndSend(JAVA2PYTHON, content);
    }
}

如果没有客户端接收的话，会一直在队列中，Web 页面下可以看到：

接收消息

接收消息也非常简单，只需要添加 @RabbitListener 注解即可。

@RabbitListener(queues = PYTHON2JAVA)
public void listen(String message) {
    System.out.println(message);
}

Python 端实现

Python 端需要安装第三方库 pika。

建立连接

def get_connect():
    """
    连接
    :return: 
    """
    config_pika_username = "admin"
    cofig_pika_password = "admin"
    config_pika_host = "192.168.0.102"
    config_pika_port = 5672
    config_pika_virtual_host = "test"
    cred = pika.PlainCredentials(config_pika_username, cofig_pika_password)
    connection = pika.BlockingConnection(
        pika.ConnectionParameters(
            host=config_pika_host,
            port=config_pika_port,
            virtual_host=config_pika_virtual_host,
            credentials=cred,
            heartbeat=0
        ))
    return connection

定义回调函数

1
2

def callback(ch, method, properties, body):
    print(body)

等待接收

运行此方法，等待接收。

def build():
    """
    start_consuming
    :return: 
    """
    channel = get_connect().channel()
    channel.queue_declare(queue='java2python', durable=True)
    channel.basic_consume(queue='java2python',
                          auto_ack=True,
                          on_message_callback=callback)
    print(' consumer_start')
    channel.start_consuming()

if __name__ == '__main__':
    build()

发送消息

def producer():
    '''
    生产者
    :param rabbit_body: 发送内容
    '''
    # 创建通道
    connection = get_connect()
    channel = connection.channel()
    channel.queue_declare(queue='python2java', durable=True)

    # 发送内容
    message = "python2java and now " + str(datetime.now())
    print(message)
    channel.basic_publish(exchange='', routing_key='python2java', body=message)

坑不坑：

非长连接方式，效率相对接口方式更高。
如果项目所用框架如 Spring Boot 已经集成的话，开发会很方便。
有担心长时间没有消息队列会断开连接的情况，也有遇到，但好像都已解决。

后续

只是简单介绍用到的类和方法，流于表面，后续如果频繁使用的话，需要深入了解。

SpringMVC 下载文本实现边转码边下载

Wed, 04 Mar 2020 00:00:00 +0000

边转码边下载

下载通常都会遇到这种情况，代码里通常保存为 utf-8 格式，但是用户想要 gbk 格式，实现思路如下：

方案一： PrintWriter + CharacterEncoding

SpringMVC 框架的接口中 Response 有 ServletOutputStream 和 PrintWriter 两种输出，还有一个 setCharacterEncoding 方法。

OutPutStream 视为写入二进制数据，容器不对二进制数据进行编码，即 setCharacterEncoding 无效。所以先采用 PrintWriter 搭配 setCharacterEncoding 方法。

@GetMapping("/downloadFile1")
public void downloadFile1(HttpServletResponse response) throws IOException{

    //读取本地文件
    File file = new File(LOCAL_FILE_PATH);
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(file), "UTF-8"));

    //设置下载
    response.setHeader("Content-Disposition", "attachment;filename=file.csv");
    response.setContentType("application/octet-stream");
    response.setCharacterEncoding("GB2312");

    //传输
    BufferedWriter bufferedWriter = new BufferedWriter(response.getWriter());
    String line;
    while ((line = bufferedReader.readLine()) != null) {
        bufferedWriter.write(line + "\r\n");
        bufferedWriter.flush();
    }
    bufferedReader.close();
    bufferedWriter.close();

}

无用，没有仔细研究，应该 setCharacterEncoding 只是告诉浏览器是什么编码，没有解码功能。

方案二：ServletOutputStream + OutputStreamWriter

将 response.getOutputStream() 获取到的流用 OutputStreamWriter 包装。结果可行。

@GetMapping("/downloadFile2")
public void downloadFile2(HttpServletResponse response) throws IOException{

    //读取本地文件
    File file = new File(LOCAL_FILE_PATH);
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(file), "UTF-8"));

    //设置下载
    response.setHeader("Content-Disposition", "attachment;filename=file.csv");
    response.setContentType("application/octet-stream");

    //传输
    OutputStreamWriter writerStream = new OutputStreamWriter(response.getOutputStream(),"GBK");
    String line;
    while ((line = bufferedReader.readLine()) != null) {
        writerStream.write(line + "\r\n");
        writerStream.flush();
    }
    bufferedReader.close();
    writerStream.close();

}

方案三：ServletOutputStream + getBytes

在按行写入字符串时，使用 getBytes 方法将字符串转换为想要输出的编码格式。结果可行。

@GetMapping("/downloadFile3")
public void downloadFile3(HttpServletResponse response) throws IOException{

    //读取本地文件
    File file = new File(LOCAL_FILE_PATH);
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(file), "UTF-8"));

    //设置下载
    response.setHeader("Content-Disposition", "attachment;filename=file.csv");
    response.setContentType("application/octet-stream");

    //传输
    OutputStream outputStream = response.getOutputStream();
    String line;
    while ((line = bufferedReader.readLine()) != null) {
        outputStream.write((line + "\r\n").getBytes("GB2312"));
        outputStream.flush();
    }
    bufferedReader.close();
    outputStream.close();
}

无需转换的写法

若不需要转码的话，就很简短了，用字节流就行了。

@GetMapping("/downloadFile4")
public void downloadFile4(HttpServletResponse response) throws IOException{

    //读取本地文件
    File file = new File(LOCAL_FILE_PATH);
    FileInputStream fis = new FileInputStream(file);

    //设置下载
    response.setHeader("Content-Disposition", "attachment;filename=file.csv");
    response.setContentType("application/octet-stream");

    //传输
    OutputStream os = response.getOutputStream();
    byte[] buffer = new byte[4096];
    int b = -1;
    while ((b = fis.read(buffer)) != -1) {
        os.write(buffer, 0, b);
    }
    fis.close();
    os.close();
}

简写的话可以用第三方包。

import org.springframework.util.FileCopyUtils;
@GetMapping("/downloadFile5")
public void downloadFile5(HttpServletResponse response) throws IOException{

    //读取本地文件
    File file = new File(LOCAL_FILE_PATH);
    InputStream inputStream= new BufferedInputStream(new FileInputStream(file));

    //设置下载
    response.setHeader("Content-Disposition", "attachment;filename=file.csv");
    response.setContentType("application/octet-stream");

    //传输
    FileCopyUtils.copy(inputStream, response.getOutputStream());


}

多文件打包下载

当需要下载多个文件时，可以将其打包成一个文件，然后下载。Java 自带的 ZipOutputStream 可以实现。

import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

@Override
public void download(OutputStream outputStream) throws IOException {

    // Create the ZIP file
    ZipOutputStream zipOut = new ZipOutputStream(outputStream);

    // image demo
    Map<String, String> imageMap = new HashMap<>;

    //add file to zip
    ZipEntry zipEntry;
    for (String imageName : imageMap.keySet()) {
        // http://192.168.0.102:13080/pcg/files/image/64280347-afa8-4057-8941-ccbaeebf3c4b
        File fileToZip = new File(StaticProperty.IMAGE_PATH, imageMap.get(imageName));

        try (FileInputStream fis = new FileInputStream(fileToZip)) {
            zipEntry = new ZipEntry(imageName);

            zipOut.putNextEntry(zipEntry);

            byte[] bytes = new byte[1024];
            int length;
            while((length = fis.read(bytes)) >= 0) {
                zipOut.write(bytes, 0, length);
            }

        }catch (FileNotFoundException fnfe){
            LOG.warn("file {} not found", imageMap.get(imageName));
        }

        zipOut.closeEntry();
    }

    zipOut.flush();
    zipOut.close();

补充：

使用 Nginx 可以不通过接口前端直接下载，后续可以尝试采用此方法。