代码搭建

.
├── README.md
├── commodity_new.json
├── lib
│   └── k3cloud-webapi-sdk.7.6.x.jar
├── pom.xml
└── src
    ├── main
    │   ├── java
    │   │   └── com
    │   │       └── smartrm
    │   │           └── smartrmmonolith
    │   │               ├── SmartrmMonolithApplication.java
    │   │               ├── commodity 商品上下文
    │   │               │   ├── adapter 适配器层
    │   │               │   ├── application 应用层
    │   │               │   ├── domain 领域层
    │   │               │   └── infrastructure 基础设施层
    │   │               ├── device
    │   │               │   ├── adapter
    │   │               │   ├── application
    │   │               │   ├── domain
    │   │               │   └── infrastructure
    │   │               ├── infracore
    │   │               │   ├── aggregate
    │   │               │   ├── api
    │   │               │   ├── common
    │   │               │   ├── event
    │   │               │   ├── exception
    │   │               │   ├── idgenerator
    │   │               │   ├── scheduler
    │   │               │   └── security
    │   │               ├── operation
    │   │               │   ├── adapter
    │   │               │   ├── domain
    │   │               │   └── infrastructure
    │   │               ├── payment
    │   │               │   ├── adapter
    │   │               │   ├── application
    │   │               │   ├── domain
    │   │               │   └── infrastructure
    │   │               ├── trade
    │   │               │   ├── adapter
    │   │               │   ├── application
    │   │               │   ├── domain
    │   │               │   └── infrastructure
    │   │               └── user
    │   │                   ├── adapter
    │   │                   ├── application
    │   │                   ├── domain
    │   │                   └── infrastructure
    │   └── resources
    │       ├── application-test.yml
    │       ├── application.properties
    │       ├── application.yml
    │       ├── com
    │       │   └── smartrm
    │       │       └── smartrmmonolith
    │       │           └── device
    │       │               └── infrastructure
    │       └── commodity_new.json
    └── test
        └── java
            └── com
                └── smartrm
                    └── smartrmmonolith
                        ├── SmartrmMonolithApplicationTests.java
                        └── event
                            ├── TestEvent.java
                            ├── TestEvent1.java
                            └── TestEventHandler.java

commodity

├── adapter
│   ├── CommodityProcessor.java
│   ├── api
│   │   └── CommodityController.java
│   ├── convertor
│   │   ├── json
│   │   └── plaintext
│   ├── file
│   └── repository
│       └── impl
├── application
│   ├── dto
│   └── service
│       └── impl
├── domain
│   ├── model
│   └── repository
└── infrastructure
    └── CommodityError.java

{"secondLevelCategory": "粮油调味", "description": null, "commodityId": "1000001", "label": [], "imageUrl": {"url": "1000001.jpg", "width": null, "height": null, "fileSize": null, "fileMd5": null}, "commodityName": "星华源 纯燕麦速食面140g", "firstLevelCategory": "食品饮料", "thirdLevelCategory": "方便食品", "price": 10.0, "barCode": "7069488225951"}
{"secondLevelCategory": "粮油调味", "description": null, "commodityId": "1000002", "label": ["儿童"], "imageUrl": {"url": "1000002.jpg", "width": null, "height": null, "fileSize": null, "fileMd5": null}, "commodityName": "寿桃牌儿童面 260g", "firstLevelCategory": "食品饮料", "thirdLevelCategory": "方便食品", "price": 5.5, "barCode": "9401241465345"}
{"secondLevelCategory": "粮油调味", "description": null, "commodityId": "1000003", "label": [], "imageUrl": {"url": "1000003.jpg", "width": null, "height": null, "fileSize": null, "fileMd5": null}, "commodityName": "【咸阳馆】宝鸡岐山擀面皮280g", "firstLevelCategory": "食品饮料", "thirdLevelCategory": "方便食品", "price": 3.0, "barCode": "1684571693535"}

/**
 * @author: yoda
 * @description: 商品服务入口
 */
@RestController
@RequestMapping("/commodity")
public class CommodityController {

  @Autowired
  private CommodityService commodityService;

  @GetMapping(value = "/detail/{commodityId}")
  @ResponseBody
  public CommonResponse<CommodityInfoDto> getDetail(@PathVariable String commodityId) {
    CommodityInfoDto commodityInfoDto = commodityService.getCommodityDetail(commodityId);
    return CommonResponse.success(commodityInfoDto);
  }

  @PostMapping(value = "/list")
  @ResponseBody
  public CommonResponse<List<CommodityInfoDto>> getCommodityList(@RequestBody
      ListCommodityByIdQueryDto request) {
    return CommonResponse.success(commodityService.getCommodityList(request.getIds()));
  }
}

/**
 * @author: yoda
 * @description: 适配器，从商品模型到Json对象
 */
@Component
public class JsonPropertyConvertor implements PropertyConvertor {

  private static Map<ValueTypeCode, Pair<CommodityPropertyParser, CommodityPropertyDumper>> adapterMap = ImmutableMap
      .<ValueTypeCode, Pair<CommodityPropertyParser, CommodityPropertyDumper>>builder()
      .put(STRING, Pair.of(new StringPropertyJsonParser(), new StringPropertyJsonDumper()))
      .put(INTEGER, Pair.of(new IntegerPropertyJsonParser(), new IntegerPropertyJsonDumper()))
      .put(FLOAT, Pair.of(new FloatPropertyJsonParser(), new FloatPropertyJsonDumper()))
      .put(CURRENCY, Pair.of(new CurrencyPropertyJsonParser(), new CurrencyPropertyJsonDumper()))
      .put(DATE, Pair.of(new DatePropertyJsonParser(), new DatePropertyJsonDumper()))
      .put(DATETIME, Pair.of(new DateTimePropertyJsonParser(), new DateTimePropertyJsonDumper()))
      .put(IMAGE_URL, Pair.of(new ImageUrlPropertyJsonParser(), new ImageUrlPropertyJsonDumper()))
      .put(MAP, Pair.of(new MapPropertyJsonParser(), new MapPropertyJsonDumper()))
      .build();

  @Override
  public CommodityPropertyParser parser(ValueType type) {
    return adapterMap.get(type.getType()).getLeft();
  }

  @Override
  public CommodityPropertyDumper dumper(ValueType type) {
    return adapterMap.get(type.getType()).getRight();
  }

}

package com.smartrm.smartrmmonolith.commodity.adapter.convertor.plaintext;

import com.smartrm.smartrmmonolith.commodity.adapter.convertor.CommodityPropertyParser;
import com.smartrm.smartrmmonolith.commodity.infrastructure.CommodityError;
import com.smartrm.smartrmmonolith.infracore.exception.DomainException;
import java.math.BigDecimal;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;

/**
 * @author: yoda
 * @description:
 */
public class CurrencyPropertyTextParser implements
    CommodityPropertyParser<BigDecimal, String> {

  @Override
  public BigDecimal parse(String value) {
    if (StringUtils.isEmpty(value)) {
      return null;
    }

    try {
      return NumberUtils.createBigDecimal(value);
    } catch (NumberFormatException e) {
      throw new DomainException(CommodityError.CommodityParseError);
    }
  }
}

package com.smartrm.smartrmmonolith.commodity.adapter.file;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.smartrm.smartrmmonolith.commodity.adapter.convertor.PropertyConvertor;
import com.smartrm.smartrmmonolith.commodity.domain.model.Commodity;
import com.smartrm.smartrmmonolith.commodity.domain.model.CommoditySchema;
import com.smartrm.smartrmmonolith.commodity.domain.model.PropertySchema;
import com.smartrm.smartrmmonolith.commodity.domain.repository.CommodityRepository;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Iterator;
import javax.annotation.PostConstruct;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * @author: yoda
 * @description: 从json数据文件加载资源库
 */
@Component
public class CommodityRepositoryJsonReader {

  @Value("${commodity.file.json.path}")
  private String commodityJsonFilePath;

  @Autowired
  @Qualifier("jsonPropertyConvertor")
  private PropertyConvertor convertor;

  @Autowired
  private CommoditySchema schema;

  @Autowired
  private CommodityRepository commodityRepository;

  private static Logger LOGGER = LoggerFactory.getLogger(CommodityRepositoryJsonReader.class);

  @PostConstruct
  public void load() throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    FileInputStream istream = new FileInputStream(commodityJsonFilePath);
    BufferedReader reader = new BufferedReader(new InputStreamReader(istream, "UTF-8"));
    while (true) {
      String line = reader.readLine();
      if (line == null) {
        break;
      }
      ObjectNode obj = (ObjectNode) (mapper.readTree(line));
      Iterator<String> fields = obj.fieldNames();
      Commodity commodity = new Commodity(schema);
      while (fields.hasNext()) {
        String field = fields.next();
        PropertySchema propertySchema = schema.getPropertySchema(field);
        if (propertySchema != null) {
          JsonNode node = obj.get(field);
          LOGGER.info("field:{}, value:{}", field, node.toString());
          if (node.isArray()) {
            ArrayNode array = (ArrayNode) node;
            for (int i = 0; i < array.size(); i++) {
              commodity.setValue(field,
                  this.convertor.parser(propertySchema.getValueType()).parse(array.get(i)));
            }
          } else {
            commodity.setValue(field,
                this.convertor.parser(propertySchema.getValueType()).parse(node));
          }

        }
      }
      commodityRepository.put(commodity);

    }
  }

}

@Component
public class CommodityRepositoryJsonWriter {

  @Autowired
  private CommodityRepository commodityRepository;

  public void dumpRepository() throws IOException {
    CommodityDumper dumper = new CommodityJsonDumper(
        new FileOutputStream("commodity_repository_dump.json"));
    commodityRepository.traverse(dumper);
  }

}

package com.smartrm.smartrmmonolith.commodity.domain.repository;

import com.smartrm.smartrmmonolith.commodity.adapter.CommodityProcessor;
import com.smartrm.smartrmmonolith.commodity.domain.model.Commodity;
import java.io.IOException;
import java.util.List;

/**
 * @author: yoda
 * @description: 商品资源库接口
 */
public interface CommodityRepository {

  Commodity findById(String commodityId);

  List<Commodity> findBatchByIds(List<String> ids);

  void put(Commodity commodity);

  void traverse(CommodityProcessor processor) throws IOException;

}

package com.smartrm.smartrmmonolith.commodity.domain.model;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Map;

public class PropertySchema<T> {

  //字段名
  private String name;

  //字段标签
  private String label = "";

  //最大重复次数，默认不重复
  private int maxRepeat = 1;

  //数据类型
  private ValueType<T> valueType;

  //样例
  private String example = "";

  //说明
  private String desc = "";

  public PropertySchema(String name, ValueType<T> type) {
    this.name = name;
    this.valueType = type;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public String getLabel() {
    return label;
  }

  public void setLabel(String label) {
    this.label = label;
  }

  public int getMaxRepeat() {
    return maxRepeat;
  }

  public void setMaxRepeat(int maxRepeat) {
    this.maxRepeat = maxRepeat;
  }

  public ValueType<T> getValueType() {
    return valueType;
  }

  public void setValueType(ValueType<T> valueType) {
    this.valueType = valueType;
  }

  public String getExample() {
    return example;
  }

  public void setExample(String example) {
    this.example = example;
  }

  public String getDesc() {
    return desc;
  }

  public void setDesc(String desc) {
    this.desc = desc;
  }

  public static PropertySchema<BigDecimal> ofCurrency(String name, int maxRepeat) {
    PropertySchema<BigDecimal> ret = new PropertySchema<>(name, new ValueTypeCurrency());
    ret.setMaxRepeat(maxRepeat);
    return ret;
  }


  public static PropertySchema<LocalDate> ofDate(String name, int maxRepeat) {
    PropertySchema<LocalDate> ret = new PropertySchema<>(name, new ValueTypeDate());
    ret.setMaxRepeat(maxRepeat);
    return ret;
  }


  public static PropertySchema<LocalDateTime> ofDateTime(String name, int maxRepeat) {
    PropertySchema<LocalDateTime> ret = new PropertySchema<>(name, new ValueTypeDateTime());
    ret.setMaxRepeat(maxRepeat);
    return ret;
  }


  public static PropertySchema<Double> ofFloat(String name, int maxRepeat) {
    PropertySchema<Double> ret = new PropertySchema<>(name, new ValueTypeFloat());
    ret.setMaxRepeat(maxRepeat);
    return ret;
  }

  public static PropertySchema<ImageUrl> ofImageUrl(String name, int maxRepeat) {
    PropertySchema<ImageUrl> ret = new PropertySchema<>(name, new ValueTypeImageUrl());
    ret.setMaxRepeat(maxRepeat);
    return ret;
  }

  public static PropertySchema<Long> ofInteger(String name, int maxRepeat) {
    PropertySchema<Long> ret = new PropertySchema<>(name, new ValueTypeInteger());
    ret.setMaxRepeat(maxRepeat);
    return ret;
  }

  public static PropertySchema<Map> ofMap(String name, int maxRepeat) {
    PropertySchema<Map> ret = new PropertySchema<>(name, new ValueTypeMap());
    ret.setMaxRepeat(maxRepeat);
    return ret;
  }

  public static PropertySchema<String> ofString(String name, int maxRepeat) {
    PropertySchema<String> ret = new PropertySchema<>(name, new ValueTypeString());
    ret.setMaxRepeat(maxRepeat);
    return ret;
  }

}

public class ValueTypeCurrency implements ValueType<BigDecimal> {

  @Override
  public ValueTypeCode getType() {
    return ValueTypeCode.CURRENCY;
  }

  @Override
  public Class<BigDecimal> getValueClass() {
    return BigDecimal.class;
  }

}

package com.smartrm.smartrmmonolith.commodity.domain.model;

import static com.smartrm.smartrmmonolith.commodity.infrastructure.CommodityError.CommodityNoSuchProperty;
import static com.smartrm.smartrmmonolith.commodity.infrastructure.CommodityError.CommodityPropertyReachMaxRepeat;

import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
import com.smartrm.smartrmmonolith.infracore.exception.DomainException;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Commodity implements Serializable {

  private static final Logger LOGGER = LoggerFactory.getLogger(Commodity.class);

  public static final String PROPERTY_NAME_ID = "commodityId";

  public static final String PROPERTY_NAME_NAME = "commodityName";

  private CommoditySchema schema;

  private Multimap<String, Property> data = ArrayListMultimap.create();

  public Commodity(CommoditySchema schema) {
    this.schema = schema;
  }

  public <T> void setProperty(Property<T> property) {
    if (data.get(property.getName()).size() >= property.getMaxRepeat()) {
      throw new DomainException(CommodityPropertyReachMaxRepeat);
    } else {
      data.put(property.getName(), property);
    }
  }

  public <T> void setValue(String name, T value) {
    PropertySchema propertySchema = schema.getPropertySchema(name);
    if (propertySchema == null) {
      throw new DomainException(CommodityNoSuchProperty);
    } else {
      Property<T> property = new Property<>(propertySchema, value);
      setProperty(property);
    }
  }

  public <T> Property<T> getSingleProperty(String name) {
    if (!data.get(name).isEmpty()) {
      return data.get(name).iterator().next();
    } else {
      return null;
    }
  }

  public String getAsString(String name) {
    return this.<String>getSingleProperty(name).getValue();
  }

  public BigDecimal getAsBigDecimal(String name) {
    return this.<BigDecimal>getSingleProperty(name).getValue();
  }

  public Long getAsLong(String name) {
    return this.<Long>getSingleProperty(name).getValue();
  }

  public LocalDate getAsLocalDate(String name) {
    return this.<LocalDate>getSingleProperty(name).getValue();
  }

  public LocalDateTime getAsLocalDateTime(String name) {
    return this.<LocalDateTime>getSingleProperty(name).getValue();
  }

  public ImageUrl getAsImageUrl(String name) {
    return this.<ImageUrl>getSingleProperty(name).getValue();
  }

  public Collection<Property> getMultiProperty(String name) {
    return data.get(name);
  }

  public <T> List<T> getAsList(String name) {
    return data.get(name).stream().map(p -> ((Property<T>) p).getValue())
        .collect(Collectors.toList());
  }

  public Collection<Property> getAllProperties() {
    return data.values();
  }

  public String getCommodityId() {
    return this.<String>getSingleProperty(PROPERTY_NAME_ID).getValue();
  }

  public String getCommodityName() {
    return this.<String>getSingleProperty(PROPERTY_NAME_NAME).getValue();
  }

}

package com.smartrm.smartrmmonolith.commodity.domain.model;

public enum ValueTypeCode {

  //字符串
  STRING,
  //整数
  INTEGER,
  //浮点数
  FLOAT,
  //货币
  CURRENCY,
  //日期，对应LocalDate
  DATE,
  //日期时间，对应LocalDateTime
  DATETIME,
  //图片url
  IMAGE_URL,
  //字典
  MAP;
}

package com.smartrm.smartrmmonolith.commodity.application.service.impl;

import com.google.common.collect.Lists;
import com.smartrm.smartrmmonolith.commodity.application.dto.CommodityInfoDto;
import com.smartrm.smartrmmonolith.commodity.application.service.CommodityService;
import com.smartrm.smartrmmonolith.commodity.domain.model.Commodity;
import com.smartrm.smartrmmonolith.commodity.domain.repository.CommodityRepository;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author: yoda
 * @description: 商品服务实现
 */
@Service
public class CommodityServiceImpl implements CommodityService {

  @Autowired
  private CommodityRepository commodityRepository;

  @Override
  public CommodityInfoDto getCommodityDetail(String commodityId) {
    Commodity commodity = commodityRepository.findById(commodityId);
    if (commodity == null) {
      return null;
    }
    CommodityInfoDto commodityInfoDto = new CommodityInfoDto(commodity);
    return commodityInfoDto;
  }

  @Override
  public List<CommodityInfoDto> getCommodityList(List<String> commodityId) {
    List<CommodityInfoDto> ret = Lists.newArrayList();
    List<Commodity> commodities = commodityRepository.findBatchByIds(commodityId);
    for (Commodity commodity : commodities) {
      ret.add(new CommodityInfoDto(commodity));
    }
    return ret;
  }
}