notify event事件回调通知方法-Map通用类型转换方法

notify event事件回调通知方法-Map通用类型转换方法

接上篇：
notify event事件回调通知方法模板代码
https://www.cnblogs.com/oktokeep/p/19490717

1.使用该方法会报错，因为Map中接收到的都是字符串类型

/**
     * map 转对象
     * @param eventData
     * @param clazz
     * @param <T>
     * @return
     */
    private <T> T convertMapToRequest(Map<String, Object> eventData, Class<T> clazz) {
        try {
            //数据类型不一致，需处理
            ObjectMapper objectMapper = new ObjectMapper();
            return objectMapper.convertValue(eventData, clazz);
        } catch (Exception e) {
            throw new RuntimeException("Failed to convert map to " + clazz.getSimpleName(), e);
        }
    }

2.以下是改造后的测试方法：

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;

/**
 * output：CancelledOrderRequest{distributorOrderId='20231224123456789', msgId='20231224123456789', orderId=123456789, sign='20231224123456789', orderStatus='cancelled', cancelType=1, reason='reason', amount=0.01}
 */
public class TestMap {
    public static void main(String[] args) {
        //jdk9支持
//        Map<String, Object> eventData = Map.of(
//                "distributorOrderId", "20231224123456789",
//                "msgId", "20231224123456789",
//                "orderId", 123456789L,
//                "sign", "20231224123456789",
//                "orderStatus", "cancelled",
//                "cancelType", 1,
//                "reason", "reason",
//                "amount", new BigDecimal("0.01")
//        );

        // 使用 HashMap 替代
        Map<String, Object> eventData = new HashMap<>();
        eventData.put("distributorOrderId", "20231224123456789");
        eventData.put("msgId", "20231224123456789");
        eventData.put("orderId", "123456789");
        eventData.put("sign", "20231224123456789");
        eventData.put("orderStatus", "cancelled");
        eventData.put("cancelType", "1");
        eventData.put("reason", "reason");
        eventData.put("amount", "0.01");


        CancelledOrderRequest request = convertMapToRequest(eventData, CancelledOrderRequest.class);
        System.out.println(request.toString());
    }

    /**
     * 将String类型的Map转换为指定对象，自动处理类型转换
     * @param eventData 源Map，所有值都是String类型
     * @param clazz 目标对象类型
     * @param <T> 目标对象泛型
     * @return 转换后的对象
     */
    private static <T> T convertMapToRequest(Map<String, Object> eventData, Class<T> clazz) {
        try {
            T instance = clazz.newInstance();

            // 遍历目标类的所有字段，进行类型转换和赋值
            for (java.lang.reflect.Field field : clazz.getDeclaredFields()) {
                if (!field.isAccessible()) {
                    field.setAccessible(true);
                }

                String fieldName = field.getName();
                if (eventData.containsKey(fieldName)) {
                    Object value = eventData.get(fieldName);

                    if (value != null) {
                        Object convertedValue = convertValueToFieldType(value, field.getType());
                        field.set(instance, convertedValue);
                    }
                }
            }

            return instance;
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("Failed to convert map to " + clazz.getSimpleName(), e);
        }
    }

    /**
     * 将Object值转换为目标字段类型
     * @param value 源值
     * @param targetType 目标类型
     * @return 转换后的值
     */
    private static Object convertValueToFieldType(Object value, Class<?> targetType) {
        if (value == null) {
            return null;
        }

        String stringValue = String.valueOf(value);

        // 处理基本数据类型
        if (targetType == String.class) {
            return stringValue;
        } else if (targetType == Integer.class || targetType == int.class) {
            return Integer.parseInt(stringValue);
        } else if (targetType == Long.class || targetType == long.class) {
            return Long.parseLong(stringValue);
        } else if (targetType == Double.class || targetType == double.class) {
            return Double.parseDouble(stringValue);
        } else if (targetType == Float.class || targetType == float.class) {
            return Float.parseFloat(stringValue);
        } else if (targetType == Boolean.class || targetType == boolean.class) {
            return Boolean.parseBoolean(stringValue);
        } else if (targetType == BigDecimal.class) {
            return new BigDecimal(stringValue);
        } else if (targetType == Short.class || targetType == short.class) {
            return Short.parseShort(stringValue);
        } else if (targetType == Byte.class || targetType == byte.class) {
            return Byte.parseByte(stringValue);
        } else if (targetType == Character.class || targetType == char.class) {
            return stringValue.isEmpty() ? '\0' : stringValue.charAt(0);
        } else {
            // 对于其他类型，尝试直接返回字符串值或自定义处理
            return stringValue;
        }
    }
}


public class CancelledOrderRequest {
    private String distributorOrderId;  //对应的是凹凸的订单号
    private String msgId;
    private Long orderId;
    private String sign;
    private String orderStatus; // = "cancelled"
    private Integer cancelType; 
    /*
     * 1: 未支付取消 (Unpaid cancellation)
     * 2: 未确认取消 (Unconfirmed cancellation)
     * 3: 下单失败取消 (Order failure cancellation)
     * 4: 用户主动取消 (User-initiated cancellation)
     * 5: 客服系统取消 (Customer service cancellation)
     * 6: 供应商取消 (Supplier cancellation)
     */
    private String reason;
    private java.math.BigDecimal amount; // Cancellation fee

    @Override
    public String toString() {
        return "CancelledOrderRequest{" +
                "distributorOrderId='" + distributorOrderId + '\'' +
                ", msgId='" + msgId + '\'' +
                ", orderId=" + orderId +
                ", sign='" + sign + '\'' +
                ", orderStatus='" + orderStatus + '\'' +
                ", cancelType=" + cancelType +
                ", reason='" + reason + '\'' +
                ", amount=" + amount +
                '}';
    }

    // Constructors
    public CancelledOrderRequest() {}

    public String getDistributorOrderId() {
        return distributorOrderId;
    }

    public void setDistributorOrderId(String distributorOrderId) {
        this.distributorOrderId = distributorOrderId;
    }

    // Getters and Setters
    public String getMsgId() {
        return msgId;
    }

    public void setMsgId(String msgId) {
        this.msgId = msgId;
    }

    public Long getOrderId() {
        return orderId;
    }

    public void setOrderId(Long orderId) {
        this.orderId = orderId;
    }

    public String getSign() {
        return sign;
    }

    public void setSign(String sign) {
        this.sign = sign;
    }

    public String getOrderStatus() {
        return orderStatus;
    }

    public void setOrderStatus(String orderStatus) {
        this.orderStatus = orderStatus;
    }

    public Integer getCancelType() {
        return cancelType;
    }

    public void setCancelType(Integer cancelType) {
        this.cancelType = cancelType;
    }

    public String getReason() {
        return reason;
    }

    public void setReason(String reason) {
        this.reason = reason;
    }

    public java.math.BigDecimal getAmount() {
        return amount;
    }

    public void setAmount(java.math.BigDecimal amount) {
        this.amount = amount;
    }
}