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

news2025/1/12 20:56:22

目录

前言

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);
    }

}

结果：

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

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1377290.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

这是一家有图书馆的公司

这是一家有图书馆的公司

Tubi 技术团队的同事们&#xff0c;除了爱写书、翻译书&#xff0c;也很爱读书。应广大爱书人号召&#xff0c;Tubi 中国团队从 2018 年 7 月开始兴建 Tubi 小书架&#xff0c;迄今已建成了一个有着17 种类别、近 500 本藏书、100 位常驻借阅成员、以音视频开发、广告推荐和团队…
阅读更多...
固态继电器SSR光耦OR-806A ，对标替代AQW212

固态继电器SSR光耦OR-806A ，对标替代AQW212

固态继电器 VL60V输出端击穿电压光耦 高隔离电压 60 至 600V 输出耐受电压 工业温度范围&#xff1a;-40 to 85℃ 高灵敏度和高速响应 特征 输入和输出之间的高隔离电压 &#xff08;Viso&#xff1a;5000 V rms&#xff09;。 控制低电平模拟信号 高灵敏度和高速响应 …
阅读更多...
Neo4j备份

Neo4j备份

这里主要讲Neo4j在windows环境下如何备份&#xff0c;Linux环境同理 Neo4j恢复看这里:Neo4j恢复-CSDN博客 Step1:停服 关闭neo4j.bat console会话窗口即可 Step2: 备份 找到数据目录&#xff0c;并备份、压缩 copy即可 data - 20240108.7z Step3: 启动服务 进入命令行&am…
阅读更多...
【动态规划】20子数组系列_环形子数组的最大和_C++（medium）

【动态规划】20子数组系列_环形子数组的最大和_C++（medium）

题目链接&#xff1a;leetcode环形子数组的最大和 目录 题目解析&#xff1a; 算法原理 1.状态表示 2.状态转移方程 3.初始化 4.填表顺序 5.返回值 编写代码 题目解析&#xff1a; 题目让我们求返回 nums 的非空 子数组 的最大可能和 这道题如果是按照-这道题-是不对…
阅读更多...
MySQL数据被误删怎么办？

MySQL数据被误删怎么办？

文章目录 前言数据备份恢复工具数据备份策略数据备份恢复演示备份数据模拟数据误删恢复备份的数据恢复未备份的数据 总结 前言 很多年前&#xff0c;被公司外派到一家单位驻场开发一个OA项目&#xff0c;两个开发对接各部门的需求&#xff0c;需求还要及时生效&#xff08;一边…
阅读更多...
usb转i2c无需代码实现

usb转i2c无需代码实现

总体思路 usb 转 ttl ttl转i2c 因此可以使用普通的串口调试助手进行。 同时也避免了自己写程序的麻烦。 关键芯片 参考资料 SC18IM700_4_20191009.fm (szlcsc.com)https://atta.szlcsc.com/upload/public/pdf/source/20221014/7E6E1261944FE14AC40A431139B6E16B.pdf …
阅读更多...
C++(9)——内存管理

C++(9)——内存管理

1. 内存分类&#xff1a; 在前面的文章中&#xff0c;通常会涉及到几个名词&#xff0c;例如&#xff1a;栈、堆。这两个词所代表的便是计算机内存的一部分 。在计算机中&#xff0c;对系统的内存按照不同的使用需求进行了区分&#xff0c;大致可以分为&#xff1a;栈 、堆、数…
阅读更多...
平均预期寿命可视化

平均预期寿命可视化

完整地址&#xff1a; 一键三连感谢您的观看 https://www.bilibili.com/video/BV11V41197Rd/?spm_id_from333.999.list.card_archive.click&vd_sourcee9167c654bb4523338a765358a8ac2af<!DOCTYPE html> <html><head><meta charset"utf-8"…
阅读更多...
工程师职称申报业绩是如何要求的？

工程师职称申报业绩是如何要求的？

无论是初级职称还是中级职称或是高级职称&#xff0c;评审的重要条件之一就是相关的业绩证明。 一、个人业绩&#xff0c;比如你做过哪些与本专业相关的业绩证明&#xff0c;像工程类的职称&#xff0c;你的业绩证明就包括中标通知书、竣工验收报告&#xff0c;或是你参与工程建…
阅读更多...
脑科学与人工神经网络ANN的发展历程与最新研究

脑科学与人工神经网络ANN的发展历程与最新研究

本文深入研究了ANN的基本概念、发展背景、应用场景以及与人脑神经网络的关系。 关注TechLead&#xff0c;分享AI全维度知识。作者拥有10年互联网服务架构、AI产品研发经验、团队管理经验&#xff0c;同济本复旦硕&#xff0c;复旦机器人智能实验室成员&#xff0c;阿里云认证的…
阅读更多...
【书生·浦语大模型实战营04】《(4)XTuner 大模型单卡低成本微调实战》学习笔记

【书生·浦语大模型实战营04】《(4)XTuner 大模型单卡低成本微调实战》学习笔记

《(4)XTuner 大模型单卡低成本微调实战》 课程文档&#xff1a;《XTuner 大模型单卡低成本微调实战》 1 Finetune简介 LLM的下游应用中&#xff0c;增量预训练和指令跟随是经常会用到两种的微调模式 1.1 增量预训练微调 使用场景&#xff1a;让基座模型学习到一些新知识&a…
阅读更多...
中本聪15年前剧本重演！“比特币上市首日”成绩斐然，ETF交易量冲破46亿美元！

中本聪15年前剧本重演！“比特币上市首日”成绩斐然，ETF交易量冲破46亿美元！

2024年1月11日&#xff0c;美国证券交易委员会&#xff08;SEC&#xff09;以3-2投票结果批准比特币现货ETF。 2009年1月11日&#xff0c;中本聪向比特币早期开发者哈尔芬尼(Hal Finney)转出10枚比特币&#xff0c;使他成为世界上第一个透过交易获得比特币的人。随后&#xff0…
阅读更多...
13个自媒体文库平台（附通道链接）

13个自媒体文库平台（附通道链接）

​划到最后“阅读原文” ——进入官网 Hi&#xff0c;大家好&#xff0c;我是胡猛夫&#xff0c;每天分享实用运营工具&#xff01; 更多内容&#xff0c;更多资源&#xff0c;欢迎交流&#xff01; 公 号 | 微视角文化 》》精彩推荐 >>微视角文化知识库&#xff1a;移…
阅读更多...
智汇云舟受邀出席石油化工工程数字化交付研讨会

智汇云舟受邀出席石油化工工程数字化交付研讨会

1月9日&#xff0c;由中国石油和石化工程研究会主办的石油化工工程数字化交付研讨会暨智能化工厂建设运行经验交流会在北京顺利召开。智汇云舟创始人兼总裁周舟受邀出席活动&#xff0c;与来自中国石油、中国石化、中国海油、中国中化等单位的相关专家、领导三百余人共同探讨如…
阅读更多...
轻量级图床Imagewheel本地部署并结合内网穿透实现远程访问

轻量级图床Imagewheel本地部署并结合内网穿透实现远程访问

文章目录 1.前言2. Imagewheel网站搭建2.1. Imagewheel下载和安装2.2. Imagewheel网页测试2.3.cpolar的安装和注册 3.本地网页发布3.1.Cpolar临时数据隧道3.2.Cpolar稳定隧道&#xff08;云端设置&#xff09;3.3.Cpolar稳定隧道&#xff08;本地设置&#xff09; 4.公网访问测…
阅读更多...
最佳实践：如何在 SoapUI 中进行 REST 服务的测试

最佳实践：如何在 SoapUI 中进行 REST 服务的测试

SoapUI 频繁地被选择为 SOAP 和 REST API 的自动化测试利器&#xff0c;得益于其友好的用户界面&#xff0c;测试人员毫不费力便可校验 REST 和 SOAP 协议的 Web 服务。它尤其适用于那些需要进行复杂测试的场合。 1、设置接口 我利用了 Swagger 去设置了一批即将投入使用的接…
阅读更多...
springcloud stream消息驱动

springcloud stream消息驱动

简介 Spring Cloud Stream是一个用于构建基于事件驱动的微服务应用程序的框架&#xff0c;其核心目标是简化开发过程&#xff0c;降低消息通信的复杂性&#xff0c;从而使开发人员能够专注于编写业务逻辑。Spring Cloud Stream通过提供Binder抽象&#xff0c;将应用程序与消息…
阅读更多...
基于Java SSM框架实现医院管理系统项目【项目源码】计算机毕业设计

基于Java SSM框架实现医院管理系统项目【项目源码】计算机毕业设计

基于java的SSM框架实现医院管理系统演示 SSM框架 当今流行的“SSM组合框架”是Spring SpringMVC MyBatis的缩写&#xff0c;受到很多的追捧&#xff0c;“组合SSM框架”是强强联手、各司其职、协调互补的团队精神。web项目的框架&#xff0c;通常更简单的数据源。Spring属于…
阅读更多...
自定义View示例

自定义View示例

目录 1.继承View重写onDraw方法 2.继承View重写onMeasure方法 3.添加自定义属性 4.完整代码&#xff1a; 1.继承View重写onDraw方法 解决问题&#xff1a;直接继承自View和ViewGroup的控件&#xff0c;padding是默认无法生效的&#xff0c;需要自己处理。 Overrideprotect…
阅读更多...
组合和聚合

组合和聚合

不是c的语法要求&#xff0c;是一种建模思想 目录 1.组合 1. 使用 -- 在一个类中创建另外一个类的对象 代码中的解释: 代码结果&#xff1a; 组合&#xff1a; 2. 使用 -- 在一个类中创建另外一个类的指针 2.使用类定义一个指针 -- 不是创建一个对象 3.聚合 1. 使…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023