缓存初始化

package com.xiaomi.miui.ad.ssp.proxy;

import com.xiaomi.common.perfcounter.PerfCounter;
import com.xiaomi.miui.ad.ssp.common.Constants;
import com.xiaomi.miui.ad.ssp.converter.mockad.MockAdConfigConverter;
import com.xiaomi.miui.ad.ssp.converter.mockad.MockAdInfoConverter;
import com.xiaomi.miui.ad.ssp.model.mockad.MockAdConfig;
import com.xiaomi.miui.ad.ssp.model.mockad.MockAdInfo;
import com.xiaomi.miui.ad.ssp.util.CommonUtils;
import com.xiaomi.miui.ad.ssp.util.HttpGetter;
import com.xiaomi.miui.ad.thrift.model.AdInfo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;

import java.util.*;
import java.util.concurrent.*;

@Slf4j
public class MockAdProxy {
    private static final MockAdProxy proxy = new MockAdProxy();

    public static MockAdProxy getInstance() {
        return proxy;
    }

    // 假广告配置缓存
    private Map<String, MockAdConfig> mockAdConfigCache = new HashMap<String, MockAdConfig>();
    // 假广告缓存
    private Map<String, MockAdInfo> mockAdInfoCache = new HashMap<String, MockAdInfo>();

    private Random ran = new Random();

    static {
        proxy.startTask();
    }

    // 每一分钟更新一次缓存
    private void startTask() {
        Runnable mockAdConfigTask = new MockAdConfigUpdater();
        Runnable mockAdInfoTask = new MockAdInfoUpdater();
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
        scheduledExecutorService.scheduleAtFixedRate(mockAdConfigTask, 0, 1, TimeUnit.MINUTES);
        scheduledExecutorService.scheduleAtFixedRate(mockAdInfoTask, 0, 1, TimeUnit.MINUTES);
    }

    private class MockAdConfigUpdater implements Runnable {
        @Override
        public void run() {
            log.info("Start get mockAdConfig from tools ...");
            try {
                long startTS = System.currentTimeMillis();
                String url = CommonUtils.getSspServiceHost() + Constants.HttpPath.MOCK_AD_CONFIG;
                String ret = HttpGetter.send(url);
                PerfCounter.count("ad.tools.mockad.config.http.get", 1L, System.currentTimeMillis() - startTS);

                List<MockAdConfig> mockAdConfigList = new ArrayList<MockAdConfig>();
                boolean isSucc = MockAdConfigConverter.convert(ret, mockAdConfigList);

                if (isSucc) {
                    Map<String, MockAdConfig> tmpMockAdConfigCache = new HashMap<String, MockAdConfig>();
                    for (MockAdConfig mockAdConfig : mockAdConfigList) {
                        if (mockAdConfig != null && StringUtils.isNotEmpty(mockAdConfig.getPlacementId())
                                && CollectionUtils.isNotEmpty(mockAdConfig.getTargetImeiSet())) {
                            tmpMockAdConfigCache.put(mockAdConfig.getPlacementId(), mockAdConfig);
                        }
                    }
                    mockAdConfigCache = tmpMockAdConfigCache;
                }
            } catch (Exception e) {
                log.error("get mockAdConfig from tools error");
            }
            log.info("Finish get mockAdConfig from tools task, cache size is {}", mockAdConfigCache.size());
        }
    }

    private class MockAdInfoUpdater implements Runnable {
        @Override
        public void run() {
            log.info("Start get mockAdInfo from tools ...");
            try {
                long startTS = System.currentTimeMillis();
                String url = CommonUtils.getSspServiceHost() + Constants.HttpPath.MOCK_AD_INFO;
                String ret = HttpGetter.send(url);
                PerfCounter.count("ad.tools.mockad.info.http.get", 1L, System.currentTimeMillis() - startTS);

                List<MockAdInfo> mockAdInfoList = new ArrayList<MockAdInfo>();
                boolean isSucc = MockAdInfoConverter.convert(ret, mockAdInfoList);

                if (isSucc) {
                    Map<String, MockAdInfo> tmpMockAdInfoCache = new HashMap<String, MockAdInfo>();
                    for (MockAdInfo mockAdInfo : mockAdInfoList) {
                        if (mockAdInfo != null && StringUtils.isNotEmpty(mockAdInfo.getName())) {
                            tmpMockAdInfoCache.put(mockAdInfo.getName(), mockAdInfo);
                        }
                    }
                    mockAdInfoCache = tmpMockAdInfoCache;

                }
            } catch (Exception e) {
                log.error("get mockAdInfo from tools error");
            }
            log.info("Finish get mockAdInfo from tools task, cache size is {}", mockAdInfoCache.size());
        }
    }

    public boolean isSetMockAd(String imei, String placementId) {
        if (!mockAdConfigCache.containsKey(placementId)) {
            return false;
        }
        MockAdConfig mockAdConfig = mockAdConfigCache.get(placementId);
        return mockAdConfig != null && mockAdConfig.getTargetImeiSet().contains(imei);
    }

    public List<AdInfo> getMockAdInfoList(String imei, String placementId) {
        if (!isSetMockAd(imei, placementId)) {
            return Collections.EMPTY_LIST;
        }

        MockAdConfig mockAdConfig = mockAdConfigCache.get(placementId);
        if (mockAdConfig == null || CollectionUtils.isEmpty(mockAdConfig.getAdNameLists())) {
            return Collections.EMPTY_LIST;
        }

        int random = ran.nextInt(mockAdConfig.getAdNameLists().size());
        List<String> adNameList = mockAdConfig.getAdNameLists().get(random);
        if (CollectionUtils.isEmpty(adNameList)) {
            return Collections.EMPTY_LIST;
        }
        List<AdInfo> adInfos = new ArrayList<AdInfo>();
        Map<String, MockAdInfo> tmpMockAdInfoCache = mockAdInfoCache;
        for (String adName : adNameList) {
            if (StringUtils.isNotEmpty(adName) && tmpMockAdInfoCache.containsKey(adName)
                    && tmpMockAdInfoCache.get(adName) != null) {
                adInfos.add(tmpMockAdInfoCache.get(adName).getAdInfo().deepCopy());
            }
        }
        return adInfos;
    }
}