#448

Committed 23 May 2026 01:38PM UTC coverage: 89.341% (+0.4%) from 88.921%

Build # #448

Build Type

push

Committed by

Commit Message

fix: init fail if Kryo not in classpath

Coverage Stats

0 of 4 new or added lines in 1 file covered. (0.0%)

27 existing lines in 9 files now uncovered.

5029 of 5629 relevant lines covered (89.34%)

0.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.11

/jetcache-anno/src/main/java/com/alicp/jetcache/anno/support/ConfigProvider.java

package com.alicp.jetcache.anno.support;

import com.alicp.jetcache.CacheBuilder;
import com.alicp.jetcache.CacheManager;
import com.alicp.jetcache.embedded.EmbeddedCacheBuilder;
import com.alicp.jetcache.external.ExternalCacheBuilder;
import com.alicp.jetcache.support.AbstractLifecycle;
import com.alicp.jetcache.support.DecodeFilter;
import com.alicp.jetcache.support.StatInfo;
import com.alicp.jetcache.support.StatInfoLogger;
import com.alicp.jetcache.template.CacheBuilderTemplate;
import com.alicp.jetcache.template.CacheMonitorInstaller;
import com.alicp.jetcache.template.MetricsMonitorInstaller;
import com.alicp.jetcache.template.NotifyMonitorInstaller;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.time.Duration;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;

/**
 * Created on 2016/11/29.
 *
 * @author huangli
 */
public class ConfigProvider extends AbstractLifecycle {

    private static final Logger logger = LoggerFactory.getLogger(ConfigProvider.class);

    protected GlobalCacheConfig globalCacheConfig;

    protected EncoderParser encoderParser;
    protected KeyConvertorParser keyConvertorParser;
    private Consumer<StatInfo> metricsCallback;

    private CacheBuilderTemplate cacheBuilderTemplate;

    public ConfigProvider() {
        encoderParser = new DefaultEncoderParser();
        keyConvertorParser = new DefaultKeyConvertorParser();
        metricsCallback = new StatInfoLogger(false);
    }

    @Override
    protected void doInit() {
        cacheBuilderTemplate = new CacheBuilderTemplate(globalCacheConfig.isPenetrationProtect(),
                globalCacheConfig.isUseDefaultLocalExpireInMultiLevelCache(),
                globalCacheConfig.getLocalCacheBuilders(), globalCacheConfig.getRemoteCacheBuilders());
        for (CacheBuilder builder : globalCacheConfig.getLocalCacheBuilders().values()) {
            EmbeddedCacheBuilder eb = (EmbeddedCacheBuilder) builder;
            if (eb.getConfig().getKeyConvertor() instanceof ParserFunction) {
                ParserFunction f = (ParserFunction) eb.getConfig().getKeyConvertor();
                eb.setKeyConvertor(parseKeyConvertor(f.getValue()));
            }
        }
        for (CacheBuilder builder : globalCacheConfig.getRemoteCacheBuilders().values()) {
            ExternalCacheBuilder eb = (ExternalCacheBuilder) builder;
            if (eb.getConfig().getKeyConvertor() instanceof ParserFunction) {
                ParserFunction f = (ParserFunction) eb.getConfig().getKeyConvertor();
                eb.setKeyConvertor(parseKeyConvertor(f.getValue()));
            }
            if (eb.getConfig().getValueEncoder() instanceof ParserFunction) {
                ParserFunction f = (ParserFunction) eb.getConfig().getValueEncoder();
                eb.setValueEncoder(parseValueEncoder(f.getValue()));
            }
            if (eb.getConfig().getValueDecoder() instanceof ParserFunction) {
                ParserFunction f = (ParserFunction) eb.getConfig().getValueDecoder();
                eb.setValueDecoder(parseValueDecoder(f.getValue()));
            }
        }
        initDecodeFilter();
        initCacheMonitorInstallers();
    }

    protected void initCacheMonitorInstallers() {
        cacheBuilderTemplate.getCacheMonitorInstallers().add(metricsMonitorInstaller());
        cacheBuilderTemplate.getCacheMonitorInstallers().add(notifyMonitorInstaller());
        for (CacheMonitorInstaller i : cacheBuilderTemplate.getCacheMonitorInstallers()) {
            if (i instanceof AbstractLifecycle) {
                ((AbstractLifecycle) i).init();
            }
        }
    }

    private void initDecodeFilter() {
        DecodeFilter f = DecodeFilter.getDefault();
        f.setEnabled(globalCacheConfig.isDecodeFilterEnabled());
        List<String> allowPatterns = globalCacheConfig.getDecodeFilterAllowPatterns();
        if (allowPatterns != null && !allowPatterns.isEmpty()) {
            f.addAllowPatterns(allowPatterns.toArray(new String[0]));
        }
        List<String> denyPatterns = globalCacheConfig.getDecodeFilterDenyPatterns();
        if (denyPatterns != null && !denyPatterns.isEmpty()) {
            f.addDenyPatterns(denyPatterns.toArray(new String[0]));
        }
    }

    protected CacheMonitorInstaller metricsMonitorInstaller() {
        Duration interval = null;
        if (globalCacheConfig.getStatIntervalMinutes() > 0) {
            interval = Duration.ofMinutes(globalCacheConfig.getStatIntervalMinutes());
        }

        MetricsMonitorInstaller i = new MetricsMonitorInstaller(metricsCallback, interval);
        i.init();
        return i;
    }

    protected CacheMonitorInstaller notifyMonitorInstaller() {
        return new NotifyMonitorInstaller(area -> globalCacheConfig.getRemoteCacheBuilders().get(area));
    }

    public CacheBuilderTemplate getCacheBuilderTemplate() {
        return cacheBuilderTemplate;
    }

    @Override
    public void doShutdown() {
        try {
            for (CacheMonitorInstaller i : cacheBuilderTemplate.getCacheMonitorInstallers()) {
                if (i instanceof AbstractLifecycle) {
                    ((AbstractLifecycle) i).shutdown();
                }
            }
        } catch (Exception e) {
            logger.error("close fail", e);
        }
    }

    /**
     * Keep this method for backward compatibility.
     * NOTICE: there is no getter for encoderParser.
     */
    public Function<Object, byte[]> parseValueEncoder(String valueEncoder) {
        return encoderParser.parseEncoder(valueEncoder);
    }

    /**
     * Keep this method for backward compatibility.
     * NOTICE: there is no getter for encoderParser.
     */
    public Function<byte[], Object> parseValueDecoder(String valueDecoder) {
        return encoderParser.parseDecoder(valueDecoder);
    }

    /**
     * Keep this method for backward compatibility.
     * NOTICE: there is no getter for keyConvertorParser.
     */
    public Function<Object, Object> parseKeyConvertor(String convertor) {
        return keyConvertorParser.parseKeyConvertor(convertor);
    }

    public CacheNameGenerator createCacheNameGenerator(String[] hiddenPackages) {
        return new DefaultCacheNameGenerator(hiddenPackages);
    }

    public CacheContext newContext(CacheManager cacheManager) {
        return new CacheContext(cacheManager, this, globalCacheConfig);
    }

    public void setEncoderParser(EncoderParser encoderParser) {
        this.encoderParser = encoderParser;
    }

    public void setKeyConvertorParser(KeyConvertorParser keyConvertorParser) {
        this.keyConvertorParser = keyConvertorParser;
    }

    public GlobalCacheConfig getGlobalCacheConfig() {
        return globalCacheConfig;
    }

    public void setGlobalCacheConfig(GlobalCacheConfig globalCacheConfig) {
        this.globalCacheConfig = globalCacheConfig;
    }

    public void setMetricsCallback(Consumer<StatInfo> metricsCallback) {
        this.metricsCallback = metricsCallback;
    }

}

1	package com.alicp.jetcache.anno.support;
2
3	import com.alicp.jetcache.CacheBuilder;
4	import com.alicp.jetcache.CacheManager;
5	import com.alicp.jetcache.embedded.EmbeddedCacheBuilder;
6	import com.alicp.jetcache.external.ExternalCacheBuilder;
7	import com.alicp.jetcache.support.AbstractLifecycle;
8	import com.alicp.jetcache.support.DecodeFilter;
9	import com.alicp.jetcache.support.StatInfo;
10	import com.alicp.jetcache.support.StatInfoLogger;
11	import com.alicp.jetcache.template.CacheBuilderTemplate;
12	import com.alicp.jetcache.template.CacheMonitorInstaller;
13	import com.alicp.jetcache.template.MetricsMonitorInstaller;
14	import com.alicp.jetcache.template.NotifyMonitorInstaller;
15	import org.slf4j.Logger;
16	import org.slf4j.LoggerFactory;
17
18	import java.time.Duration;
19	import java.util.List;
20	import java.util.function.Consumer;
21	import java.util.function.Function;
22
23	/**
24	* Created on 2016/11/29.
25	*
26	* @author huangli
27	*/
28	public class ConfigProvider extends AbstractLifecycle {
29
30	private static final Logger logger = LoggerFactory.getLogger(ConfigProvider.class);	1✔
31
32	protected GlobalCacheConfig globalCacheConfig;
33
34	protected EncoderParser encoderParser;
35	protected KeyConvertorParser keyConvertorParser;
36	private Consumer<StatInfo> metricsCallback;
37
38	private CacheBuilderTemplate cacheBuilderTemplate;
39
40	public ConfigProvider() {	1✔
41	encoderParser = new DefaultEncoderParser();	1✔
42	keyConvertorParser = new DefaultKeyConvertorParser();	1✔
43	metricsCallback = new StatInfoLogger(false);	1✔
44	}	1✔
45
46	@Override
47	protected void doInit() {
48	cacheBuilderTemplate = new CacheBuilderTemplate(globalCacheConfig.isPenetrationProtect(),	1✔
49	globalCacheConfig.isUseDefaultLocalExpireInMultiLevelCache(),	1✔
50	globalCacheConfig.getLocalCacheBuilders(), globalCacheConfig.getRemoteCacheBuilders());	1✔
51	for (CacheBuilder builder : globalCacheConfig.getLocalCacheBuilders().values()) {	1✔
52	EmbeddedCacheBuilder eb = (EmbeddedCacheBuilder) builder;	1✔
53	if (eb.getConfig().getKeyConvertor() instanceof ParserFunction) {	1✔
54	ParserFunction f = (ParserFunction) eb.getConfig().getKeyConvertor();	1✔
55	eb.setKeyConvertor(parseKeyConvertor(f.getValue()));	1✔
56	}
57	}	1✔
58	for (CacheBuilder builder : globalCacheConfig.getRemoteCacheBuilders().values()) {	1✔
59	ExternalCacheBuilder eb = (ExternalCacheBuilder) builder;	1✔
60	if (eb.getConfig().getKeyConvertor() instanceof ParserFunction) {	1✔
61	ParserFunction f = (ParserFunction) eb.getConfig().getKeyConvertor();	1✔
62	eb.setKeyConvertor(parseKeyConvertor(f.getValue()));	1✔
63	}
64	if (eb.getConfig().getValueEncoder() instanceof ParserFunction) {	1✔
65	ParserFunction f = (ParserFunction) eb.getConfig().getValueEncoder();	1✔
66	eb.setValueEncoder(parseValueEncoder(f.getValue()));	1✔
67	}
68	if (eb.getConfig().getValueDecoder() instanceof ParserFunction) {	1✔
69	ParserFunction f = (ParserFunction) eb.getConfig().getValueDecoder();	1✔
70	eb.setValueDecoder(parseValueDecoder(f.getValue()));	1✔
71	}
72	}	1✔
73	initDecodeFilter();	1✔
74	initCacheMonitorInstallers();	1✔
75	}	1✔
76
77	protected void initCacheMonitorInstallers() {
78	cacheBuilderTemplate.getCacheMonitorInstallers().add(metricsMonitorInstaller());	1✔
79	cacheBuilderTemplate.getCacheMonitorInstallers().add(notifyMonitorInstaller());	1✔
80	for (CacheMonitorInstaller i : cacheBuilderTemplate.getCacheMonitorInstallers()) {	1✔
81	if (i instanceof AbstractLifecycle) {	1✔
82	((AbstractLifecycle) i).init();	1✔
83	}
84	}	1✔
85	}	1✔
86
87	private void initDecodeFilter() {
88	DecodeFilter f = DecodeFilter.getDefault();	1✔
89	f.setEnabled(globalCacheConfig.isDecodeFilterEnabled());	1✔
90	List<String> allowPatterns = globalCacheConfig.getDecodeFilterAllowPatterns();	1✔
91	if (allowPatterns != null && !allowPatterns.isEmpty()) {	1✔
92	f.addAllowPatterns(allowPatterns.toArray(new String[0]));	1✔
93	}
94	List<String> denyPatterns = globalCacheConfig.getDecodeFilterDenyPatterns();	1✔
95	if (denyPatterns != null && !denyPatterns.isEmpty()) {	1✔
96	f.addDenyPatterns(denyPatterns.toArray(new String[0]));	1✔
97	}
98	}	1✔
99
100	protected CacheMonitorInstaller metricsMonitorInstaller() {
101	Duration interval = null;	1✔
102	if (globalCacheConfig.getStatIntervalMinutes() > 0) {	1✔
103	interval = Duration.ofMinutes(globalCacheConfig.getStatIntervalMinutes());	1✔
104	}
105
106	MetricsMonitorInstaller i = new MetricsMonitorInstaller(metricsCallback, interval);	1✔
107	i.init();	1✔
108	return i;	1✔
109	}
110
111	protected CacheMonitorInstaller notifyMonitorInstaller() {
112	return new NotifyMonitorInstaller(area -> globalCacheConfig.getRemoteCacheBuilders().get(area));	1✔
113	}
114
115	public CacheBuilderTemplate getCacheBuilderTemplate() {
116	return cacheBuilderTemplate;	1✔
117	}
118
119	@Override
120	public void doShutdown() {
121	try {
122	for (CacheMonitorInstaller i : cacheBuilderTemplate.getCacheMonitorInstallers()) {	1✔
123	if (i instanceof AbstractLifecycle) {	1✔
124	((AbstractLifecycle) i).shutdown();	1✔
125	}
126	}	1✔
UNCOV 127	} catch (Exception e) {	×
UNCOV 128	logger.error("close fail", e);	×
129	}	1✔
130	}	1✔
131
132	/**
133	* Keep this method for backward compatibility.
134	* NOTICE: there is no getter for encoderParser.
135	*/
136	public Function<Object, byte[]> parseValueEncoder(String valueEncoder) {
137	return encoderParser.parseEncoder(valueEncoder);	1✔
138	}
139
140	/**
141	* Keep this method for backward compatibility.
142	* NOTICE: there is no getter for encoderParser.
143	*/
144	public Function<byte[], Object> parseValueDecoder(String valueDecoder) {
145	return encoderParser.parseDecoder(valueDecoder);	1✔
146	}
147
148	/**
149	* Keep this method for backward compatibility.
150	* NOTICE: there is no getter for keyConvertorParser.
151	*/
152	public Function<Object, Object> parseKeyConvertor(String convertor) {
153	return keyConvertorParser.parseKeyConvertor(convertor);	1✔
154	}
155
156	public CacheNameGenerator createCacheNameGenerator(String[] hiddenPackages) {
157	return new DefaultCacheNameGenerator(hiddenPackages);	1✔
158	}
159
160	public CacheContext newContext(CacheManager cacheManager) {
161	return new CacheContext(cacheManager, this, globalCacheConfig);	1✔
162	}
163
164	public void setEncoderParser(EncoderParser encoderParser) {
165	this.encoderParser = encoderParser;	×
166	}	×
167
168	public void setKeyConvertorParser(KeyConvertorParser keyConvertorParser) {
UNCOV 169	this.keyConvertorParser = keyConvertorParser;	×
UNCOV 170	}	×
171
172	public GlobalCacheConfig getGlobalCacheConfig() {
173	return globalCacheConfig;	1✔
174	}
175
176	public void setGlobalCacheConfig(GlobalCacheConfig globalCacheConfig) {
177	this.globalCacheConfig = globalCacheConfig;	1✔
178	}	1✔
179
180	public void setMetricsCallback(Consumer<StatInfo> metricsCallback) {
181	this.metricsCallback = metricsCallback;	1✔
182	}	1✔
183
184	}

alibaba / jetcache / #448

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous