#405

Committed 16 Apr 2024 05:58AM UTC coverage: 0.0% (-88.9%) from 88.866%

Build # #405

Build Type

push

Committed by

Commit Message

add encoding to fix coverage report

Run Details

0 of 5353 relevant lines covered (0.0%)

0.0 hits per line

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

0.0

/jetcache-anno/src/main/java/com/alicp/jetcache/anno/field/CreateCacheWrapper.java

package com.alicp.jetcache.anno.field;

import com.alicp.jetcache.Cache;
import com.alicp.jetcache.CacheManager;
import com.alicp.jetcache.RefreshPolicy;
import com.alicp.jetcache.anno.CacheConsts;
import com.alicp.jetcache.anno.CachePenetrationProtect;
import com.alicp.jetcache.anno.CacheRefresh;
import com.alicp.jetcache.anno.CreateCache;
import com.alicp.jetcache.anno.method.CacheConfigUtil;
import com.alicp.jetcache.anno.support.CacheNameGenerator;
import com.alicp.jetcache.anno.support.CachedAnnoConfig;
import com.alicp.jetcache.anno.support.ConfigProvider;
import com.alicp.jetcache.anno.support.GlobalCacheConfig;
import com.alicp.jetcache.anno.support.PenetrationProtectConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

import java.lang.reflect.Field;

/**
 * Created on 2016/12/13.
 *
 * @author huangli
 */
class CreateCacheWrapper {

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

    private Cache cache;

    private ConfigurableListableBeanFactory beanFactory;
    private CreateCache ann;
    private Field field;
    private RefreshPolicy refreshPolicy;
    private PenetrationProtectConfig protectConfig;

    public CreateCacheWrapper(ConfigurableListableBeanFactory beanFactory, CreateCache ann, Field field) {
        this.beanFactory = beanFactory;
        this.ann = ann;
        this.field = field;
        CacheRefresh cr = field.getAnnotation(CacheRefresh.class);
        if (cr != null) {
            refreshPolicy = CacheConfigUtil.parseRefreshPolicy(cr);
        }
        CachePenetrationProtect penetrateProtect = field.getAnnotation(CachePenetrationProtect.class);
        if (penetrateProtect != null) {
            protectConfig = CacheConfigUtil.parsePenetrationProtectConfig(penetrateProtect);
        }
        init();
    }

    private void init() {
        GlobalCacheConfig globalCacheConfig = beanFactory.getBean(GlobalCacheConfig.class);
        ConfigProvider configProvider = beanFactory.getBean(ConfigProvider.class);
        CacheManager cacheManager = beanFactory.getBean(CacheManager.class);
        if (cacheManager == null) {
            logger.error("There is no cache manager instance in spring context");
        }

        CachedAnnoConfig cac = new CachedAnnoConfig();
        cac.setArea(ann.area());
        cac.setName(ann.name());
        cac.setTimeUnit(ann.timeUnit());
        cac.setExpire(ann.expire());
        cac.setLocalExpire(ann.localExpire());
        cac.setCacheType(ann.cacheType());
        cac.setSyncLocal(ann.syncLocal());
        cac.setLocalLimit(ann.localLimit());
        cac.setSerialPolicy(ann.serialPolicy());
        cac.setKeyConvertor(ann.keyConvertor());

        cac.setRefreshPolicy(refreshPolicy);
        cac.setPenetrationProtectConfig(protectConfig);

        String cacheName = cac.getName();
        if (CacheConsts.isUndefined(cacheName)) {
            String[] hiddenPackages = globalCacheConfig.getHiddenPackages();
            CacheNameGenerator g = configProvider.createCacheNameGenerator(hiddenPackages);
            cacheName = g.generateCacheName(field);
        }
        cache = configProvider.newContext(cacheManager).__createOrGetCache(cac, ann.area(), cacheName);
    }

    public Cache getCache() {
        return cache;
    }
}

1	package com.alicp.jetcache.anno.field;
2
3	import com.alicp.jetcache.Cache;
4	import com.alicp.jetcache.CacheManager;
5	import com.alicp.jetcache.RefreshPolicy;
6	import com.alicp.jetcache.anno.CacheConsts;
7	import com.alicp.jetcache.anno.CachePenetrationProtect;
8	import com.alicp.jetcache.anno.CacheRefresh;
9	import com.alicp.jetcache.anno.CreateCache;
10	import com.alicp.jetcache.anno.method.CacheConfigUtil;
11	import com.alicp.jetcache.anno.support.CacheNameGenerator;
12	import com.alicp.jetcache.anno.support.CachedAnnoConfig;
13	import com.alicp.jetcache.anno.support.ConfigProvider;
14	import com.alicp.jetcache.anno.support.GlobalCacheConfig;
15	import com.alicp.jetcache.anno.support.PenetrationProtectConfig;
16	import org.slf4j.Logger;
17	import org.slf4j.LoggerFactory;
18	import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
19
20	import java.lang.reflect.Field;
21
22	/**
23	* Created on 2016/12/13.
24	*
25	* @author huangli
26	*/
27	class CreateCacheWrapper {
28
29	private static final Logger logger = LoggerFactory.getLogger(CreateCacheWrapper.class);	×
30
31	private Cache cache;
32
33	private ConfigurableListableBeanFactory beanFactory;
34	private CreateCache ann;
35	private Field field;
36	private RefreshPolicy refreshPolicy;
37	private PenetrationProtectConfig protectConfig;
38
39	public CreateCacheWrapper(ConfigurableListableBeanFactory beanFactory, CreateCache ann, Field field) {	×
40	this.beanFactory = beanFactory;	×
41	this.ann = ann;	×
42	this.field = field;	×
43	CacheRefresh cr = field.getAnnotation(CacheRefresh.class);	×
44	if (cr != null) {	×
45	refreshPolicy = CacheConfigUtil.parseRefreshPolicy(cr);	×
46	}
47	CachePenetrationProtect penetrateProtect = field.getAnnotation(CachePenetrationProtect.class);	×
48	if (penetrateProtect != null) {	×
49	protectConfig = CacheConfigUtil.parsePenetrationProtectConfig(penetrateProtect);	×
50	}
51	init();	×
52	}	×
53
54	private void init() {
55	GlobalCacheConfig globalCacheConfig = beanFactory.getBean(GlobalCacheConfig.class);	×
56	ConfigProvider configProvider = beanFactory.getBean(ConfigProvider.class);	×
57	CacheManager cacheManager = beanFactory.getBean(CacheManager.class);	×
58	if (cacheManager == null) {	×
59	logger.error("There is no cache manager instance in spring context");	×
60	}
61
62	CachedAnnoConfig cac = new CachedAnnoConfig();	×
63	cac.setArea(ann.area());	×
64	cac.setName(ann.name());	×
65	cac.setTimeUnit(ann.timeUnit());	×
66	cac.setExpire(ann.expire());	×
67	cac.setLocalExpire(ann.localExpire());	×
68	cac.setCacheType(ann.cacheType());	×
69	cac.setSyncLocal(ann.syncLocal());	×
70	cac.setLocalLimit(ann.localLimit());	×
71	cac.setSerialPolicy(ann.serialPolicy());	×
72	cac.setKeyConvertor(ann.keyConvertor());	×
73
74	cac.setRefreshPolicy(refreshPolicy);	×
75	cac.setPenetrationProtectConfig(protectConfig);	×
76
77	String cacheName = cac.getName();	×
78	if (CacheConsts.isUndefined(cacheName)) {	×
79	String[] hiddenPackages = globalCacheConfig.getHiddenPackages();	×
80	CacheNameGenerator g = configProvider.createCacheNameGenerator(hiddenPackages);	×
81	cacheName = g.generateCacheName(field);	×
82	}
83	cache = configProvider.newContext(cacheManager).__createOrGetCache(cac, ann.area(), cacheName);	×
84	}	×
85
86	public Cache getCache() {
87	return cache;	×
88	}
89	}

alibaba / jetcache / #405

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