You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@isis.apache.org by ah...@apache.org on 2018/03/25 18:41:06 UTC
[isis] branch master updated: ISIS-1931 introduces Field/Method
caching for ServicesInjector
This is an automated email from the ASF dual-hosted git repository.
ahuber pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/isis.git
The following commit(s) were added to refs/heads/master by this push:
new 2093a12 ISIS-1931 introduces Field/Method caching for ServicesInjector
2093a12 is described below
commit 2093a12d44db85462f58005d5ad667c4675bb385
Author: Andi Huber <ah...@apache.org>
AuthorDate: Sun Mar 25 20:41:00 2018 +0200
ISIS-1931 introduces Field/Method caching for ServicesInjector
also ServicesInjector was
(1)refactored to use less temporary collections
(2)collection injection was refactored out into a separate class
(3)collection injection was extended to also support Set, SortedSet
(4)removing guava idioms, using java stream API instead
---
.../core/metamodel/services/CollectionHelper.java | 100 ++++++++++
.../core/metamodel/services/ServicesInjector.java | 221 ++++++++-------------
.../services/ServicesInjectorDefaultTest.java | 3 +-
...rvicesInjectorDefaultTest_validateServices.java | 4 +-
4 files changed, 190 insertions(+), 138 deletions(-)
diff --git a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/services/CollectionHelper.java b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/services/CollectionHelper.java
new file mode 100644
index 0000000..9b6d9e0
--- /dev/null
+++ b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/services/CollectionHelper.java
@@ -0,0 +1,100 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.isis.core.metamodel.services;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+class CollectionHelper {
+
+ /**
+ * If field is of type Collection<T> with generic type T present, then call action with the element type.
+ * @param field
+ * @param action
+ */
+ static void ifIsCollectionWithGenericTypeThen(Field field, Consumer<Class<?>> action) {
+
+ final Class<?> typeToBeInjected = field.getType();
+
+ if(Collection.class.isAssignableFrom(typeToBeInjected)) {
+ final Type genericType = field.getGenericType();
+ if(genericType instanceof ParameterizedType) {
+ final ParameterizedType parameterizedType = (ParameterizedType) genericType;
+ final Class<?> elementType = (Class<?>) parameterizedType.getActualTypeArguments()[0];
+
+ action.accept(elementType);
+ }
+ }
+
+ }
+
+ /**
+ * Collects elements from stream into a collection that is compatible with the given typeOfCollection.
+ * @param typeOfCollection
+ * @param elementStream
+ * @return
+ *
+ * @throws IllegalArgumentException if the given typeOfCollection is not supported
+ */
+ static <T> Collection<T> collectIntoUnmodifiableCompatibleWithCollectionType (
+ Class<? extends Collection<T>> typeOfCollection, Stream<T> elementStream) {
+
+ if(SortedSet.class.isAssignableFrom(typeOfCollection)) {
+ return Collections.unmodifiableSortedSet(
+ elementStream.collect(Collectors.toCollection(TreeSet::new))
+ );
+ }
+
+ if(Set.class.isAssignableFrom(typeOfCollection)) {
+ return Collections.unmodifiableSet(
+ elementStream.collect(Collectors.toCollection(HashSet::new))
+ );
+ }
+
+ if(List.class.isAssignableFrom(typeOfCollection)) {
+ return Collections.unmodifiableList(
+ elementStream.collect(Collectors.toCollection(ArrayList::new))
+ );
+ }
+
+ if(Collection.class.isAssignableFrom(typeOfCollection)) {
+ return Collections.unmodifiableCollection(
+ elementStream.collect(Collectors.toCollection(ArrayList::new))
+ );
+ }
+
+ throw new IllegalArgumentException(
+ String.format("Can not collect into %s. Only List, Set, SortedSet and Collection are supported.",
+ typeOfCollection.getClass().getName()));
+ }
+
+}
diff --git a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/services/ServicesInjector.java b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/services/ServicesInjector.java
index 688ea07..06582bb 100644
--- a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/services/ServicesInjector.java
+++ b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/services/ServicesInjector.java
@@ -19,27 +19,19 @@ package org.apache.isis.core.metamodel.services;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
-
-import javax.inject.Inject;
-
-import com.google.common.base.Predicate;
-import com.google.common.collect.ArrayListMultimap;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.ListMultimap;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
import org.apache.isis.applib.annotation.Programmatic;
+import org.apache.isis.applib.internal.base._NullSafe;
+import org.apache.isis.applib.internal.collections._Lists;
+import org.apache.isis.applib.internal.collections._Maps;
+import org.apache.isis.applib.internal.collections._Multimaps;
+import org.apache.isis.applib.internal.collections._Multimaps.ListMultimap;
import org.apache.isis.applib.services.exceprecog.ExceptionRecognizer;
import org.apache.isis.core.commons.authentication.AuthenticationSessionProvider;
import org.apache.isis.core.commons.components.ApplicationScopedComponent;
@@ -55,6 +47,8 @@ import org.apache.isis.core.metamodel.specloader.InjectorMethodEvaluatorDefault;
import org.apache.isis.core.metamodel.specloader.SpecificationLoader;
import org.apache.isis.core.runtime.authentication.AuthenticationManager;
import org.apache.isis.core.runtime.authorization.AuthorizationManager;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* The repository of services, also able to inject into any object.
@@ -72,19 +66,20 @@ public class ServicesInjector implements ApplicationScopedComponent {
public static final String KEY_SET_PREFIX = "isis.services.injector.setPrefix";
public static final String KEY_INJECT_PREFIX = "isis.services.injector.injectPrefix";
- // -- constructor, fields
+ // -- CONSTRUCTOR, FIELDS
/**
* This is mutable internally, but only ever exposed (in {@link #getRegisteredServices()}) as immutable.
*/
- private final List<Object> services = Lists.newArrayList();
+ private final List<Object> services = _Lists.newArrayList();
/**
* If no key, not yet searched for type; otherwise the corresponding value is a {@link List} of all
* services that are assignable to the type. It's possible that this is an empty list.
*/
- private final Map<Class<?>, List<Object>> servicesAssignableToType = Maps.newHashMap();
-
- private final Map<Class<?>, Object> serviceByConcreteType = Maps.newHashMap();
+ private final Map<Class<?>, List<Object>> servicesAssignableToType = _Maps.newHashMap();
+ private final Map<Class<?>, Object> serviceByConcreteType = _Maps.newHashMap();
+ private final Map<Class<?>, Method[]> methodsByClassCache = _Maps.newHashMap();
+ private final Map<Class<?>, Field[]> fieldsByClassCache = _Maps.newHashMap();
private final InjectorMethodEvaluator injectorMethodEvaluator;
private final boolean autowireSetters;
@@ -94,25 +89,19 @@ public class ServicesInjector implements ApplicationScopedComponent {
this(services, null, configuration);
}
- /**
- * For testing.
- */
- public ServicesInjector(
- final List<Object> services,
+ public static ServicesInjector forTesting(
+ final List<Object> services,
final IsisConfigurationDefault configuration,
final InjectorMethodEvaluator injectorMethodEvaluator) {
- this(services, injectorMethodEvaluator, defaultAutowiring(configuration));
+ return new ServicesInjector(services, injectorMethodEvaluator, defaultAutowiring(configuration));
}
-
+
private static IsisConfiguration defaultAutowiring(final IsisConfigurationDefault configuration) {
configuration.put(KEY_SET_PREFIX, ""+true);
configuration.put(KEY_INJECT_PREFIX, ""+false);
return configuration;
}
- /**
- * For testing.
- */
private ServicesInjector(
final List<Object> services,
final InjectorMethodEvaluator injectorMethodEvaluator,
@@ -128,9 +117,7 @@ public class ServicesInjector implements ApplicationScopedComponent {
this.autowireInject = configuration.getBoolean(KEY_INJECT_PREFIX, false);
}
-
-
- // -- replaceServices
+ // -- REPLACE SERVICES
/**
* Update an individual service.
@@ -185,44 +172,33 @@ public class ServicesInjector implements ApplicationScopedComponent {
}
private static void validate(List<Object> serviceList) {
- ListMultimap<String, Object> servicesById = ArrayListMultimap.create();
+ final ListMultimap<String, Object> servicesById = _Multimaps.newListMultimap();
for (Object service : serviceList) {
String id = ServiceUtil.id(service);
- servicesById.put(id, service);
+ servicesById.putElement(id, service);
}
- for (Map.Entry<String, Collection<Object>> servicesForId : servicesById.asMap().entrySet()) {
- String serviceId = servicesForId.getKey();
- Collection<Object> services = servicesForId.getValue();
- if(services.size() > 1) {
+
+ servicesById.forEach((serviceId, services)->{
+ if(services.size() > 1) {
throw new IllegalStateException(
String.format("Service ids must be unique; serviceId '%s' is declared by domain services %s",
serviceId, classNamesFor(services)));
}
- }
+ });
}
private static String classNamesFor(Collection<Object> services) {
- StringBuilder buf = new StringBuilder();
- for (Object service : services) {
- if(buf.length() > 0) {
- buf.append(", ");
- }
- buf.append(service.getClass().getName());
- }
- return buf.toString();
+ return _NullSafe.stream(services)
+ .map(Object::getClass)
+ .map(Class::getName)
+ .collect(Collectors.joining(", "));
}
-
static boolean contains(final List<Object> services, final Class<?> serviceClass) {
- for (Object service : services) {
- if(serviceClass.isAssignableFrom(service.getClass())) {
- return true;
- }
- }
- return false;
+ return _NullSafe.stream(services)
+ .anyMatch(service->serviceClass.isAssignableFrom(service.getClass()));
}
-
/**
* All registered services, as an immutable {@link List}.
*/
@@ -230,9 +206,7 @@ public class ServicesInjector implements ApplicationScopedComponent {
return Collections.unmodifiableList(services);
}
-
-
- // -- injectServicesInto
+ // -- INJECT SERVICES INTO
/**
* Provided by the <tt>ServicesInjector</tt> when used by framework.
@@ -255,9 +229,7 @@ public class ServicesInjector implements ApplicationScopedComponent {
}
}
-
-
- // -- injectInto
+ // -- INJECT INTO
/**
* That is, injecting this injector...
@@ -269,9 +241,7 @@ public class ServicesInjector implements ApplicationScopedComponent {
}
}
-
-
- // -- helpers
+ // -- HELPERS
private void injectServices(final Object object, final List<Object> services) {
@@ -288,18 +258,10 @@ public class ServicesInjector implements ApplicationScopedComponent {
}
private void autowireViaFields(final Object object, final List<Object> services, final Class<?> cls) {
- final List<Field> fields = Arrays.asList(cls.getDeclaredFields());
- final Iterable<Field> injectFields = Iterables.filter(fields, new Predicate<Field>() {
- @Override
- public boolean apply(final Field input) {
- final Inject annotation = input.getAnnotation(javax.inject.Inject.class);
- return annotation != null;
- }
- });
-
- for (final Field field : injectFields) {
- autowire(object, field, services);
- }
+
+ _NullSafe.stream(fieldsByClassCache.computeIfAbsent(cls, __->cls.getDeclaredFields()))
+ .filter(isAnnotatedForInjection())
+ .forEach(field->autowire(object, field, services));
// recurse up the object's class hierarchy
final Class<?> superclass = cls.getSuperclass();
@@ -313,35 +275,37 @@ public class ServicesInjector implements ApplicationScopedComponent {
final Field field,
final List<Object> services) {
- final Class<?> type = field.getType();
+ final Class<?> typeToBeInjected = field.getType();
// don't think that type can ever be null,
// but Javadoc for java.lang.reflect.Field doesn't say
- if(type == null) {
+ if(typeToBeInjected == null) {
return;
}
- // inject into Collection<T> or List<T>
- if(Collection.class.isAssignableFrom(type) || List.class.isAssignableFrom(type)) {
- final Type genericType = field.getGenericType();
- if(genericType instanceof ParameterizedType) {
- final ParameterizedType listParameterizedType = (ParameterizedType) genericType;
- final Class<?> listType = (Class<?>) listParameterizedType.getActualTypeArguments()[0];
- final List<Object> listOfServices =
- Collections.unmodifiableList(
- Lists.newArrayList(
- Iterables.filter(services, new Predicate<Object>() {
- @Override
- public boolean apply(final Object input) {
- return input != null && listType.isAssignableFrom(input.getClass());
- }
- })));
- invokeInjectorField(field, object, listOfServices);
- }
- }
-
+ // inject matching services into a field of type Collection<T> if a generic type T is present
+ CollectionHelper.ifIsCollectionWithGenericTypeThen(field, (elementType)->{
+
+ @SuppressWarnings("unchecked")
+ final Class<? extends Collection<Object>> collectionTypeToBeInjected =
+ (Class<? extends Collection<Object>>) typeToBeInjected;
+
+ final Collection<Object> collectionOfServices =
+ CollectionHelper.collectIntoUnmodifiableCompatibleWithCollectionType(
+
+ collectionTypeToBeInjected,
+
+ _NullSafe.stream(services)
+ .filter(_NullSafe::isPresent)
+ .filter(isOfType(elementType))
+
+ );
+
+ invokeInjectorField(field, object, collectionOfServices);
+ });
+
for (final Object service : services) {
final Class<?> serviceClass = service.getClass();
- if(type.isAssignableFrom(serviceClass)) {
+ if(typeToBeInjected.isAssignableFrom(serviceClass)) {
invokeInjectorField(field, object, service);
return;
}
@@ -353,23 +317,17 @@ public class ServicesInjector implements ApplicationScopedComponent {
final List<Object> services,
final Class<?> cls,
final String prefix) {
- final List<Method> methods = Arrays.asList(cls.getMethods());
- final Iterable<Method> prefixedMethods = Iterables.filter(methods, new Predicate<Method>(){
- public boolean apply(final Method method) {
- final String methodName = method.getName();
- return methodName.startsWith(prefix);
- }
- });
-
- for (final Method prefixedMethod : prefixedMethods) {
- autowire(object, prefixedMethod, services);
- }
+
+ _NullSafe.stream(methodsByClassCache.computeIfAbsent(cls, __->cls.getMethods()))
+ .filter(nameStartsWith(prefix))
+ .forEach(prefixedMethod->autowire(object, prefixedMethod, services));
}
private void autowire(
final Object object,
final Method prefixedMethod,
final List<Object> services) {
+
for (final Object service : services) {
final Class<?> serviceClass = service.getClass();
final boolean isInjectorMethod = injectorMethodEvaluator.isInjectorMethodFor(prefixedMethod, serviceClass);
@@ -420,23 +378,13 @@ public class ServicesInjector implements ApplicationScopedComponent {
}
}
-
-
-
-
-
-
-
- // -- autoWire
+ // -- AUTOWIRE
@Programmatic
public void autowire() {
injectServicesInto(this.services);
}
-
-
-
// -- lookupService, lookupServices
/**
@@ -487,30 +435,33 @@ public class ServicesInjector implements ApplicationScopedComponent {
return;
}
- final List<Object> matchingServices = Lists.newArrayList();
+ final List<Object> matchingServices = _Lists.newArrayList();
addAssignableTo(serviceClass, services, matchingServices);
servicesAssignableToType.put(serviceClass, matchingServices);
}
private static void addAssignableTo(final Class<?> type, final List<Object> candidates, final List<Object> filteredServicesAndContainer) {
- final Iterable<Object> filteredServices = Iterables.filter(candidates, ofType(type));
- filteredServicesAndContainer.addAll(Lists.newArrayList(filteredServices));
+ _NullSafe.stream(candidates)
+ .filter(isOfType(type))
+ .forEach(filteredServicesAndContainer::add);
}
- private static final Predicate<Object> ofType(final Class<?> cls) {
- return new Predicate<Object>() {
- @Override
- public boolean apply(final Object input) {
- return cls.isAssignableFrom(input.getClass());
- }
- };
+ // -- REFLECTIVE PREDICATES
+
+ private static final Predicate<Object> isOfType(final Class<?> cls) {
+ return input->cls.isAssignableFrom(input.getClass());
}
-
-
-
- // -- convenience lookups (singletons only, cached)
+ private static final Predicate<Method> nameStartsWith(final String prefix) {
+ return method->method.getName().startsWith(prefix);
+ }
+
+ private static final Predicate<Field> isAnnotatedForInjection() {
+ return field->field.getAnnotation(javax.inject.Inject.class) != null;
+ }
+
+ // -- CONVENIENCE LOOKUPS (singletons only, cached)
private AuthenticationManager authenticationManager;
diff --git a/core/metamodel/src/test/java/org/apache/isis/core/metamodel/services/ServicesInjectorDefaultTest.java b/core/metamodel/src/test/java/org/apache/isis/core/metamodel/services/ServicesInjectorDefaultTest.java
index 4ee5a13..dc9c808 100644
--- a/core/metamodel/src/test/java/org/apache/isis/core/metamodel/services/ServicesInjectorDefaultTest.java
+++ b/core/metamodel/src/test/java/org/apache/isis/core/metamodel/services/ServicesInjectorDefaultTest.java
@@ -72,7 +72,8 @@ public class ServicesInjectorDefaultTest {
final Object[] services = { mockContainer, mockService1, mockService2 };
IsisConfigurationDefault stubConfiguration = new IsisConfigurationDefault();
- injector = new ServicesInjector(Arrays.asList(services), stubConfiguration, new InjectorMethodEvaluatorDefault());
+ injector = ServicesInjector.forTesting(
+ Arrays.asList(services), stubConfiguration, new InjectorMethodEvaluatorDefault());
}
@After
diff --git a/core/metamodel/src/test/java/org/apache/isis/core/metamodel/services/ServicesInjectorDefaultTest_validateServices.java b/core/metamodel/src/test/java/org/apache/isis/core/metamodel/services/ServicesInjectorDefaultTest_validateServices.java
index 7008a90..5834639 100644
--- a/core/metamodel/src/test/java/org/apache/isis/core/metamodel/services/ServicesInjectorDefaultTest_validateServices.java
+++ b/core/metamodel/src/test/java/org/apache/isis/core/metamodel/services/ServicesInjectorDefaultTest_validateServices.java
@@ -62,7 +62,7 @@ public class ServicesInjectorDefaultTest_validateServices {
serviceList.add(new DomainServiceWithSomeId());
serviceList.add(new DomainServiceWithDuplicateId());
- servicesInjector = new ServicesInjector(serviceList, stubConfiguration, null);
+ servicesInjector = ServicesInjector.forTesting(serviceList, stubConfiguration, null);
// when
servicesInjector.validateServices();
@@ -74,7 +74,7 @@ public class ServicesInjectorDefaultTest_validateServices {
serviceList.add(new DomainServiceWithSomeId());
serviceList.add(new DomainServiceWithDifferentId());
- servicesInjector = new ServicesInjector(serviceList, stubConfiguration, null);
+ servicesInjector = ServicesInjector.forTesting(serviceList, stubConfiguration, null);
// when
servicesInjector.validateServices();
--
To stop receiving notification emails like this one, please contact
ahuber@apache.org.