@PostConstruct注解

@PostConstruct注解是Java提供的一个基础注解，该注解被用来修饰一个非静态的void()方法。被@PostConstruct修饰的方法会在服务器加载Servlet的时候运行，并且只会被服务器执行一次。PostConstruct在构造函数之后执行，init()方法之前执行。

在日常使用中，可以用来初始化可配置字典相关的信息，通过项目启动初始化bean的方式，将需要加载的信息，提前加载到服务器内存，便于后面在程序中使用对应的值。

可以结合ExpiryMap（工具类），设置失效时间，方便及时获取最新的配置内容。

示例：

// 用于存放信息的map
private HashMap<String, Object> infoMap = new hashMap<>();
// 用来判断是否需要重新加载信息的ExpiryMap 时间根据自身需要设置
private ExpiryMap<String, Integer> expMap = new ExpiryMap<>(60*1000);

/**
 * 
 * <p>Description: 根据key获取对应的信息</p>
 * @param tag
 * @return
 */
public xx getInfo(String key) {
    // 验证是否超过重新加载时间，重新拉取最新信息
    expMap.computeIfAbsent("loadName", k -> {
        initInfo();
        return expMap.put(k,1);
    });
    Object info = infoMap.get(key);
    // 根据自身需要，可以加个空值验证，拉取一次最新的信息
    if (null == info) {
        initInfo();
        return infoMap.get(key);
    }
    return info;
}

/**
 * 
 * <p>Description: 加载字典信息</p>
 */
@PostConstruct
public void initInfo() {
    // 接口连接
    String url = "xxx";
    // 调用接口获取字典最新信息
    String str = OKHttpUtil.post(xxx);
    // 返回正常存放信息
    infoMap.pur(xx,xxx);
}

上面示例是简单的思路，具体使用可以根据自身项目的需要进行处理

ExpiryMap

package com.ule.wholesale.common.cache;

import java.util.*;

/**
 * 可以设置有效时间的Map
 * 
 * @param <K>
 * @param <V>
 */
public class ExpiryMap<K, V> extends HashMap<K, V> {

	private static final long serialVersionUID = 1L;
	/**
	 * 默认有效时间一分钟
	 */
	private long expiry = 1000 * 60 * 1L;
	private transient HashMap<K, Long> expiryMapSelf = new HashMap<>();

	public ExpiryMap() {
		super();
	}

	public ExpiryMap(long defaultExpiryTime) {
		this(1 << 4, defaultExpiryTime);
	}

	public ExpiryMap(int initialCapacity, long defaultExpiryTime) {
		super(initialCapacity);
		this.expiry = defaultExpiryTime;
	}

	@Override
	public V put(K key, V value) {
		expiryMapSelf.put(key, System.currentTimeMillis() + expiry);
		return super.put(key, value);
	}
	@Override
	public boolean containsKey(Object key) {
		return !checkExpiry(key, true) && super.containsKey(key);
	}

	/**
	 * expiryTime 键值对有效期 毫秒
	 * 
	 * @param key
	 * @param value
	 * @param expiryTime
	 * @return
	 */
	public V put(K key, V value, long expiryTime) {
		expiryMapSelf.put(key, System.currentTimeMillis() + expiryTime);
		return super.put(key, value);
	}
	@Override
	public int size() {
		return entrySet().size();
	}
	@Override
	public boolean isEmpty() {
		return entrySet() == null || entrySet().isEmpty();
	}
	@Override
	public boolean containsValue(Object value) {
		if (value == null)
			return Boolean.FALSE;
		Set<Entry<K, V>> set = super.entrySet();
		Iterator<Entry<K, V>> iterator = set.iterator();
		while (iterator.hasNext()) {
			Entry<K, V> entry = iterator.next();
			if (value.equals(entry.getValue())) {
				if (checkExpiry(entry.getKey(), false)) {
					iterator.remove();
					return Boolean.FALSE;
				} else {
					return Boolean.TRUE;
				}
			}
		}
		return Boolean.FALSE;
	}
	@Override
	public Collection<V> values() {
		Collection<V> values = super.values();
		if (values == null || values.isEmpty())
			return values;
		Iterator<V> iterator = values.iterator();
		while (iterator.hasNext()) {
			V next = iterator.next();
			if (!containsValue(next))
				iterator.remove();
		}
		return values;
	}
	@Override
	public V get(Object key) {
		if (key == null)
			return null;
		if (checkExpiry(key, true))
			return null;
		return super.get(key);
	}

	/**
	 * @Description: 是否过期
	 * @param key
	 * @return null:不存在或key为null ,-1:过期 ,存在且没过期返回value 因为过期的不是实时删除，所以稍微有点作用
	 */
	public Object isInvalid(Object key) {
		if (key == null)
			return null;
		if (!expiryMapSelf.containsKey(key)) {
			return null;
		}
		long expiryTime = expiryMapSelf.get(key);
		boolean flag = System.currentTimeMillis() > expiryTime;
		if (flag) {
			super.remove(key);
			expiryMapSelf.remove(key);
			return -1;
		}
		return super.get(key);
	}
	@Override
	public void putAll(Map<? extends K, ? extends V> m) {
		for (Entry<? extends K, ? extends V> e : m.entrySet())
			expiryMapSelf.put(e.getKey(), System.currentTimeMillis() + expiry);
		super.putAll(m);
	}
	@Override
	public Set<Entry<K, V>> entrySet() {
		Set<Entry<K, V>> set = super.entrySet();
		Iterator<Entry<K, V>> iterator = set.iterator();
		while (iterator.hasNext()) {
			Entry<K, V> entry = iterator.next();
			if (checkExpiry(entry.getKey(), false))
				iterator.remove();
		}
		return set;
	}

	/**
	 * @Description: 是否过期 
	 * @param isRemoveSuper true super删除
	 * @return
	 */
	private boolean checkExpiry(Object key, boolean isRemoveSuper) {
		if (!expiryMapSelf.containsKey(key)) {
			return Boolean.FALSE;
		}
		long expiryTime = expiryMapSelf.get(key);
		boolean flag = System.currentTimeMillis() > expiryTime;
		if (flag) {
			if (isRemoveSuper)
				super.remove(key);
			expiryMapSelf.remove(key);
		}
		return flag;
	}

	@Override
	public boolean equals(Object o) {
		return super.equals(o);
	}

	@Override
	public int hashCode() {
		return super.hashCode();
	}

	@Override
	public String toString() {
		return super.toString();
	}
}