Comment obtenir le dictionnaire de données basé sur une annotation dans Springboot

La question mène à :

J'ai récemment démarré un nouveau projet et un dictionnaire de données est utilisé dans le projet. Lorsque les données de la requête de liste sont renvoyées, le code doit être converti manuellement. à nommer et affiché à la réception. Le chef de projet a déclaré qu'une fonction unifiée peut être encapsulée pour éviter aux programmeurs d'écrire leur propre code confus et des styles incohérents.

Exigences :

• Basé sur l'architecture du microservice, le dictionnaire de données est obtenu via le service

# ; 🎜🎜## 🎜🎜#Code simplifié, facile à utiliser
Utiliser Redis ;
• # 🎜🎜#L'orientation générale est de personnaliser les annotations et d'effectuer le traitement des données pendant la sérialisation ; en considérant les microservices, la logique principale doit être mise en commun, puis des interfaces externes sont fournies, et chaque service métier implémente l'interface pour obtenir les données du dictionnaire ; Pensez à Redis, lors de la sérialisation des données, obtenez-les d'abord via Redis, si elles ne peuvent pas être obtenues, obtenez-les via l'interface, stockez-les dans Redis, puis revenez au traitement. étape supplémentaire. Lors de l'ajout ou de la modification du dictionnaire de données, mettez à jour de manière synchrone le contenu Redis pour garantir la validité des données.
  implémentation

Notes de définition

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotationsInside
@JsonSerialize(using = DictSerializer.class)
public @interface Dict {

    /** 字典类型 */
    String type();
}

# 🎜 🎜#Spécifiez l'emplacement pour ajouter l'annotation
Spécifiez l'heure d'effet de l'annotation

• Spécifiez le traitement de sérialisation class#🎜🎜 #

• Classe de traitement de sérialisation

• public class DictSerializer extends StdSerializer<Object> implements ContextualSerializer {
      /** 字典注解 */
      private Dict dict;
      public DictSerializer() {
          super(Object.class);
      }
      public DictSerializer(Dict dict) {
          super(Object.class);
          this.dict = dict;
      }
      private String type;
      @Override
      public void serialize(Object value, JsonGenerator gen, SerializerProvider provider) throws IOException {
          if (Objects.isNull(value)) {
              gen.writeObject(value);
              return;
          }
          if (Objects.nonNull(dict)){
              type = dict.type();
          }
          // 通过数据字典类型和value获取name
  
          gen.writeObject(value);
          gen.writeFieldName(gen.getOutputContext().getCurrentName()+"Name");
          gen.writeObject(label);
      }
      @Override
      public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty beanProperty) throws JsonMappingException {
          if (Objects.isNull(beanProperty)){
              return prov.findValueSerializer(beanProperty.getType(), beanProperty);
          }
          Dict dict = beanProperty.getAnnotation(Dict.class);
          if (Objects.nonNull(dict)){
              type = dict.type();
              return this;
          }
          return prov.findNullValueSerializer(null);
      }
  }

  La logique traitée ici est le champ d'origine Le contenu reste inchangé et un nouveau champ est ajouté pour stocker la valeur convertie

• Acquisition du dictionnaire de données
  #🎜🎜 #

  private static String changeLabel(String type,String code) {
      if(code.indexOf(",") > -1) {
          String[] strs = code.split(",");
          if (strs.length > 1) {
              StringBuilder sb = new StringBuilder();
              for (String str : strs) {
                  // 从缓存中获取字典。如果不行，通过SpringUtil.getBean(); 获取服务处理
                  sb.append(DictDataCache.getLabel(type, str)).append(separator);
              }
              return sb.substring(0, sb.length() - 1);
          }
      }
      // 从缓存中获取字典。如果不行，通过SpringUtil.getBean(); 获取服务处理
      return DictDataCache.getLabel(type, code);
  }

  # 🎜🎜#Considérez la situation de la sélection multiple, déterminez d'abord s'il s'agit d'une sélection multiple, d'un épissage par virgule par défaut et ajoutez un contrôle des paramètres d'entrée plus tard

@Override
public String getDictDataOptions(String typeCode,String value) {
    if (redisTemplate.hasKey("dict:"+typeCode+":"+value)){
        return (String) redisTemplate.opsForValue().get("dict:"+typeCode+":"+value);
    }
    List<DictDataOptions> dictDataList = getDictDataHandler().getDictDataOptions(typeCode);
    if(CollUtil.isNotEmpty(dictDataList)) {
        put(typeCode, dictDataList);
    }
    if (redisTemplate.hasKey("dict:"+typeCode+":"+value)){
        return (String) redisTemplate.opsForValue().get("dict:"+typeCode+":"+value);
    }
    return null;
}

Jugez s'il existe dans Redis en fonction du clé, et obtenez-la directement si elle existe, si elle n'existe pas, récupérez-la via l'interface, placez-la directement dans Redis, puis récupérez-la à nouveau depuis Redis.

protected void put(String typeCode, List<DictDataOptions> dataList) {
    if (CollUtil.isNotEmpty(dataList)){
        for (DictDataOptions dictDataOptions : dataList) {
            AbstractDictHandler.redisTemplate.opsForValue().set("dict:"+typeCode+":"+dictDataOptions.getDataLabel(),dictDataOptions.getDataValue());
        }
    }
}

Boucle pour placer les valeurs du dictionnaire de données

@Override
public List<DictDataOptions> getDictDataOptions(String typeCode) {
    return iSysDictService.queryDictItemsByCode(typeCode).stream()
            .map(e -> DictDataOptions.builder().typeCode(typeCode).dataLabel(e.getValue()).dataValue(e.getText()).build())
            .collect(Collectors.toList());
}

• Selon le type de dictionnaire de données, notez que cette classe d'implémentation nécessite que chaque microservice en implémente un ; afin d'éviter les données de base. Si le service raccroche et qu'une erreur est signalée lors de l'appel, une implémentation par défaut est fournie en commun.
  4. Utilisez

@Dict(type = "inspectType")
private String checkType;

pour ajouter des annotations aux champs correspondants dans l'entité renvoyée au front-end et spécifiez la valeur du type de dictionnaire de données

      {
        "id": "1522492702905954306",
        "professionName": "专业名称888",
        "checkCode": "检测项编码8",
        "checkProject": "rrrr检测项目88",
        "checkDevice": "52",
        "checkStandard": "检测项编码88",
        "referenceStandard": "wq参考标准8",
        "checkType": "1",
        "checkTypeName": "尺寸",
        "remarks": "ef备注备注8"
      },

#🎜 🎜# obtenu par le front end json aura un champ supplémentaire : checkTypeName, le contenu est la valeur chinoise de checkType.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!