#447

Committed 23 May 2026 01:52AM UTC coverage: 88.921% (-0.4%) from 89.31%

Build # #447

Build Type

push

Committed by

Commit Message

feat: allow customize DecodeFilter for kryo decoder

Coverage Stats

54 of 59 new or added lines in 8 files covered. (91.53%)

24 existing lines in 8 files now uncovered.

4976 of 5596 relevant lines covered (88.92%)

0.89 hits per line

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

91.78

/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> patterns = globalCacheConfig.getDecodeFilterPatterns();
        if (patterns != null && !patterns.isEmpty()) {
            f.addAllowPatterns(patterns.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> patterns = globalCacheConfig.getDecodeFilterPatterns();	1✔
91	if (patterns != null && !patterns.isEmpty()) {	1✔
92	f.addAllowPatterns(patterns.toArray(new String[0]));	1✔
93	}
94	}	1✔
95
96	protected CacheMonitorInstaller metricsMonitorInstaller() {
97	Duration interval = null;	1✔
98	if (globalCacheConfig.getStatIntervalMinutes() > 0) {	1✔
99	interval = Duration.ofMinutes(globalCacheConfig.getStatIntervalMinutes());	1✔
100	}
101
102	MetricsMonitorInstaller i = new MetricsMonitorInstaller(metricsCallback, interval);	1✔
103	i.init();	1✔
104	return i;	1✔
105	}
106
107	protected CacheMonitorInstaller notifyMonitorInstaller() {
108	return new NotifyMonitorInstaller(area -> globalCacheConfig.getRemoteCacheBuilders().get(area));	1✔
109	}
110
111	public CacheBuilderTemplate getCacheBuilderTemplate() {
112	return cacheBuilderTemplate;	1✔
113	}
114
115	@Override
116	public void doShutdown() {
117	try {
118	for (CacheMonitorInstaller i : cacheBuilderTemplate.getCacheMonitorInstallers()) {	1✔
119	if (i instanceof AbstractLifecycle) {	1✔
120	((AbstractLifecycle) i).shutdown();	1✔
121	}
122	}	1✔
UNCOV 123	} catch (Exception e) {	×
UNCOV 124	logger.error("close fail", e);	×
125	}	1✔
126	}	1✔
127
128	/**
129	* Keep this method for backward compatibility.
130	* NOTICE: there is no getter for encoderParser.
131	*/
132	public Function<Object, byte[]> parseValueEncoder(String valueEncoder) {
133	return encoderParser.parseEncoder(valueEncoder);	1✔
134	}
135
136	/**
137	* Keep this method for backward compatibility.
138	* NOTICE: there is no getter for encoderParser.
139	*/
140	public Function<byte[], Object> parseValueDecoder(String valueDecoder) {
141	return encoderParser.parseDecoder(valueDecoder);	1✔
142	}
143
144	/**
145	* Keep this method for backward compatibility.
146	* NOTICE: there is no getter for keyConvertorParser.
147	*/
148	public Function<Object, Object> parseKeyConvertor(String convertor) {
149	return keyConvertorParser.parseKeyConvertor(convertor);	1✔
150	}
151
152	public CacheNameGenerator createCacheNameGenerator(String[] hiddenPackages) {
153	return new DefaultCacheNameGenerator(hiddenPackages);	1✔
154	}
155
156	public CacheContext newContext(CacheManager cacheManager) {
157	return new CacheContext(cacheManager, this, globalCacheConfig);	1✔
158	}
159
160	public void setEncoderParser(EncoderParser encoderParser) {
UNCOV 161	this.encoderParser = encoderParser;	×
UNCOV 162	}	×
163
164	public void setKeyConvertorParser(KeyConvertorParser keyConvertorParser) {
UNCOV 165	this.keyConvertorParser = keyConvertorParser;	×
UNCOV 166	}	×
167
168	public GlobalCacheConfig getGlobalCacheConfig() {
169	return globalCacheConfig;	1✔
170	}
171
172	public void setGlobalCacheConfig(GlobalCacheConfig globalCacheConfig) {
173	this.globalCacheConfig = globalCacheConfig;	1✔
174	}	1✔
175
176	public void setMetricsCallback(Consumer<StatInfo> metricsCallback) {
177	this.metricsCallback = metricsCallback;	1✔
178	}	1✔
179
180	}

alibaba / jetcache / #447

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