Java封装了一个自适应的单位转换工具类

目录

前言

1、前期准备

2、实现代码

2.1 方法一:通过map去标记需要转换的 类属性字段

2.2 方法二:配合自定义注解


前言

平时在做项目中,经常会做一些数据书籍,尤其像是数据看板之类,需要从数据库中查询想要的数据,但这些数据的单位往往与需求是不匹配的。

比如,数据库中查询的金额是元,但页面上需要展示万元;

亦或是,数据库中查出的距离是米,业务需要的是千米;

又比如,需要将查出的数据除以100,返回前端做百分比展示。等等。。。。。。

那像这种情况,我们是怎么处理的呢?

很多时候我们拿到的是一个数据集合list,然后去遍历集合获取每个参数,再根据参数的属性去做相关的单位转换处理。然后一直重复做着get set,get set,get set。

像这样:

虽然这种写法不会报错,但是看着重复的get set方法,着实是有点孬。所以就封装了一个单位转换的工具类,请看正文。


1、前期准备

  • 接收数据的实体类:
import lombok.Data;

import java.io.Serializable;
import java.math.BigDecimal;

/**
 * 单位转换Vo
 */
@Data
public class UnitConvertVo implements Serializable {

    private static final long serialVersionUID = 4784820539438132009L;

    /*** 日销售额(千元)*/
    private BigDecimal dailySales;

    /*** 年销售额(万元)*/
    private BigDecimal annualSales;

    /*** 营收占比(百分比)*/
    private BigDecimal percentage;

    /*** 营收占比(千分比)*/
    private BigDecimal perMillage;

    /*** 距离*/
    private BigDecimal distance;

    /*** 重量*/
    private BigDecimal weight;

}
  • 定义单位类型枚举类

/**
 * 单位转换枚举
 */
public enum UnitEnum {

    /*** 千元*/
    THOUSAND_YUAN("1", "千元"),
    /*** 万元*/
    TEN_THOUSAND_YUAN("2", "万元"),
    /*** 百分比*/
    PERCENTAGE("3", "百分比"),
    /*** 千分比*/
    PER_MILLAGE("4", "千分比"),
    /*** 米*/
    METER("5", "米"),
    /*** 千米*/
    KILOMETRE("6", "千米"),
    /*** 千克*/
    KILOGRAM("8", "千克"),
    /*** 吨*/
    TON("9", "吨");

    private final String code;

    private final String name;

    UnitEnum(String code, String name) {
        this.code = code;
        this.name = name;
    }

    public String getCode() {
        return code;
    }

    public String getName() {
        return name;
    }
}

2、实现代码

提供两种方法实现:

2.1 方法一:通过map去标记需要转换的 类属性字段

思路

1.通过反射取出字段
2.配合传入的转换标记Map,匹配哪些字段需要转换
3.然后从Map中取出相关字段的具体操作有哪些,然后执行转换
4.重新赋值

核心工具类:

import com.test.java.base.UnitEnum;
import lombok.extern.slf4j.Slf4j;

import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.List;
import java.util.Map;

/**
 * 单位转换工具类
 */
@Slf4j
public class UnitConvertUtil {

    /**
     * 方法一:通过反射,获取标识map进行转换
     */
    public static <T> void unitMapConvert(List<T> list, Map<String, UnitEnum> propertyMap) {
        for (T t : list) {
            Field[] declaredFields = t.getClass().getDeclaredFields();
            for (Field declaredField : declaredFields) {
                // 匹配map里的字段属性和转换操作
                if (propertyMap.keySet().stream().anyMatch(x -> x.equals(declaredField.getName()))) {
                    try {
                        declaredField.setAccessible(true);
                        Object object = declaredField.get(t);
                        UnitEnum unitEnum = propertyMap.get(declaredField.getName());
                        if (object != null) {// 若匹配上,则执行对应的转换操作(加减乘除)
                            // 元 → 千元
                            if (unitEnum.equals(UnitEnum.THOUSAND_YUAN)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("1000"), 2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 元 → 万元
                            if (unitEnum.equals(UnitEnum.TEN_THOUSAND_YUAN)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("10000"), 2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 百分比
                            if (unitEnum.equals(UnitEnum.PERCENTAGE)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("100")).setScale(2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 千分比
                            if (unitEnum.equals(UnitEnum.PER_MILLAGE)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("1000")).setScale(2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 千米 → 米
                            if (unitEnum.equals(UnitEnum.METER)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("1000")).setScale(2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 米 → 千米
                            if (unitEnum.equals(UnitEnum.KILOMETRE)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("1000"), 2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 吨 → 千克
                            if (unitEnum.equals(UnitEnum.KILOGRAM)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("1000")).setScale(2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 千克 → 吨
                            if (unitEnum.equals(UnitEnum.TON)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("1000"), 2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                        }
                    } catch (Exception e) {
                        log.error("单位转换失败,{}", e.getMessage());
                    }
                }
            }
        }
    }


}

写个测试main方法:

    public static void main(String[] args) {

        // 创建测试数据
        UnitConvertVo vo = new UnitConvertVo();
        vo.setDailySales(new BigDecimal("23600.53"));
        vo.setAnnualSales(new BigDecimal("368624.24"));
        vo.setPercentage(new BigDecimal("0.2361"));
        vo.setPerMillage(new BigDecimal("0.536285"));
        vo.setDistance(new BigDecimal("8568.54"));// 米 → 千米
        vo.setWeight(new BigDecimal("35.62638"));// 吨 → 千克

        List<UnitConvertVo> list1 = new ArrayList<>();
        list1.add(vo);

        // 测试方法一:
        Map<String, UnitEnum> map = new HashMap<>();
        map.put("dailySales", UnitEnum.THOUSAND_YUAN);
        map.put("annualSales", UnitEnum.TEN_THOUSAND_YUAN);
        map.put("percentage", UnitEnum.PERCENTAGE);
        map.put("perMillage", UnitEnum.PER_MILLAGE);
        map.put("distance", UnitEnum.KILOMETRE);
        map.put("weight", UnitEnum.KILOGRAM);
        System.out.println("转换前:" + list1);
        unitMapConvert(list1, map);
        System.out.println("通过map标识转换:" + list1);

    }

转换结果:

2.2 方法二:配合自定义注解

其实第一种方法已经够用了,但是为了调用更加的方便,后期能够更好的拓展,所以配合着自定义注解,优化了一下,直接上代码:

  • 定义自定义注解
package com.test.java.annotation;

import com.test.java.base.UnitEnum;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 单位转换 自定义注解
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface UnitConvert {

    UnitEnum name();

}
  • 在实体类上,使用自定义注解

import com.test.java.annotation.UnitConvert;
import com.test.java.base.UnitEnum;
import lombok.Data;

import java.io.Serializable;
import java.math.BigDecimal;

/**
 * 单位转换Vo
 */
@Data
public class UnitConvertVo implements Serializable {

    private static final long serialVersionUID = 4784820539438132009L;

    /*** 日销售额(千元)*/
    @UnitConvert(name = UnitEnum.THOUSAND_YUAN)
    private BigDecimal dailySales;

    /*** 年销售额(万元)*/
    @UnitConvert(name = UnitEnum.TEN_THOUSAND_YUAN)
    private BigDecimal annualSales;

    /*** 营收占比(百分比)*/
    @UnitConvert(name = UnitEnum.PERCENTAGE)
    private BigDecimal percentage;

    /*** 营收占比(千分比)*/
    @UnitConvert(name = UnitEnum.PER_MILLAGE)
    private BigDecimal perMillage;

    /*** 距离*/
    @UnitConvert(name = UnitEnum.METER)
    private BigDecimal distance;

    /*** 重量*/
    @UnitConvert(name = UnitEnum.TON)
    private BigDecimal weight;

}

配合自定义注解,在刚刚的工具类里又封装了一个方法,反射获取属性字段,解析注解,做对应转换操作。

import com.test.java.annotation.UnitConvert;
import com.test.java.base.UnitEnum;
import com.test.java.domain.vo.UnitConvertVo;
import lombok.extern.slf4j.Slf4j;

import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;

/**
 * 单位转换工具类
 */
@Slf4j
public class UnitConvertUtil {

    /**
     * 方法一:通过反射,获取标识map进行转换
     */
    public static <T> void unitMapConvert(List<T> list, Map<String, UnitEnum> propertyMap) {
        for (T t : list) {
            Field[] declaredFields = t.getClass().getDeclaredFields();
            for (Field declaredField : declaredFields) {
                // 匹配map里的字段属性和转换操作
                if (propertyMap.keySet().stream().anyMatch(x -> x.equals(declaredField.getName()))) {
                    try {
                        declaredField.setAccessible(true);
                        Object object = declaredField.get(t);
                        UnitEnum unitEnum = propertyMap.get(declaredField.getName());
                        if (object != null) {// 若匹配上,则执行对应的转换操作(加减乘除)
                            // 元 → 千元
                            if (unitEnum.equals(UnitEnum.THOUSAND_YUAN)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("1000"), 2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 元 → 万元
                            if (unitEnum.equals(UnitEnum.TEN_THOUSAND_YUAN)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("10000"), 2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 百分比
                            if (unitEnum.equals(UnitEnum.PERCENTAGE)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("100")).setScale(2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 千分比
                            if (unitEnum.equals(UnitEnum.PER_MILLAGE)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("1000")).setScale(2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 千米 → 米
                            if (unitEnum.equals(UnitEnum.METER)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("1000")).setScale(2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 米 → 千米
                            if (unitEnum.equals(UnitEnum.KILOMETRE)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("1000"), 2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 吨 → 千克
                            if (unitEnum.equals(UnitEnum.KILOGRAM)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("1000")).setScale(2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                            // 千克 → 吨
                            if (unitEnum.equals(UnitEnum.TON)) {
                                BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("1000"), 2, RoundingMode.HALF_UP);
                                declaredField.set(t, bigDecimal);
                            }
                        }
                    } catch (Exception e) {
                        log.error("单位转换失败,{}", e.getMessage());
                    }
                }
            }
        }
    }

    /**
     * 方法二:通过自定义注解 进行转换
     */
    public static <T> void unitAnnotationConvert(List<T> list) {
        for (T t : list) {
            // 获取属性字段
            Field[] declaredFields = t.getClass().getDeclaredFields();
            for (Field declaredField : declaredFields) {
                try {
                    if ("serialVersionUID".equals(declaredField.getName())) {
                        continue;
                    }
                    // 取出字段上的自定义注解
                    UnitConvert myFieldAnn = declaredField.getAnnotation(UnitConvert.class);
                    if (Objects.isNull(myFieldAnn)) {
                        continue;
                    }
                    // 取出注解里面的转换类型枚举
                    UnitEnum unitEnum = myFieldAnn.name();
                    // 赋予超级权限
                    declaredField.setAccessible(true);
                    Object object = declaredField.get(t);
                    if (Objects.nonNull(object)) {// 执行对应的转换操作(加减乘除)
                        // 元 → 千元
                        if (unitEnum.equals(UnitEnum.THOUSAND_YUAN)) {
                            BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("1000"), 2, RoundingMode.HALF_UP);
                            declaredField.set(t, bigDecimal);
                        }
                        // 元 → 万元
                        if (unitEnum.equals(UnitEnum.TEN_THOUSAND_YUAN)) {
                            BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("10000"), 2, RoundingMode.HALF_UP);
                            declaredField.set(t, bigDecimal);
                        }
                        // 百分比
                        if (unitEnum.equals(UnitEnum.PERCENTAGE)) {
                            BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("100")).setScale(2, RoundingMode.HALF_UP);
                            declaredField.set(t, bigDecimal);
                        }
                        // 千分比
                        if (unitEnum.equals(UnitEnum.PER_MILLAGE)) {
                            BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("1000")).setScale(2, RoundingMode.HALF_UP);
                            declaredField.set(t, bigDecimal);
                        }
                        // 千米 → 米
                        if (unitEnum.equals(UnitEnum.METER)) {
                            BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("1000")).setScale(2, RoundingMode.HALF_UP);
                            declaredField.set(t, bigDecimal);
                        }
                        // 米 → 千米
                        if (unitEnum.equals(UnitEnum.KILOMETRE)) {
                            BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("1000"), 2, RoundingMode.HALF_UP);
                            declaredField.set(t, bigDecimal);
                        }
                        // 吨 → 千克
                        if (unitEnum.equals(UnitEnum.KILOGRAM)) {
                            BigDecimal bigDecimal = ((BigDecimal) object).multiply(new BigDecimal("1000")).setScale(2, RoundingMode.HALF_UP);
                            declaredField.set(t, bigDecimal);
                        }
                        // 千克 → 吨
                        if (unitEnum.equals(UnitEnum.TON)) {
                            BigDecimal bigDecimal = ((BigDecimal) object).divide(new BigDecimal("1000"), 2, RoundingMode.HALF_UP);
                            declaredField.set(t, bigDecimal);
                        }
                    }
                } catch (Exception e) {
                    log.error("单位转换失败,{}", e.getMessage());
                }
            }
        }
    }

    public static void main(String[] args) {

        // 创建测试数据
        UnitConvertVo vo = new UnitConvertVo();
        vo.setDailySales(new BigDecimal("23600.53"));
        vo.setAnnualSales(new BigDecimal("368624.24"));
        vo.setPercentage(new BigDecimal("0.2361"));
        vo.setPerMillage(new BigDecimal("0.536285"));
        vo.setDistance(new BigDecimal("8568.54"));// 米 → 千米
        vo.setWeight(new BigDecimal("35.62638"));// 吨 → 千克

        UnitConvertVo vo1 = new UnitConvertVo();
        vo1.setDailySales(new BigDecimal("23600.53"));
        vo1.setAnnualSales(new BigDecimal("368624.24"));
        vo1.setPercentage(new BigDecimal("0.2361"));
        vo1.setPerMillage(new BigDecimal("0.536285"));
        vo1.setDistance(new BigDecimal("8.56854"));// 千米 → 米
        vo1.setWeight(new BigDecimal("35626.38"));// 千克 → 吨

        List<UnitConvertVo> list1 = new ArrayList<>();
        List<UnitConvertVo> list2 = new ArrayList<>();
        list1.add(vo);
        list2.add(vo1);

        // 测试方法一:
        Map<String, UnitEnum> map = new HashMap<>();
        map.put("dailySales", UnitEnum.THOUSAND_YUAN);
        map.put("annualSales", UnitEnum.TEN_THOUSAND_YUAN);
        map.put("percentage", UnitEnum.PERCENTAGE);
        map.put("perMillage", UnitEnum.PER_MILLAGE);
        map.put("distance", UnitEnum.KILOMETRE);
        map.put("weight", UnitEnum.KILOGRAM);
        System.out.println("转换前:" + list1);
        unitMapConvert(list1, map);
        System.out.println("通过map标识转换:" + list1);

        // 测试方法二:
        System.out.println("转换前:" + list2);
        unitAnnotationConvert(list2);
        System.out.println("通过注解标识转换:" + list2);
    }

}

结果:

两种方法都正确的转换了单位,不过我个人推荐第二种方法,方便后期维护。

如果这篇文章对您有所帮助,或者有所启发的话,求一键三连:点赞、评论、收藏➕关注,您的支持是我坚持写作最大的动力。  

  • 10
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Javaの甘乃迪

感谢看客老爷的打赏

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值