lyloou

public class Result {

    @JsonProperty("err_code")
    private final int status;

    @JsonProperty("err_msg")
    private String msg;

    @JsonProperty("data")
    private Object data;

    public Result(int status, String msg) {
        this.status = status;
        this.msg = msg;
    }

    public Result data(Object data) {
        this.data = data;
        return this;
    }

    public Result msg(String msg) {
        this.msg = msg;
        return this;
    }

    public Result appendMsg(String msg) {
        return appendMsg(msg, ", ");
    }

    public Result appendMsg(String msg, String sep) {
        if (!Strings.isNullOrEmpty(msg)) {
            this.msg = Joiner.on(sep).join(this.msg, msg);
        } else {
            this.msg = msg;
        }
        return this;
    }

}

/**
 * 处理 Result 的接口，具体实现看 ResultHandlerImpl
 */
public interface ResultHandler {

    /**
     * 只需要返回 code 和 msg
     *
     * @param code 状态码
     * @return 结果
     */
    Result msgResult(StatusCode code);

    /**
     * 正常返回时，才使用这个；
     * 错误的时候，尽量不要用这个，除非前端有作处理。填写不当的 data，有可能会导致解析不对；
     *
     * @param code 错误码
     * @param data 返回给调用者的数据
     * @return 结果
     */
    Result dataResult(StatusCode code, Object data);

}

@Component
public class ResultHandlerImpl implements ResultHandler {

    @Override
    public Result msgResult(StatusCode code) {
        StatusCodeDict status = code.get();
        return new Result(status.code(), status.msg());
    }


    @Override
    public Result dataResult(StatusCode code, Object data) {
        StatusCodeDict status = code.get();
        Result result = new Result(status.code(), status.msg());
        result.data(data);
        return result;
    }

}

/**
 * ResultHandle 用此类作为参数。
 * 通过此接口，可以通过 lambda 的方式来获取 StatusCodeDict 里的信息
 * (<code>resultHandler.msgResult(() -> PARAM_LOGIN_ERROR);</code>)
 */
@FunctionalInterface
public interface StatusCode extends Supplier<StatusCodeDict> {
    @Override
    StatusCodeDict get();
}

/**
 * 错误码字典
 */
public enum StatusCodeDict {


    // 通用码
    COMMON_OK(0, "ok"),
    COMMON_UNKNOWN(9999, "未知的异常"),
    COMMON_INVALID_REQUEST(9998, "无效的请求"),

    // 系统
    SYSTEM_404(404, "404你懂的"),
    SYSTEM_502(502, "服务器打洋了"),
    SYSTEM_500(500, "哎哟，这里有个锅"),

    PARAM(1001, "参数错误"),
    PARAM_BEYOND_QUANTITY_NUMBER(1003, "参数错误，超出最大数量限制"),

    // 登录
    PARAM_LOGIN_ERROR(1102, "用户名不存在或密码错误"),

    // 商品
    GOODS_IS_NOT_EXISTED(1301, "商品不存在"),
    GOODS_IS_NOT_MARKETABLE(1302, "商品已经下架"),

    DB(1401, "数据库异常"),

    UNDEFINED(1999, "未定义的业务异常"),
    ;


    private int code;
    private String msg;
    private static final Map<Integer, StatusCodeDict> dict = new HashMap<>();

    static {
        Arrays.stream(StatusCodeDict.values())
                .forEach(p -> dict.put(p.code, p));
    }

    public static StatusCodeDict of(int code) {
        return Optional.of(dict.get(code)).orElse(COMMON_UNKNOWN);
    }

    StatusCodeDict(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public int code() {
        return code;
    }

    public String msg() {
        return msg;
    }
}

@RestController
@RequestMapping(path = "${apiVersion}/user")
public class UserController {

    @Autowired
    private ResultHandler resultHandler;

    @Autowired
    UserMapper userMapper;

    @PostMapping("login")
    public Result login(
            @RequestParam("name") String name,
            @RequestParam("password") String password
    ) {
        UserPassword userPassword = userMapper.getUserPasswordByNamePassword(name, password);
        if (userPassword == null) {
            return resultHandler.msgResult(() -> PARAM_LOGIN_ERROR);
        }
        User user = userMapper.getUser(userPassword.getUserId());
        return resultHandler.dataResult(() -> COMMON_OK, user);
    }
}

/**
 * ID 生成器
 */
@Component
public class IdGenerator {
    /**
     * 生成器类型
     */
    public enum Type {
        NORMAL(""),
        ORDER("OR"),
        RETURN("RT"),
        REFUND("RF");

        private String prefix;

        Type(String prefix) {
            this.prefix = prefix;
        }
    }

    private static String GENERATOR = "GENERATOR";
    private static String FORMAT = "yyyyMMddHHmmss";

    public String generate(Type type) {
        String now = DateFormatUtils.format(new Date(), FORMAT);
        String key = GENERATOR + ":" + type.name();
        int counter = getCounter(key);
        return String.format("%s%s%s", type.prefix, now, counter);
    }

    @Autowired
    Jedis jedis;

    /**
     * 通过 redis 来获取累加器
     * 根据 key 类型来获取累加数字
     *
     * @param key 类型
     * @return 累加的数字
     */
    private int getCounter(String key) {
        int num;
        String serial = jedis.get(key);
        num = 1000;
        if (serial != null && Integer.parseInt(serial) < 9999) {
            num = jedis.incrBy(key, 1).intValue();
        } else {
            jedis.set(key, String.valueOf(num));
        }
        return num;
    }
}

@RunWith(SpringRunner.class)
@ComponentScan(basePackages = {"com.lyloou.order"})
@SpringBootTest
public class FlowApplicationTests {
  @Autowired
  IdGenerator idGenerator;

  @Test
  public void testGenerator() {
      List<String> ids = Lists.newArrayList();
      for (int i = 0; i < 10; i++) {
          double delay = Math.random() * 1000;
          Thread.sleep((long) delay);
          ids.add(idGenerator.generate(IdGenerator.Type.ORDER));
      }
      System.out.println(Joiner.on(",\n").join(ids));
  }
}

/** 运行结果：
OR202003261127151030,
OR202003261127161031,
OR202003261127171032,
OR202003261127181033,
OR202003261127181034,
OR202003261127191035,
OR202003261127191036,
OR202003261127191037,
OR202003261127201038,
OR202003261127211039
*/

// TimeUtils.java
public class TimeUtils {
    // 1月中的15号，0点整
    public static Timestamp getMonthDay15(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.DAY_OF_MONTH, 15);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        return new Timestamp(calendar.getTimeInMillis());
    }
}

// FeeJob.java
/**
 * 入账任务
 *
 * @author lyloou
 */
public class FeeJob implements Job {

    private final Log logger = Logger.get(FeeJob.class);

    @Override
    public void execute(JobExecutionContext jec) {
        // 1分钟执行一次
        Date date = new Date();
        if (TimeUtils.getMonthDay15(date).getTime() != date.getTime()) {
            return;
        }

        long t1 = System.currentTimeMillis();
        // do your job here
        long spend = System.currentTimeMillis() - t1;
        logger.info(String.format("%s|执行xxx任务，耗时%s：", getClass().getName(), spend));
    }
}

// 向上取整（天花板）
Math.ceil();
// 向下取整（地板）
Math.floor();

/**
* 比较两个数值是否相等
*/
public static boolean isEqual(Object x, Object y) {
    return compareTo(x, y) == 0;
}

/**
* 比较数字大小，x > y返回-1，x = y返回0，x < y返回1
*/
public static int compareTo(Object x, Object y) {
    return new BigDecimal(x + "").compareTo(new BigDecimal(y + ""));
}

public class Main {
    public static void main(String[] args) throws Exception {
        BigDecimal a = divide(1, 7, 2, RoundingMode.HALF_EVEN);
        BigDecimal b = divide(6, 7, 2, RoundingMode.HALF_EVEN);
        System.out.println(a);
        System.out.println(b);
        System.out.println(CalcUtils.add(a, b));

    }

    public static BigDecimal divide(Object x, Object y, int bit, RoundingMode mode) {
        return new BigDecimal(x + "").divide(new BigDecimal(y + ""), bit, mode);
    }
}

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test {

    // http://www.runoob.com/java/java-regular-expressions.html
    @Test
    public void testRegex() {
        String input = "【丝路亚心】250gX4<font color=\"red\">核桃仁</font> 原味生<font color=\"red\">核桃核桃仁</font> 新疆特产, <font color=\"red\">123445</font>bcdef";
        String regex = "<font[^>]+?>(.*?)<\\\\/font>";
        Pattern compile = Pattern.compile(regex);
        Matcher matcher = compile.matcher(input);
        List<String> output = new ArrayList<>();
        int count = 0;
        while (matcher.find()) {
            System.out.println("--" + count);
            output.add(matcher.group(count));
            count++;
        }

        System.out.println(output);
    }

    @Test
    public void testHtml() {

        String html = "<span style=\"color:red;border-radius:10px;background-color:blue;\">抢购</span> 我是标题我是标题我是标题<font color=\"red\">高亮</font>我是标题我是标题我是标题我是标题<font color=\"red\">高亮</font>我是标题";

        Document doc = Jsoup.parse(html);
        System.out.println(doc); // 输出带标签的html文档
        System.out.println("\n---->" + doc.text()); // 输出内容
        System.out.println("\n---->" + doc.getElementsByTag("span").get(0).html());
        System.out.println("\n---->" + doc.getElementsByTag("font").get(0).html());

    }

    @Test
    public void testStyle() {
        String style = "position: absolute; width: 500px; height: 552px; color: red; background-color: blue;";
        String width = "width";
        String color = "color";
        String backgroundColor = "background-color";
        System.out.println(getFloat(style, width));
        System.out.println(getString(style, color));
        System.out.println(getString(style, backgroundColor));
    }

    // https://www.cnblogs.com/qlqwjy/p/7531579.html
    public static double getFloat(String value, String property) {
        try {
            if (value.contains(property)) {
                value = value.substring(value.indexOf(property));
                value = value.substring(0, value.contains(";") ? value.indexOf(";") : value.length());
                String attr = value.substring(value.indexOf(":") + 1).trim();
                return Double.parseDouble(attr.substring(0, attr.indexOf("px")));
            }
        } catch (Exception e) {
            // ignore all exception
        }

        return 0;
    }

    public static String getString(String value, String property) {
        try {
            if (value.contains(property)) {
                System.out.println(value);
                value = value.substring(value.indexOf(property));
                value = value.substring(0, value.contains(";") ? value.indexOf(";") : value.length());
                return value.substring(value.indexOf(":") + 1).trim();
            }
        } catch (Exception e) {
            // ignore all exception
        }

        return "";
    }
}