Skip to content

Commit 66e6d42

Browse files
chrisdennischrisdennis
committed
Use public configuration builder APIs in parser where possible.
1 parent c09439b commit 66e6d42

6 files changed

Lines changed: 100 additions & 92 deletions

File tree

‎clustered/ehcache-client/src/main/java/org/ehcache/clustered/client/internal/config/xml/ClusteredResourceConfigurationParser.java‎

Lines changed: 26 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -16,9 +16,10 @@
1616

1717
package org.ehcache.clustered.client.internal.config.xml;
1818

19-
import org.ehcache.clustered.client.internal.config.ClusteredResourcePoolImpl;
20-
import org.ehcache.clustered.client.internal.config.DedicatedClusteredResourcePoolImpl;
21-
import org.ehcache.clustered.client.internal.config.SharedClusteredResourcePoolImpl;
19+
import org.ehcache.clustered.client.config.ClusteredResourcePool;
20+
import org.ehcache.clustered.client.config.DedicatedClusteredResourcePool;
21+
import org.ehcache.clustered.client.config.SharedClusteredResourcePool;
22+
import org.ehcache.clustered.client.config.builders.ClusteredResourcePoolBuilder;
2223
import org.ehcache.config.ResourcePool;
2324
import org.ehcache.config.units.MemoryUnit;
2425
import org.ehcache.xml.CacheResourceConfigurationParser;
@@ -57,7 +58,7 @@ public ResourcePool parse(final Element fragment, ClassLoader classLoader) {
5758
switch (elementName) {
5859
case SHARED_ELEMENT_NAME:
5960
final String sharing = parsePropertyOrString(fragment.getAttribute(SHARING_ELEMENT_NAME));
60-
return new SharedClusteredResourcePoolImpl(sharing);
61+
return ClusteredResourcePoolBuilder.clusteredShared(sharing);
6162

6263
case DEDICATED_ELEMENT_NAME:
6364
// 'from' attribute is optional on 'clustered-dedicated' element
@@ -85,41 +86,43 @@ public ResourcePool parse(final Element fragment, ClassLoader classLoader) {
8586
throw new XmlConfigurationException(String.format("XML configuration element <%s> value '%s' is not valid", elementName, sizeValue), e);
8687
}
8788

88-
return new DedicatedClusteredResourcePoolImpl(from, size, sizeUnits);
89+
return ClusteredResourcePoolBuilder.clusteredDedicated(from, size, sizeUnits);
8990
case CLUSTERED_ELEMENT_NAME:
90-
return new ClusteredResourcePoolImpl();
91+
return ClusteredResourcePoolBuilder.clustered();
9192
default:
9293
return null;
9394
}
9495
}
9596

9697
@Override
9798
public Element safeUnparse(Document doc, ResourcePool resourcePool) {
98-
Element rootElement = null;
99-
if (ClusteredResourcePoolImpl.class == resourcePool.getClass()) {
100-
rootElement = doc.createElementNS(NAMESPACE, TC_CLUSTERED_NAMESPACE_PREFIX + CLUSTERED_ELEMENT_NAME);
101-
} else if (DedicatedClusteredResourcePoolImpl.class == resourcePool.getClass()) {
102-
DedicatedClusteredResourcePoolImpl dedicatedClusteredResourcePool = (DedicatedClusteredResourcePoolImpl) resourcePool;
103-
rootElement = doc.createElementNS(NAMESPACE, TC_CLUSTERED_NAMESPACE_PREFIX + DEDICATED_ELEMENT_NAME);
99+
if (resourcePool instanceof SharedClusteredResourcePool) {
100+
SharedClusteredResourcePool sharedClusteredResourcePool = (SharedClusteredResourcePool) resourcePool;
101+
Element element = doc.createElementNS(NAMESPACE, TC_CLUSTERED_NAMESPACE_PREFIX + SHARED_ELEMENT_NAME);
102+
element.setAttribute(SHARING_ELEMENT_NAME, sharedClusteredResourcePool.getSharedResourcePool());
103+
return element;
104+
} else if (resourcePool instanceof DedicatedClusteredResourcePool) {
105+
DedicatedClusteredResourcePool dedicatedClusteredResourcePool = (DedicatedClusteredResourcePool) resourcePool;
106+
Element element = doc.createElementNS(NAMESPACE, TC_CLUSTERED_NAMESPACE_PREFIX + DEDICATED_ELEMENT_NAME);
104107
if (dedicatedClusteredResourcePool.getFromResource() != null) {
105-
rootElement.setAttribute(FROM_ELEMENT_NAME, dedicatedClusteredResourcePool.getFromResource());
108+
element.setAttribute(FROM_ELEMENT_NAME, dedicatedClusteredResourcePool.getFromResource());
106109
}
107-
rootElement.setAttribute(UNIT_ELEMENT_NAME, dedicatedClusteredResourcePool.getUnit().toString());
108-
rootElement.setTextContent(String.valueOf(dedicatedClusteredResourcePool.getSize()));
109-
} else if (SharedClusteredResourcePoolImpl.class == resourcePool.getClass()) {
110-
SharedClusteredResourcePoolImpl sharedClusteredResourcePool = (SharedClusteredResourcePoolImpl) resourcePool;
111-
rootElement = doc.createElementNS(NAMESPACE, TC_CLUSTERED_NAMESPACE_PREFIX + SHARED_ELEMENT_NAME);
112-
rootElement.setAttribute(SHARING_ELEMENT_NAME, sharedClusteredResourcePool.getSharedResourcePool());
110+
element.setAttribute(UNIT_ELEMENT_NAME, dedicatedClusteredResourcePool.getUnit().toString());
111+
element.setTextContent(String.valueOf(dedicatedClusteredResourcePool.getSize()));
112+
return element;
113+
} else if (resourcePool instanceof ClusteredResourcePool) {
114+
return doc.createElementNS(NAMESPACE, TC_CLUSTERED_NAMESPACE_PREFIX + CLUSTERED_ELEMENT_NAME);
115+
} else {
116+
return null;
113117
}
114-
return rootElement;
115118
}
116119

117120
@Override
118121
public Set<Class<? extends ResourcePool>> getResourceTypes() {
119122
return Collections.unmodifiableSet(new HashSet<>(Arrays.asList(
120-
ClusteredResourcePoolImpl.class,
121-
DedicatedClusteredResourcePoolImpl.class,
122-
SharedClusteredResourcePoolImpl.class
123+
ClusteredResourcePool.class,
124+
DedicatedClusteredResourcePool.class,
125+
SharedClusteredResourcePool.class
123126
)));
124127
}
125128
}

‎ehcache-core/src/main/java/org/ehcache/core/util/ClassLoading.java‎

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -28,8 +28,10 @@
2828
import java.util.List;
2929
import java.util.ServiceLoader;
3030
import java.util.function.Supplier;
31+
import java.util.stream.Stream;
3132

3233
import static java.security.AccessController.doPrivileged;
34+
import static java.util.Arrays.asList;
3335
import static java.util.Collections.enumeration;
3436
import static java.util.Collections.list;
3537
import static java.util.stream.Collectors.toList;
@@ -66,6 +68,36 @@ public static ClassLoader delegationChain(ClassLoader ... loaders) {
6668
return doPrivileged((PrivilegedAction<ClassLoader>) () -> new ChainedClassLoader(of(loaders).<Supplier<ClassLoader>>map(l -> () -> l).collect(toList())));
6769
}
6870

71+
public static double classDistance(Class<?> a, Class<?> b) {
72+
if (a.isAssignableFrom(b)) {
73+
if (a.isInterface()) {
74+
double depth = 0.5;
75+
for (Class<?> t = b; asList(t.getInterfaces()).contains(a); t = b.getSuperclass()) {
76+
depth++;
77+
}
78+
return depth;
79+
} else {
80+
double depth = 0;
81+
for (Class<?> t = b; !a.equals(t); t = b.getSuperclass()) {
82+
depth++;
83+
}
84+
return depth;
85+
}
86+
} else if (b.isAssignableFrom(a)) {
87+
return classDistance(b, a);
88+
} else {
89+
return Double.POSITIVE_INFINITY;
90+
}
91+
};
92+
93+
private static Stream<Class<?>> classHierarchy(Class<?> klazz) {
94+
if (Object.class.equals(klazz)) {
95+
return Stream.of(Object.class);
96+
} else {
97+
return Stream.concat(Stream.of(klazz), classHierarchy(klazz.getSuperclass()));
98+
}
99+
}
100+
69101
private static class ChainedClassLoader extends ClassLoader {
70102

71103
private final List<Supplier<ClassLoader>> loaders;

‎ehcache-impl/src/main/java/org/ehcache/config/builders/ResourcePoolsBuilder.java‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -26,6 +26,7 @@
2626
import org.ehcache.config.ResourceType;
2727
import org.ehcache.config.ResourceUnit;
2828
import org.ehcache.config.units.MemoryUnit;
29+
import org.slf4j.Logger;
2930
import org.slf4j.LoggerFactory;
3031

3132
import java.util.Collections;
@@ -44,6 +45,8 @@
4445
*/
4546
public class ResourcePoolsBuilder implements Builder<ResourcePools> {
4647

48+
private static final Logger LOGGER = LoggerFactory.getLogger(ResourcePoolsBuilder.class);
49+
4750
private final Map<ResourceType<?>, ResourcePool> resourcePools;
4851

4952
private ResourcePoolsBuilder() {
@@ -133,6 +136,9 @@ public ResourcePoolsBuilder withReplacing(ResourcePool resourcePool) {
133136
* @throws IllegalArgumentException if the set of resource pools already contains a pool for {@code type}
134137
*/
135138
public ResourcePoolsBuilder with(ResourceType<SizedResourcePool> type, long size, ResourceUnit unit, boolean persistent) {
139+
if (type == org.ehcache.config.ResourceType.Core.HEAP && unit instanceof MemoryUnit){
140+
LOGGER.info("Byte based heap resources are deprecated and will be removed in a future version.");
141+
}
136142
return with(new SizedResourcePoolImpl<>(type, size, unit, persistent));
137143
}
138144

‎ehcache-impl/src/main/java/org/ehcache/impl/config/SizedResourcePoolImpl.java‎

Lines changed: 0 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -20,10 +20,7 @@
2020
import org.ehcache.config.ResourceType;
2121
import org.ehcache.config.ResourceUnit;
2222
import org.ehcache.config.SizedResourcePool;
23-
import org.ehcache.config.units.MemoryUnit;
2423
import org.ehcache.core.HumanReadable;
25-
import org.slf4j.Logger;
26-
import org.slf4j.LoggerFactory;
2724

2825
/**
2926
* Implementation of the {@link SizedResourcePool} interface.
@@ -33,7 +30,6 @@
3330
public class SizedResourcePoolImpl<P extends SizedResourcePool> extends AbstractResourcePool<P, ResourceType<P>>
3431
implements SizedResourcePool, HumanReadable {
3532

36-
private static final Logger LOGGER = LoggerFactory.getLogger(SizedResourcePoolImpl.class);
3733
private final long size;
3834
private final ResourceUnit unit;
3935

@@ -56,9 +52,6 @@ public SizedResourcePoolImpl(ResourceType<P> type, long size, ResourceUnit unit,
5652
if (!type.isPersistable() && persistent) {
5753
throw new IllegalStateException("Non-persistable resource cannot be configured persistent");
5854
}
59-
if (type == org.ehcache.config.ResourceType.Core.HEAP && unit instanceof MemoryUnit){
60-
LOGGER.info("Byte based heap resources are deprecated and will be removed in a future version.");
61-
}
6255
this.size = size;
6356
this.unit = unit;
6457
}

‎ehcache-xml/src/jakarta/java/org/ehcache/xml/ResourceConfigurationParser.java‎

Lines changed: 18 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,6 @@
2929
import org.ehcache.config.builders.ResourcePoolsBuilder;
3030
import org.ehcache.config.units.EntryUnit;
3131
import org.ehcache.config.units.MemoryUnit;
32-
import org.ehcache.impl.config.SizedResourcePoolImpl;
3332
import org.ehcache.xml.exceptions.XmlConfigurationException;
3433
import org.ehcache.xml.model.CacheTemplate;
3534
import org.ehcache.xml.model.CacheType;
@@ -51,11 +50,11 @@
5150
import javax.xml.validation.Schema;
5251
import java.math.BigInteger;
5352
import java.util.ArrayList;
54-
import java.util.HashMap;
53+
import java.util.Comparator;
5554
import java.util.List;
56-
import java.util.Map;
5755
import java.util.Set;
5856

57+
import static org.ehcache.core.util.ClassLoading.classDistance;
5958
import static org.ehcache.xml.XmlConfiguration.CORE_SCHEMA_URL;
6059
import static org.ehcache.xml.XmlUtil.newSchema;
6160

@@ -87,37 +86,34 @@ public ResourceConfigurationParser(Set<CacheResourceConfigurationParser> extensi
8786
public ResourcePools parse(CacheTemplate cacheTemplate, ResourcePoolsBuilder resourcePoolsBuilder, ClassLoader classLoader) {
8887

8988
if (cacheTemplate.getHeap() != null) {
90-
resourcePoolsBuilder = resourcePoolsBuilder.with(parseHeapConfiguration(cacheTemplate.getHeap()));
89+
ResourceTypeWithPropSubst heapResource = cacheTemplate.getHeap().getValue();
90+
resourcePoolsBuilder = resourcePoolsBuilder.heap(heapResource.getValue().longValue(), parseUnit(heapResource));
9191
} else if (!cacheTemplate.getResources().isEmpty()) {
9292
for (Element element : cacheTemplate.getResources()) {
93-
ResourcePool resourcePool;
94-
if (!CORE_SCHEMA_NS.equals(element.getNamespaceURI())) {
95-
resourcePool = parseResourceExtension(element, classLoader);
96-
} else {
93+
if (CORE_SCHEMA_NS.equals(element.getNamespaceURI())) {
9794
try {
9895
Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
9996
unmarshaller.setEventHandler(new DefaultValidationEventHandler());
10097
Object resource = unmarshaller.unmarshal(element);
10198
if (resource instanceof Heap) {
102-
resourcePool = parseHeapConfiguration((Heap) resource);
99+
ResourceTypeWithPropSubst heap = ((Heap) resource).getValue();
100+
resourcePoolsBuilder = resourcePoolsBuilder.heap(heap.getValue().longValue(), parseUnit(heap));
103101
} else if (resource instanceof Offheap) {
104-
MemoryTypeWithPropSubst offheapResource = ((Offheap) resource).getValue();
105-
resourcePool = new SizedResourcePoolImpl<>(org.ehcache.config.ResourceType.Core.OFFHEAP,
106-
offheapResource.getValue().longValue(), parseMemory(offheapResource), false);
102+
MemoryTypeWithPropSubst offheap = ((Offheap) resource).getValue();
103+
resourcePoolsBuilder = resourcePoolsBuilder.offheap(offheap.getValue().longValue(), parseMemory(offheap));
107104
} else if (resource instanceof Disk) {
108-
PersistableMemoryTypeWithPropSubst diskResource = ((Disk) resource).getValue();
109-
resourcePool = new SizedResourcePoolImpl<>(org.ehcache.config.ResourceType.Core.DISK,
110-
diskResource.getValue().longValue(), parseMemory(diskResource), diskResource.isPersistent());
105+
PersistableMemoryTypeWithPropSubst disk = ((Disk) resource).getValue();
106+
resourcePoolsBuilder = resourcePoolsBuilder.disk(disk.getValue().longValue(), parseMemory(disk), disk.isPersistent());
111107
} else {
112108
// Someone updated the core resources without updating *this* code ...
113109
throw new AssertionError("Unrecognized resource: " + element + " / " + resource.getClass().getName());
114110
}
115111
} catch (JAXBException e) {
116112
throw new IllegalArgumentException("Can't find parser for resource: " + element, e);
117113
}
114+
} else {
115+
resourcePoolsBuilder = resourcePoolsBuilder.with(parseResourceExtension(element, classLoader));
118116
}
119-
120-
resourcePoolsBuilder = resourcePoolsBuilder.with(resourcePool);
121117
}
122118
} else {
123119
throw new XmlConfigurationException("No resources defined for the cache: " + cacheTemplate.id());
@@ -126,12 +122,6 @@ public ResourcePools parse(CacheTemplate cacheTemplate, ResourcePoolsBuilder res
126122
return resourcePoolsBuilder.build();
127123
}
128124

129-
private ResourcePool parseHeapConfiguration(Heap heap) {
130-
ResourceTypeWithPropSubst heapResource = heap.getValue();
131-
return new SizedResourcePoolImpl<>(org.ehcache.config.ResourceType.Core.HEAP,
132-
heapResource.getValue().longValue(), parseUnit(heapResource), false);
133-
}
134-
135125
private static ResourceUnit parseUnit(ResourceTypeWithPropSubst resourceType) {
136126
if (resourceType.getUnit().equals(org.ehcache.xml.model.ResourceUnit.ENTRIES)) {
137127
return EntryUnit.ENTRIES;
@@ -190,14 +180,11 @@ public CacheType unparse(Document target, ResourcePools resourcePools, CacheType
190180
throw new XmlConfigurationException(e);
191181
}
192182
} else {
193-
Map<Class<? extends ResourcePool>, CacheResourceConfigurationParser> parsers = new HashMap<>();
194-
extensionParsers.forEach(parser -> parser.getResourceTypes().forEach(rt -> parsers.put(rt, parser)));
195-
CacheResourceConfigurationParser parser = parsers.get(resourcePool.getClass());
196-
if (parser != null) {
197-
resources.add(parser.unparse(target, resourcePool));
198-
} else {
199-
throw new AssertionError("Parser not found for resource type: " + resourceType);
200-
}
183+
CacheResourceConfigurationParser parser = extensionParsers.stream().min(Comparator.comparing(p -> p.getResourceTypes().stream()
184+
.mapToDouble(rt -> classDistance(rt, resourcePool.getClass())).min().orElse(Double.POSITIVE_INFINITY)))
185+
.orElseThrow(() -> new AssertionError("Parser not found for resource type: " + resourceType));
186+
187+
resources.add(parser.unparse(target, resourcePool));
201188
}
202189
});
203190
return cacheType.withResources(OBJECT_FACTORY.createResourcesType().withResource(resources));

0 commit comments

Comments
 (0)