![[Jenkins]](/ci/static/a01a62b1/images/svgs/logo.svg){kind=logo}
Package: SystemRoleFactorySupport
SystemRoleFactorySupport
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| SystemRoleFactorySupport() |
|
|
|
|
|
||||||||||||||||||||
| findAllImplementedInterfacesOf(Class) |
|
|
|
|
|
||||||||||||||||||||
| findContextTypeForRole(Class) |
|
|
|
|
|
||||||||||||||||||||
| findDatumTypesForRole(Class) |
|
|
|
|
|
||||||||||||||||||||
| findRoleImplementationsFor(Class, Class) |
|
|
|
|
|
||||||||||||||||||||
| findRoles(Object, Class) |
|
|
|
|
|
||||||||||||||||||||
| findTypeOf(Object) |
|
|
|
|
|
||||||||||||||||||||
| getBean(Class) |
|
|
|
|
|
||||||||||||||||||||
| getParameterValues(Class[], Class, Object, Optional, Optional) |
|
|
|
|
|
||||||||||||||||||||
| lambda$logRoles$0(Map.Entry) |
|
|
|
|
|
||||||||||||||||||||
| lambda$logRoles$1(Map.Entry) |
|
|
|
|
|
||||||||||||||||||||
| logChanges(OwnerAndRole, Set, Set) |
|
|
|
|
|
||||||||||||||||||||
| logRoles() |
|
|
|
|
|
||||||||||||||||||||
| scan(Collection) |
|
|
|
|
|
||||||||||||||||||||
| static {...} |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /*
2: * *************************************************************************************************************************************************************
3: *
4: * TheseFoolishThings: Miscellaneous utilities
5: * http://tidalwave.it/projects/thesefoolishthings
6: *
7: * Copyright (C) 2009 - 2024 by Tidalwave s.a.s. (http://tidalwave.it)
8: *
9: * *************************************************************************************************************************************************************
10: *
11: * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
12: * You may obtain a copy of the License at
13: *
14: * http://www.apache.org/licenses/LICENSE-2.0
15: *
16: * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
17: * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
18: *
19: * *************************************************************************************************************************************************************
20: *
21: * git clone https://bitbucket.org/tidalwave/thesefoolishthings-src
22: * git clone https://github.com/tidalwave-it/thesefoolishthings-src
23: *
24: * *************************************************************************************************************************************************************
25: */
26: package it.tidalwave.role.spi;
27:
28: import java.lang.reflect.InvocationTargetException;
29: import javax.annotation.Nonnull;
30: import java.util.ArrayList;
31: import java.util.Collection;
32: import java.util.HashSet;
33: import java.util.List;
34: import java.util.Map;
35: import java.util.Optional;
36: import java.util.Set;
37: import java.util.SortedSet;
38: import java.util.TreeSet;
39: import it.tidalwave.util.ContextManager;
40: import it.tidalwave.util.annotation.VisibleForTesting;
41: import it.tidalwave.role.impl.MultiMap;
42: import it.tidalwave.role.impl.OwnerAndRole;
43: import it.tidalwave.dci.annotation.DciRole;
44: import lombok.extern.slf4j.Slf4j;
45: import static java.util.Comparator.*;
46: import static it.tidalwave.util.ShortNames.*;
47:
48: /***************************************************************************************************************************************************************
49: *
50: * A basic implementation of a {@link SystemRoleFactory}. This class must be specialized to:
51: *
52: * <ol>
53: * <li>discover roles (see {@link #scan(java.util.Collection)}</li>
54: * <li>associate roles to a datum (see {@link #findDatumTypesForRole(java.lang.Class)}</li>
55: * <li>associate roles to contexts (see {@link #findContextTypeForRole(java.lang.Class)}</li>
56: * <li>eventually retrieve beans to inject in created roles (see {@link #getBean(java.lang.Class)}</li>
57: * </ol>
58: *
59: * Specializations might use annotations or configuration files to accomplish these tasks.
60: *
61: * @author Fabrizio Giudici
62: *
63: **************************************************************************************************************************************************************/
64: @Slf4j
65: public abstract class SystemRoleFactorySupport implements SystemRoleFactory
66: {
67: @VisibleForTesting final MultiMap<OwnerAndRole, Class<?>> roleMapByOwnerAndRole = new MultiMap<>();
68:
69: // FIXME: use ConcurrentHashMap
70: @VisibleForTesting final Set<OwnerAndRole> alreadyScanned = new HashSet<>();
71:
72: /***********************************************************************************************************************************************************
73: * {@inheritDoc}
74: **********************************************************************************************************************************************************/
75: @Override @Nonnull
76: public synchronized <T> List<T> findRoles (@Nonnull final Object datum, @Nonnull final Class<? extends T> roleType)
77: {
78: log.trace("findRoles({}, {})", shortId(datum), shortName(roleType));
79: final Class<?> datumType = findTypeOf(datum);
80: final List<T> roles = new ArrayList<>();
81: final var roleImplementationTypes = findRoleImplementationsFor(datumType, roleType);
82:
83:• outer: for (final var roleImplementationType : roleImplementationTypes)
84: {
85:• for (final var constructor : roleImplementationType.getDeclaredConstructors())
86: {
87: log.trace(">>>> trying constructor {}", constructor);
88: final var parameterTypes = constructor.getParameterTypes();
89: Optional<?> context = Optional.empty();
90: final var contextType = findContextTypeForRole(roleImplementationType);
91:
92:• if (contextType.isPresent())
93: {
94: // With DI frameworks such as Spring it's better to avoid eager initializations of references
95: final var contextManager = ContextManager.getInstance();
96: log.trace(">>>> contexts: {}", shortIds(contextManager.getContexts()));
97: context = contextManager.findContextOfType(contextType.get());
98:
99:• if (context.isEmpty())
100: {
101: log.trace(">>>> role {} discarded, can't find context: {}",
102: shortName(roleImplementationType), shortName(contextType.get()));
103: continue outer;
104: }
105: }
106:
107: try
108: {
109: final var params = getParameterValues(parameterTypes, datumType, datum, contextType, context);
110: roles.add(roleType.cast(constructor.newInstance(params)));
111: break;
112: }
113: catch (InstantiationException | IllegalAccessException
114: | IllegalArgumentException | InvocationTargetException e)
115: {
116: log.error("Could not instantiate role of type " + roleImplementationType, e);
117: }
118: }
119: }
120:
121:• if (log.isTraceEnabled())
122: {
123: log.trace(">>>> findRoles() returning: {}", shortIds(roles));
124: }
125:
126: return roles;
127: }
128:
129: /***********************************************************************************************************************************************************
130: * Prepare the constructor parameters out of the given expected types. Parameters will be eventually made of the
131: * given datum, context, and other objects returned by {@link #getBean(java.lang.Class)}.
132: *
133: * @param parameterTypes the expected types
134: * @param datumClass the type of the datum
135: * @param datum the datum
136: * @param contextClass the type of the context
137: * @param context the context
138: **********************************************************************************************************************************************************/
139: @Nonnull
140: private Object[] getParameterValues (@Nonnull final Class<?>[] parameterTypes,
141: @Nonnull final Class<?> datumClass,
142: @Nonnull final Object datum,
143: @Nonnull final Optional<Class<?>> contextClass,
144: @Nonnull final Optional<?> context)
145: {
146: final var values = new ArrayList<>();
147:
148:• for (final var parameterType : parameterTypes)
149: {
150:• if (parameterType.isAssignableFrom(datumClass))
151: {
152: values.add(datum);
153: }
154:• else if (contextClass.isPresent() && parameterType.isAssignableFrom(contextClass.get()))
155: {
156: values.add(context.orElse(null));
157: }
158: else // generic injection
159: {
160: // FIXME: it's injecting null, but perhaps should it throw exception?
161: values.add(getBean(parameterType).orElse(null));
162: }
163: }
164:
165: log.trace(">>>> constructor parameters: {}", values);
166: return values.toArray();
167: }
168:
169: /***********************************************************************************************************************************************************
170: * Finds the role implementations for the given owner type and role type. This method might discover new
171: * implementations that weren't found during the initial scan, since the initial scan can't go down in a
172: * hierarchy; that is, given a Base class or interface with some associated roles, it can't associate those roles
173: * to subclasses (or implementations) of Base. Now we can navigate up the hierarchy and complete the picture.
174: * Each new discovered role is added into the map, so the next time scanning will be faster.
175: *
176: * @param datumType the type of the datum
177: * @param roleType the type of the role to find
178: * @return the types of role implementations
179: **********************************************************************************************************************************************************/
180: @Nonnull
181: @VisibleForTesting synchronized <T> Set<Class<? extends T>> findRoleImplementationsFor (
182: @Nonnull final Class<?> datumType,
183: @Nonnull final Class<T> roleType)
184: {
185: final var datumAndRole = new OwnerAndRole(datumType, roleType);
186:
187:• if (!alreadyScanned.contains(datumAndRole))
188: {
189: alreadyScanned.add(datumAndRole);
190: final var before = new HashSet<>(roleMapByOwnerAndRole.getValues(datumAndRole));
191:
192:• for (final var superDatumAndRole : datumAndRole.getSuper())
193: {
194: roleMapByOwnerAndRole.addAll(datumAndRole, roleMapByOwnerAndRole.getValues(superDatumAndRole));
195: }
196:
197: final var after = new HashSet<>(roleMapByOwnerAndRole.getValues(datumAndRole));
198: logChanges(datumAndRole, before, after);
199: }
200:
201: return (Set<Class<? extends T>>)(Set)roleMapByOwnerAndRole.getValues(datumAndRole);
202: }
203:
204: /***********************************************************************************************************************************************************
205: * Scans all the given role implementation classes and build a map of roles by owner class.
206: *
207: * @param roleImplementationTypes the types of role implementations to scan
208: **********************************************************************************************************************************************************/
209: protected synchronized void scan (@Nonnull final Collection<Class<?>> roleImplementationTypes)
210: {
211: log.debug("scan({})", shortNames(roleImplementationTypes));
212:
213:• for (final var roleImplementationType : roleImplementationTypes)
214: {
215:• for (final var datumType : findDatumTypesForRole(roleImplementationType))
216: {
217:• for (final var roleType : findAllImplementedInterfacesOf(roleImplementationType))
218: {
219:• if (!"org.springframework.beans.factory.aspectj.ConfigurableObject".equals(roleType.getName()))
220: {
221: roleMapByOwnerAndRole.add(new OwnerAndRole(datumType, roleType), roleImplementationType);
222: }
223: }
224: }
225: }
226:
227: logRoles();
228: }
229:
230: /***********************************************************************************************************************************************************
231: * Finds all the interfaces implemented by a given class, including those eventually implemented by superclasses
232: * and interfaces that are indirectly implemented (e.g. C implements I1, I1 extends I2).
233: *
234: * @param clazz the class to inspect
235: * @return the implemented interfaces
236: **********************************************************************************************************************************************************/
237: @Nonnull
238: @VisibleForTesting static SortedSet<Class<?>> findAllImplementedInterfacesOf (@Nonnull final Class<?> clazz)
239: {
240: final SortedSet<Class<?>> interfaces = new TreeSet<>(comparing(Class::getName));
241: interfaces.addAll(List.of(clazz.getInterfaces()));
242:
243:• for (final var interface_ : interfaces)
244: {
245: interfaces.addAll(findAllImplementedInterfacesOf(interface_));
246: }
247:
248:• if (clazz.getSuperclass() != null)
249: {
250: interfaces.addAll(findAllImplementedInterfacesOf(clazz.getSuperclass()));
251: }
252:
253: return interfaces;
254: }
255:
256: /***********************************************************************************************************************************************************
257: * Retrieves an extra bean.
258: *
259: * @param <T> the static type of the bean
260: * @param beanType the dynamic type of the bean
261: * @return the bean
262: **********************************************************************************************************************************************************/
263: @Nonnull
264: protected <T> Optional<T> getBean (@Nonnull final Class<T> beanType)
265: {
266: return Optional.empty();
267: }
268:
269: /***********************************************************************************************************************************************************
270: * Returns the type of the context associated to the given role implementation type.
271: *
272: * @param roleImplementationType the role type
273: * @return the context type
274: **********************************************************************************************************************************************************/
275: @Nonnull
276: protected Optional<Class<?>> findContextTypeForRole (@Nonnull final Class<?> roleImplementationType)
277: {
278: final var contextClass = roleImplementationType.getAnnotation(DciRole.class).context();
279:• return (contextClass == DciRole.NoContext.class) ? Optional.empty() : Optional.of(contextClass);
280: }
281:
282: /***********************************************************************************************************************************************************
283: * Returns the valid datum types for the given role implementation type.
284: *
285: * @param roleImplementationType the role type
286: * @return the datum types
287: **********************************************************************************************************************************************************/
288: @Nonnull
289: protected Class<?>[] findDatumTypesForRole (@Nonnull final Class<?> roleImplementationType)
290: {
291: return roleImplementationType.getAnnotation(DciRole.class).datumType();
292: }
293:
294: /***********************************************************************************************************************************************************
295: **********************************************************************************************************************************************************/
296: private void logChanges (@Nonnull final OwnerAndRole ownerAndRole,
297: @Nonnull final Set<Class<?>> before,
298: @Nonnull final Set<Class<?>> after)
299: {
300: after.removeAll(before);
301:
302:• if (!after.isEmpty())
303: {
304: log.debug(">>>>>>> added implementations: {} -> {}", ownerAndRole, shortNames(after));
305:
306:• if (log.isTraceEnabled()) // yes, trace
307: {
308: logRoles();
309: }
310: }
311: }
312:
313: /***********************************************************************************************************************************************************
314: **********************************************************************************************************************************************************/
315: public void logRoles()
316: {
317: log.debug("Configured roles:");
318:
319: final var entries = new ArrayList<>(roleMapByOwnerAndRole.entrySet());
320: entries.sort(comparing((Map.Entry<OwnerAndRole, Set<Class<?>>> e) -> e.getKey().getOwnerClass().getName())
321: .thenComparing(e -> e.getKey().getRoleClass().getName()));
322:
323:• for (final var entry : entries)
324: {
325: log.debug(">>>> {}: {} -> {}",
326: shortName(entry.getKey().getOwnerClass()),
327: shortName(entry.getKey().getRoleClass()),
328: shortNames(entry.getValue()));
329: }
330: }
331:
332: /***********************************************************************************************************************************************************
333: * Returns the type of an object, taking care of mocks created by Mockito, for which the implemented interface is
334: * returned.
335: *
336: * @param object the object
337: * @return the object type
338: **********************************************************************************************************************************************************/
339: @Nonnull
340: @VisibleForTesting static <T> Class<T> findTypeOf (@Nonnull final T object)
341: {
342: var ownerClass = object.getClass();
343:
344:• if (ownerClass.toString().contains("MockitoMock"))
345: {
346: ownerClass = ownerClass.getInterfaces()[0]; // 1st is the original class, 2nd is CGLIB proxy
347:
348:• if (log.isTraceEnabled())
349: {
350: log.trace(">>>> owner is a mock {} implementing {}",
351: shortName(ownerClass), shortNames(List.of(ownerClass.getInterfaces())));
352: log.trace(">>>> owner class replaced with {}", shortName(ownerClass));
353: }
354: }
355:
356: return (Class<T>)ownerClass;
357: }
358: }