Skip to content

Commit 8132c7d

Browse files
chrisdennischrisdennis
committed
Use public configuration builder APIs in parser where possible.
1 parent b95aade commit 8132c7d

File tree

6 files changed

+104
-81
lines changed

6 files changed

+104
-81
lines changed

‎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: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -23,15 +23,20 @@
2323
import java.net.URL;
2424
import java.security.PrivilegedAction;
2525
import java.util.ArrayList;
26+
import java.util.Arrays;
2627
import java.util.Collection;
2728
import java.util.Enumeration;
2829
import java.util.List;
30+
import java.util.Objects;
2931
import java.util.ServiceLoader;
3032
import java.util.function.Supplier;
33+
import java.util.stream.Stream;
3134

3235
import static java.security.AccessController.doPrivileged;
36+
import static java.util.Arrays.asList;
3337
import static java.util.Collections.enumeration;
3438
import static java.util.Collections.list;
39+
import static java.util.Objects.requireNonNull;
3540
import static java.util.stream.Collectors.toList;
3641
import static java.util.stream.Stream.concat;
3742
import static java.util.stream.Stream.of;
@@ -66,6 +71,36 @@ public static ClassLoader delegationChain(ClassLoader ... loaders) {
6671
return doPrivileged((PrivilegedAction<ClassLoader>) () -> new ChainedClassLoader(of(loaders).<Supplier<ClassLoader>>map(l -> () -> l).collect(toList())));
6772
}
6873

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

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

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

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

3032
import java.util.Collections;
3133
import java.util.Map;

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

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +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;
2324
import org.ehcache.core.HumanReadable;
2425

2526
/**

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

Lines changed: 20 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@
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;
32+
import org.ehcache.core.util.ClassLoading;
3333
import org.ehcache.xml.exceptions.XmlConfigurationException;
3434
import org.ehcache.xml.model.CacheTemplate;
3535
import org.ehcache.xml.model.CacheType;
@@ -51,11 +51,14 @@
5151
import javax.xml.validation.Schema;
5252
import java.math.BigInteger;
5353
import java.util.ArrayList;
54+
import java.util.Comparator;
5455
import java.util.HashMap;
5556
import java.util.List;
5657
import java.util.Map;
58+
import java.util.Optional;
5759
import java.util.Set;
5860

61+
import static org.ehcache.core.util.ClassLoading.classDistance;
5962
import static org.ehcache.xml.XmlConfiguration.CORE_SCHEMA_URL;
6063
import static org.ehcache.xml.XmlUtil.newSchema;
6164

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

8992
if (cacheTemplate.getHeap() != null) {
90-
resourcePoolsBuilder = resourcePoolsBuilder.with(parseHeapConfiguration(cacheTemplate.getHeap()));
93+
ResourceTypeWithPropSubst heapResource = cacheTemplate.getHeap().getValue();
94+
resourcePoolsBuilder = resourcePoolsBuilder.heap(heapResource.getValue().longValue(), parseUnit(heapResource));
9195
} else if (!cacheTemplate.getResources().isEmpty()) {
9296
for (Element element : cacheTemplate.getResources()) {
93-
ResourcePool resourcePool;
94-
if (!CORE_SCHEMA_NS.equals(element.getNamespaceURI())) {
95-
resourcePool = parseResourceExtension(element, classLoader);
96-
} else {
97+
if (CORE_SCHEMA_NS.equals(element.getNamespaceURI())) {
9798
try {
9899
Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
99100
unmarshaller.setEventHandler(new DefaultValidationEventHandler());
100101
Object resource = unmarshaller.unmarshal(element);
101102
if (resource instanceof Heap) {
102-
resourcePool = parseHeapConfiguration((Heap) resource);
103+
ResourceTypeWithPropSubst heap = ((Heap) resource).getValue();
104+
resourcePoolsBuilder = resourcePoolsBuilder.heap(heap.getValue().longValue(), parseUnit(heap));
103105
} 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);
106+
MemoryTypeWithPropSubst offheap = ((Offheap) resource).getValue();
107+
resourcePoolsBuilder = resourcePoolsBuilder.offheap(offheap.getValue().longValue(), parseMemory(offheap));
107108
} 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());
109+
PersistableMemoryTypeWithPropSubst disk = ((Disk) resource).getValue();
110+
resourcePoolsBuilder = resourcePoolsBuilder.disk(disk.getValue().longValue(), parseMemory(disk), disk.isPersistent());
111111
} else {
112112
// Someone updated the core resources without updating *this* code ...
113113
throw new AssertionError("Unrecognized resource: " + element + " / " + resource.getClass().getName());
114114
}
115115
} catch (JAXBException e) {
116116
throw new IllegalArgumentException("Can't find parser for resource: " + element, e);
117117
}
118+
} else {
119+
resourcePoolsBuilder = resourcePoolsBuilder.with(parseResourceExtension(element, classLoader));
118120
}
119-
120-
resourcePoolsBuilder = resourcePoolsBuilder.with(resourcePool);
121121
}
122122
} else {
123123
throw new XmlConfigurationException("No resources defined for the cache: " + cacheTemplate.id());
@@ -126,12 +126,6 @@ public ResourcePools parse(CacheTemplate cacheTemplate, ResourcePoolsBuilder res
126126
return resourcePoolsBuilder.build();
127127
}
128128

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-
135129
private static ResourceUnit parseUnit(ResourceTypeWithPropSubst resourceType) {
136130
if (resourceType.getUnit().equals(org.ehcache.xml.model.ResourceUnit.ENTRIES)) {
137131
return EntryUnit.ENTRIES;
@@ -190,14 +184,11 @@ public CacheType unparse(Document target, ResourcePools resourcePools, CacheType
190184
throw new XmlConfigurationException(e);
191185
}
192186
} 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-
}
187+
CacheResourceConfigurationParser parser = extensionParsers.stream().min(Comparator.comparing(p -> p.getResourceTypes().stream()
188+
.mapToDouble(rt -> classDistance(rt, resourcePool.getClass())).min().orElse(Double.POSITIVE_INFINITY)))
189+
.orElseThrow(() -> new AssertionError("Parser not found for resource type: " + resourceType));
190+
191+
resources.add(parser.unparse(target, resourcePool));
201192
}
202193
});
203194
return cacheType.withResources(OBJECT_FACTORY.createResourcesType().withResource(resources));

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

Lines changed: 20 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -23,7 +23,6 @@
2323
import org.ehcache.config.builders.ResourcePoolsBuilder;
2424
import org.ehcache.config.units.EntryUnit;
2525
import org.ehcache.config.units.MemoryUnit;
26-
import org.ehcache.impl.config.SizedResourcePoolImpl;
2726
import org.ehcache.xml.exceptions.XmlConfigurationException;
2827
import org.ehcache.xml.model.CacheTemplate;
2928
import org.ehcache.xml.model.CacheType;
@@ -43,6 +42,8 @@
4342

4443
import java.math.BigInteger;
4544
import java.util.ArrayList;
45+
import java.util.Collection;
46+
import java.util.Comparator;
4647
import java.util.HashMap;
4748
import java.util.List;
4849
import java.util.Map;
@@ -56,6 +57,8 @@
5657
import javax.xml.transform.stream.StreamSource;
5758
import javax.xml.validation.Schema;
5859

60+
import static java.util.stream.Collectors.toList;
61+
import static org.ehcache.core.util.ClassLoading.classDistance;
5962
import static org.ehcache.xml.XmlConfiguration.CORE_SCHEMA_URL;
6063
import static org.ehcache.xml.XmlUtil.newSchema;
6164

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

8992
if (cacheTemplate.getHeap() != null) {
90-
resourcePoolsBuilder = resourcePoolsBuilder.with(parseHeapConfiguration(cacheTemplate.getHeap()));
93+
ResourceTypeWithPropSubst heapResource = cacheTemplate.getHeap().getValue();
94+
resourcePoolsBuilder = resourcePoolsBuilder.heap(heapResource.getValue().longValue(), parseUnit(heapResource));
9195
} else if (!cacheTemplate.getResources().isEmpty()) {
9296
for (Element element : cacheTemplate.getResources()) {
93-
ResourcePool resourcePool;
94-
if (!CORE_SCHEMA_NS.equals(element.getNamespaceURI())) {
95-
resourcePool = parseResourceExtension(element, classLoader);
96-
} else {
97+
if (CORE_SCHEMA_NS.equals(element.getNamespaceURI())) {
9798
try {
9899
Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
99100
unmarshaller.setEventHandler(new DefaultValidationEventHandler());
100101
Object resource = unmarshaller.unmarshal(element);
101102
if (resource instanceof Heap) {
102-
resourcePool = parseHeapConfiguration((Heap) resource);
103+
ResourceTypeWithPropSubst heap = ((Heap) resource).getValue();
104+
resourcePoolsBuilder = resourcePoolsBuilder.heap(heap.getValue().longValue(), parseUnit(heap));
103105
} 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);
106+
MemoryTypeWithPropSubst offheap = ((Offheap) resource).getValue();
107+
resourcePoolsBuilder = resourcePoolsBuilder.offheap(offheap.getValue().longValue(), parseMemory(offheap));
107108
} 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());
109+
PersistableMemoryTypeWithPropSubst disk = ((Disk) resource).getValue();
110+
resourcePoolsBuilder = resourcePoolsBuilder.disk(disk.getValue().longValue(), parseMemory(disk), disk.isPersistent());
111111
} else {
112112
// Someone updated the core resources without updating *this* code ...
113113
throw new AssertionError("Unrecognized resource: " + element + " / " + resource.getClass().getName());
114114
}
115115
} catch (JAXBException e) {
116116
throw new IllegalArgumentException("Can't find parser for resource: " + element, e);
117117
}
118+
} else {
119+
resourcePoolsBuilder = resourcePoolsBuilder.with(parseResourceExtension(element, classLoader));
118120
}
119-
120-
resourcePoolsBuilder = resourcePoolsBuilder.with(resourcePool);
121121
}
122122
} else {
123123
throw new XmlConfigurationException("No resources defined for the cache: " + cacheTemplate.id());
@@ -126,12 +126,6 @@ public ResourcePools parse(CacheTemplate cacheTemplate, ResourcePoolsBuilder res
126126
return resourcePoolsBuilder.build();
127127
}
128128

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-
135129
private static ResourceUnit parseUnit(ResourceTypeWithPropSubst resourceType) {
136130
if (resourceType.getUnit().equals(org.ehcache.xml.model.ResourceUnit.ENTRIES)) {
137131
return EntryUnit.ENTRIES;
@@ -190,14 +184,11 @@ public CacheType unparse(Document target, ResourcePools resourcePools, CacheType
190184
throw new XmlConfigurationException(e);
191185
}
192186
} 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-
}
187+
CacheResourceConfigurationParser parser = extensionParsers.stream().min(Comparator.comparing(p -> p.getResourceTypes().stream()
188+
.mapToDouble(rt -> classDistance(rt, resourcePool.getClass())).min().orElse(Double.POSITIVE_INFINITY)))
189+
.orElseThrow(() -> new AssertionError("Parser not found for resource type: " + resourceType));
190+
191+
resources.add(parser.unparse(target, resourcePool));
201192
}
202193
});
203194
return cacheType.withResources(OBJECT_FACTORY.createResourcesType().withResource(resources));

0 commit comments

Comments
 (0)