Method: hasInjectAnnotation(Field)

1: /*
2: * *************************************************************************************************************************************************************
3: *
4: * TheseFoolishThings: Miscellaneous utilities
5: * http://tidalwave.it/projects/thesefoolishthings
6: *
7: * Copyright (C) 2009 - 2025 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.util;
27:
28: import java.lang.annotation.Annotation;
29: import java.lang.reflect.Array;
30: import java.lang.reflect.Field;
31: import java.lang.reflect.GenericArrayType;
32: import java.lang.reflect.InvocationTargetException;
33: import java.lang.reflect.ParameterizedType;
34: import java.lang.reflect.Type;
35: import java.lang.reflect.TypeVariable;
36: import javax.annotation.CheckForNull;
37: import javax.annotation.Nonnull;
38: import java.util.ArrayList;
39: import java.util.Arrays;
40: import java.util.HashMap;
41: import java.util.List;
42: import java.util.Map;
43: import lombok.extern.slf4j.Slf4j;
44: import static java.util.Objects.requireNonNull;
45: import static java.util.stream.Collectors.*;
46: import static it.tidalwave.util.ShortNames.*;
47:
48: /***************************************************************************************************************************************************************
49: *
50: * Adapted from <a href="http://www.artima.com/weblogs/viewpost.jsp?thread=208860">this article</a>
51: *
52: * @author Ian Robertson
53: * @author Fabrizio Giudici
54: *
55: **************************************************************************************************************************************************************/
56: @Slf4j
57: public class ReflectionUtils
58: {
59: private static final List<String> INJECT_CLASS_NAMES = List.of("javax.inject.Inject", "jakarta.inject.Inject");
60:
61: /***********************************************************************************************************************************************************
62: * Get the actual type arguments a subclass has used to extend a generic base class. Note: if the base class is an interface, this method will work only
63: * if it is the first inherited interface in childClass.
64: *
65: * @param <T> the static type of the base class
66: * @param baseClass the base class
67: * @param childClass the subclass
68: * @return a list of the raw classes for the actual type arguments.
69: **********************************************************************************************************************************************************/
70: @Nonnull
71: public static <T> List<Class<?>> getTypeArguments (@Nonnull final Class<T> baseClass,
72: @Nonnull final Class<? extends T> childClass)
73: {
74: final Map<Type, Type> resolvedTypes = new HashMap<>();
75: Type type = childClass;
76:
77: // start walking up the inheritance hierarchy until we hit baseClass
78: while (!baseClass.equals(getClass(type)))
79: {
80: if (type instanceof Class<?>)
81: {
82: if (baseClass.isInterface())
83: {
84: type = ((Class<?>)type).getGenericInterfaces()[0]; // FIXME: works only for one interface in hierarchy
85: }
86: else
87: {
88: type = ((Class<?>)type).getGenericSuperclass();
89: }
90: // there is no useful information for us in raw types, so just keep going.
91: }
92: else
93: {
94: final var parameterizedType = (ParameterizedType) type;
95: final var rawType = (Class<?>) parameterizedType.getRawType();
96: final var actualTypeArguments = parameterizedType.getActualTypeArguments();
97: final TypeVariable<?>[] typeParameters = rawType.getTypeParameters();
98:
99: for (var i = 0; i < actualTypeArguments.length; i++)
100: {
101: resolvedTypes.put(typeParameters[i], actualTypeArguments[i]);
102: }
103:
104: if (!rawType.equals(baseClass))
105: {
106: type = rawType.getGenericSuperclass();
107: }
108: }
109: }
110:
111: // finally, for each actual type argument provided to baseClass, determine (if possible)
112: // the raw class for that type argument.
113: final Type[] actualTypeArguments;
114:
115: if (type instanceof Class)
116: {
117: actualTypeArguments = ((Class<?>)type).getTypeParameters();
118: }
119: else
120: {
121: actualTypeArguments = ((ParameterizedType)type).getActualTypeArguments();
122: }
123:
124: final var typeArgumentsAsClasses = new ArrayList<Class<?>>();
125:
126: // resolve types by chasing down type variables.
127: for (var baseType : actualTypeArguments)
128: {
129: while (resolvedTypes.containsKey(baseType))
130: {
131: baseType = resolvedTypes.get(baseType);
132: }
133:
134: typeArgumentsAsClasses.add(getClass(baseType));
135: }
136:
137: return typeArgumentsAsClasses;
138: }
139:
140: /***********************************************************************************************************************************************************
141: * Instantiates an object of the given class performing dependency injections through the constructor.
142: *
143: * @param <T> the generic type of the object to instantiate
144: * @param type the dynamic type of the object to instantiate; it is expected to have a single constructor
145: * @param beans the bag of objects to instantiate
146: * @return the new instance
147: * @throws RuntimeException if something fails
148: * @since 3.2-ALPHA-17
149: **********************************************************************************************************************************************************/
150: public static <T> T instantiateWithDependencies (@Nonnull final Class<? extends T> type,
151: @Nonnull final Map<Class<?>, Object> beans)
152: {
153: try
154: {
155: log.debug("instantiateWithDependencies({}, {})", shortName(type), shortIds(beans.values()));
156: final var constructors = type.getConstructors();
157:
158: if (constructors.length > 1)
159: {
160: throw new RuntimeException("Multiple constructors in " + type);
161: }
162:
163: final var parameters = Arrays.stream(constructors[0].getParameterTypes()).map(beans::get).collect(toList());
164:
165: log.trace(">>>> ctor arguments: {}", shortIds(parameters));
166: return type.cast(constructors[0].newInstance(parameters.toArray()));
167: }
168: catch (InstantiationException | IllegalAccessException | InvocationTargetException e)
169: {
170: throw new RuntimeException(e);
171: }
172: }
173:
174: /***********************************************************************************************************************************************************
175: * Performs dependency injection to an object by means of field introspection.
176: *
177: * @param object the object
178: * @param beans the bag of objects to instantiate
179: * @since 3.2-ALPHA-17
180: **********************************************************************************************************************************************************/
181: public static void injectDependencies (@Nonnull final Object object, @Nonnull final Map<Class<?>, Object> beans)
182: {
183: for (final var field : object.getClass().getDeclaredFields())
184: {
185: if (hasInjectAnnotation(field))
186: {
187: field.setAccessible(true);
188: final var type = field.getType();
189: final var dependency = beans.get(type);
190:
191: if (dependency == null)
192: {
193: throw new RuntimeException("Can't inject " + object + "." + field.getName());
194: }
195:
196: try
197: {
198: field.set(object, dependency);
199: }
200: catch (IllegalArgumentException | IllegalAccessException e)
201: {
202: throw new RuntimeException(e);
203: }
204: }
205: }
206: }
207:
208: /***********************************************************************************************************************************************************
209: * Returns the class literal associated to the given type.
210: *
211: * @param type the type to inspect
212: * @return the class literal; it might be {@code null} if fails
213: **********************************************************************************************************************************************************/
214: @CheckForNull
215: public static Class<?> getClass (@Nonnull final Type type)
216: {
217: requireNonNull(type, "type");
218:
219: if (type instanceof Class<?>)
220: {
221: return (Class<?>)type;
222: }
223: else if (type instanceof ParameterizedType)
224: {
225: return getClass(((ParameterizedType)type).getRawType());
226: }
227: else if (type instanceof GenericArrayType)
228: {
229: final var componentType = ((GenericArrayType)type).getGenericComponentType();
230: final var componentClass = getClass(componentType);
231:
232: if (componentClass == null)
233: {
234: return null;
235: }
236:
237: return Array.newInstance(componentClass, 0).getClass();
238: }
239: else
240: {
241: // throw new IllegalArgumentException(type.toString());
242: return null;
243: }
244: }
245:
246: /***********************************************************************************************************************************************************
247: *
248: **********************************************************************************************************************************************************/
249: private static boolean hasInjectAnnotation (@Nonnull final Field field)
250: {
251: final var classLoader = Thread.currentThread().getContextClassLoader();
252:
253:• for (final var className : INJECT_CLASS_NAMES)
254: {
255: try
256: {
257: @SuppressWarnings("unchecked")
258: final var clazz = (Class<? extends Annotation>)classLoader.loadClass(className);
259:
260:• if (field.getAnnotation(clazz) != null)
261: {
262: return true;
263: }
264: }
265: catch (ClassNotFoundException ignored)
266: {
267: // try next
268: }
269: }
270:
271: return false;
272: }
273: }