So implementieren Sie die Wörterbuchübersetzung elegant in Java

Was ist Serialisierung? In Java ist Serialisierung der Prozess der Konvertierung von Objekten in einen Bytestrom, der in einer Datei gespeichert oder über ein Netzwerk übertragen werden kann. Unter Deserialisierung versteht man den Prozess der Konvertierung eines Bytestroms in ein Rohobjekt. Durch Serialisierung und Deserialisierung können wir Objekte zwischen verschiedenen Anwendungen weitergeben und Objekte zur späteren Verwendung auch in Dateien speichern.

Verwenden Sie die Serialisierung, um die Übersetzung von Wörterbuchwerten zu erreichen.

In Java können wir den Serialisierungsmechanismus verwenden, um die Entsprechung zwischen der Codierung und der entsprechenden Bedeutung zu erreichen. Die spezifischen Schritte sind wie folgt:

1. Definieren Sie eine Wörterbuchanmerkung, zum Beispiel:

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

    /**
     * 字典类型
     * 比如在描述学生的时候，1代表小学生 2代表初中生 3代表高中生 4代表大学生
     * 同样在描述老师的时候，1代表语文老师 2代表数学老师 3代表英语老师 4代表体育老师
     * 同样的数值在不同类型下，代表含义不同，所以需要指定字典的类型
     */
    String dic();
}

2. Kombinieren Sie die benutzerdefinierte Annotation mit der Vererbung von ContextualSerializer und realisieren Sie die Übersetzung des zurückgegebenen Ergebnisses:

@Slf4j
public class DictSerializer extends StdSerializer<Object> implements ContextualSerializer {

    private transient String dictCode;

    @Override
    public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty beanProperty){
        Dict dict = beanProperty.getAnnotation(Dict.class);
        return createContextual(dict.dic());
    }

    private JsonSerializer<?> createContextual(String dicCode) {
        DictSerializer serializer = new DictSerializer();
        serializer.setDictCode(dicCode);
        return serializer;
    }

    @Override
    public void serialize(Object value, JsonGenerator gen, SerializerProvider provider){

        String dictCode = getDictCode();
        if (StrUtil.isBlank(dictCode)) {
            return;
        }
        if (Objects.isNull(value)) {
            return;
        }
        try {
            // 因为序列化是每个对象都需要进行序列话操作，这里为了减少网络IO，使用了 guava 的本地缓存（代码在下面）
            Map<String, String> dictMap = DictionaryConstants.DICTIONARY_CACHE.get(dictCode);
            if (dictMap.containsKey("nullValue")) {
                // 当本地缓存中不存在该类型的字典时，就调用查询方法，并且放入到本地缓存中（代码在下面）
                dictMap = translateDictValue(dictCode);
                DictionaryConstants.DICTIONARY_CACHE.put(dictCode, dictMap);
            }
            // 通过数据字典类型和value获取name
            String label = dictMap.get(value.toString());
            gen.writeObject(value);
            // 在需要转换的字段上添加@Dict注解，注明需要引用的code，后端会在返回值中增加filedName_dictText的key，前端只需要取对应的 filedName_dictText 就可以直接使用
            gen.writeFieldName(gen.getOutputContext().getCurrentName() + DictionaryConstants.DICT_TEXT_SUFFIX);
            gen.writeObject(label);
        } catch (Exception e) {
            log.error("错误信息:{}", e.getMessage(), e);
        }
    }

    private String getDictCode() {
        return dictCode;
    }

    private void setDictCode(String dictCode) {
        this.dictCode = dictCode;
    }

    protected DictSerializer() {
        super(Object.class);
    }
}

3 Derselbe Wörterbuchtyp und die entsprechende Bedeutung. Speichern Sie es in einer Karte, zum Beispiel:

private Map<String, String> translateDictValue(String code) {
    if (StrUtil.isBlank(code)) {
      return null;
    }
    // Map<String, String> map = new HashMap<>();
    // map.put("1", "小学生");
    // map.put("2", "初中生");
    // map.put("3", "高中生");
    // map.put("4", "大学生");
  
    // 因为我们公司采用微服务，然后字典模块单独拆分成一个服务，所以这里使用Feign方式调用
    DictionaryFeignClient dictionaryFeign = SpringUtil.getBean(DictionaryFeignClient.class);
    return dictionaryFeign.dictionary(code);
}

4 Da bei der Serialisierung jedes Objekt einen Serialisierungsvorgang ausführen muss, werden in diesem Fall viele Serialisierungsvorgänge ausgeführt , derselbe Typ muss sein Das Wörterbuch wird zwischengespeichert. Ich verwende den LoadingCache von guava für das lokale Caching (hier könnte jemand sagen, dass Ihr Cache nicht zu falschen Daten führt, wenn die Bedeutung des Wörterbuchwerts zu diesem Zeitpunkt geändert wird? Erstens). Alle, die Wörterbuchfunktion ist im Allgemeinen Die Verwaltungsseite führt Hinzufügungen, Löschungen und Änderungen durch, und sobald das Wörterbuch festgelegt ist, kann es nicht einfach geändert werden. Wenn Sie hart kämpfen wollen, gewinnen Sie.

public class DictionaryConstants {

    /**
     * 字典翻译文本后缀
     */
    public static final String DICT_TEXT_SUFFIX = "_dictText";

    public static final LoadingCache<String, Map<String, String>> DICTIONARY_CACHE = CacheBuilder.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(30, TimeUnit.SECONDS)
            .expireAfterAccess(10, TimeUnit.SECONDS)
            .build(new CacheLoader<String, Map<String, String>>() {
                @Override
                public Map<String, String> load(String key) {
                    Map<String, String> map = new HashMap<>();
                    map.put("nullValue", "nullValue");
                    return map;
                }
            });
}

Hier noch ein kleiner Hinweis:

expireAfterWrite und ExpireAfterAccess sind beide Cache-Ablaufstrategien in der Google Guava-Cache-Bibliothek.
expireAfterWrite bedeutet, dass das Cache-Element nach der angegebenen Zeit abläuft, unabhängig davon, ob auf das Cache-Element zugegriffen wurde. Wenn wir beispielsweise „expipeAfterWrite“ des Cache-Elements auf 10 Minuten festlegen, läuft das Cache-Element 10 Minuten nach dem Hinzufügen zum Cache ab, unabhängig davon, ob darauf zugegriffen wurde.
Diese beiden Ablaufstrategien können einzeln oder in Kombination verwendet werden, um eine flexiblere Caching-Strategie zu erreichen. Beispielsweise können wir „expireAfterWrite“ des Cache-Elements auf 10 Minuten und „expireAfterAccess“ auf 5 Minuten festlegen, sodass das Cache-Element nach 10 Minuten abläuft oder abläuft, wenn in den letzten 5 Minuten nicht darauf zugegriffen wurde, je nachdem, was zuerst eintritt .
Verwenden Sie „expireAfterWrite“ und „expireAfterAccess“, um zu vermeiden, dass die Datenablaufzeit im Cache zu lang oder zu kurz wird, und verbessern Sie so die Effizienz und Zuverlässigkeit des Caches.
5. Im Vergleich zur Verwendung der AOP-Aspektmethode kann die Verwendung der Serialisierungsmethode das Wörterbuch besser übersetzen (da es für die AOP-Methode schwierig ist, die Eigenschaften von Attributen in Objekten zu verarbeiten), zum Beispiel:

public class Company {
  private List<Staff> staffs;
}

public class Staff {
  private Integer age;
  private String name;
  @Dic(dic = "position")
  private String position;
  
}

Hier In diesem Szenario Wenn die Unternehmenssammlung zurückgegeben wird, ist es schwierig, den gleichen Effekt (Entwicklungsschwierigkeit und Entwicklungskosten) wie bei der Serialisierungsmethode unter Verwendung der AOP-Aspektmethode zu erzielen.

Durch die oben genannten Schritte können wir den Serialisierungsmechanismus in Java verwenden, um die Entsprechung zwischen der Wörterbuchcodierung und der entsprechenden Bedeutung elegant zu realisieren und so die Verwaltung und Wartung codierter Daten zu vereinfachen.

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die Wörterbuchübersetzung elegant in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!