From d73e0a1f8faae1693c7faeb8609c4ccdc4def392 Mon Sep 17 00:00:00 2001 From: Oliver Gierke Date: Thu, 17 May 2018 16:04:54 +0200 Subject: [PATCH] DATACMNS-1324 - Introduced extensible proxy detection infrastructure. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Introduced ProxyUtils.getUserClass(…) that by default is basically a facade for Spring's ClassUtils.getUserClass(…) but allows the registration of ProxyDetector implementations via Spring's SpringFactoriesLoader mechanism. Moved all existing usages of ClassUtils.getUserClass(…) to ProxyUtils. --- .../springframework/data/domain/Example.java | 6 +- ...sactionalRepositoryProxyPostProcessor.java | 3 +- .../data/repository/support/Repositories.java | 9 +- .../repository/util/ReactiveWrappers.java | 3 +- .../data/util/ClassTypeInformation.java | 2 +- .../springframework/data/util/ProxyUtils.java | 96 +++++++++++++++++++ .../data/util/ProxyUtilsUnitTests.java | 70 ++++++++++++++ src/test/resources/META-INF/spring.factories | 1 + 8 files changed, 180 insertions(+), 10 deletions(-) create mode 100644 src/main/java/org/springframework/data/util/ProxyUtils.java create mode 100644 src/test/java/org/springframework/data/util/ProxyUtilsUnitTests.java diff --git a/src/main/java/org/springframework/data/domain/Example.java b/src/main/java/org/springframework/data/domain/Example.java index 5c19c13df..6ccbf4872 100644 --- a/src/main/java/org/springframework/data/domain/Example.java +++ b/src/main/java/org/springframework/data/domain/Example.java @@ -15,7 +15,7 @@ */ package org.springframework.data.domain; -import org.springframework.util.ClassUtils; +import org.springframework.data.util.ProxyUtils; /** * Support for query by example (QBE). An {@link Example} takes a {@code probe} to define the example. Matching options @@ -69,10 +69,10 @@ public interface Example { * CGLIB-generated subclass. * * @return - * @see ClassUtils#getUserClass(Class) + * @see ProxyUtils#getUserClass(Class) */ @SuppressWarnings("unchecked") default Class getProbeType() { - return (Class) ClassUtils.getUserClass(getProbe().getClass()); + return (Class) ProxyUtils.getUserClass(getProbe().getClass()); } } diff --git a/src/main/java/org/springframework/data/repository/core/support/TransactionalRepositoryProxyPostProcessor.java b/src/main/java/org/springframework/data/repository/core/support/TransactionalRepositoryProxyPostProcessor.java index 89d7f0a50..bf72f7756 100644 --- a/src/main/java/org/springframework/data/repository/core/support/TransactionalRepositoryProxyPostProcessor.java +++ b/src/main/java/org/springframework/data/repository/core/support/TransactionalRepositoryProxyPostProcessor.java @@ -33,6 +33,7 @@ import org.springframework.beans.factory.ListableBeanFactory; import org.springframework.core.BridgeMethodResolver; import org.springframework.dao.support.PersistenceExceptionTranslationInterceptor; import org.springframework.data.repository.core.RepositoryInformation; +import org.springframework.data.util.ProxyUtils; import org.springframework.transaction.annotation.Ejb3TransactionAnnotationParser; import org.springframework.transaction.annotation.JtaTransactionAnnotationParser; import org.springframework.transaction.annotation.SpringTransactionAnnotationParser; @@ -386,7 +387,7 @@ class TransactionalRepositoryProxyPostProcessor implements RepositoryProxyPostPr } // Ignore CGLIB subclasses - introspect the actual user class. - Class userClass = ClassUtils.getUserClass(targetClass); + Class userClass = ProxyUtils.getUserClass(targetClass); // The method may be on an interface, but we need attributes from the target class. // If the target class is null, the method will be unchanged. Method specificMethod = ClassUtils.getMostSpecificMethod(method, userClass); diff --git a/src/main/java/org/springframework/data/repository/support/Repositories.java b/src/main/java/org/springframework/data/repository/support/Repositories.java index 9f5618ecb..2dd89f6c3 100644 --- a/src/main/java/org/springframework/data/repository/support/Repositories.java +++ b/src/main/java/org/springframework/data/repository/support/Repositories.java @@ -33,6 +33,7 @@ import org.springframework.data.repository.core.EntityInformation; import org.springframework.data.repository.core.RepositoryInformation; import org.springframework.data.repository.core.support.RepositoryFactoryInformation; import org.springframework.data.repository.query.QueryMethod; +import org.springframework.data.util.ProxyUtils; import org.springframework.util.Assert; import org.springframework.util.ClassUtils; @@ -122,7 +123,7 @@ public class Repositories implements Iterable> { Assert.notNull(domainClass, DOMAIN_TYPE_MUST_NOT_BE_NULL); - Class userClass = ClassUtils.getUserClass(domainClass); + Class userClass = ProxyUtils.getUserClass(domainClass); return repositoryFactoryInfos.containsKey(userClass); } @@ -137,7 +138,7 @@ public class Repositories implements Iterable> { Assert.notNull(domainClass, DOMAIN_TYPE_MUST_NOT_BE_NULL); - Class userClass = ClassUtils.getUserClass(domainClass); + Class userClass = ProxyUtils.getUserClass(domainClass); Optional repositoryBeanName = Optional.ofNullable(repositoryBeanNames.get(userClass)); return beanFactory.flatMap(it -> repositoryBeanName.map(it::getBean)); @@ -145,7 +146,7 @@ public class Repositories implements Iterable> { /** * Returns the {@link RepositoryFactoryInformation} for the given domain class. The given code is - * converted to the actual user class if necessary, @see ClassUtils#getUserClass. + * converted to the actual user class if necessary, @see ProxyUtils#getUserClass. * * @param domainClass must not be {@literal null}. * @return the {@link RepositoryFactoryInformation} for the given domain class or {@literal null} if no repository @@ -155,7 +156,7 @@ public class Repositories implements Iterable> { Assert.notNull(domainClass, DOMAIN_TYPE_MUST_NOT_BE_NULL); - Class userType = ClassUtils.getUserClass(domainClass); + Class userType = ProxyUtils.getUserClass(domainClass); RepositoryFactoryInformation repositoryInfo = repositoryFactoryInfos.get(userType); if (repositoryInfo != null) { diff --git a/src/main/java/org/springframework/data/repository/util/ReactiveWrappers.java b/src/main/java/org/springframework/data/repository/util/ReactiveWrappers.java index f593a0a3d..9a8147394 100644 --- a/src/main/java/org/springframework/data/repository/util/ReactiveWrappers.java +++ b/src/main/java/org/springframework/data/repository/util/ReactiveWrappers.java @@ -31,6 +31,7 @@ import java.util.stream.Collectors; import org.reactivestreams.Publisher; import org.springframework.core.ReactiveTypeDescriptor; +import org.springframework.data.util.ProxyUtils; import org.springframework.data.util.ReflectionUtils; import org.springframework.util.Assert; import org.springframework.util.ClassUtils; @@ -154,7 +155,7 @@ public class ReactiveWrappers { * @return {@literal true} if the {@code type} is a supported reactive wrapper type. */ public static boolean supports(Class type) { - return isWrapper(ClassUtils.getUserClass(type)); + return isWrapper(ProxyUtils.getUserClass(type)); } /** diff --git a/src/main/java/org/springframework/data/util/ClassTypeInformation.java b/src/main/java/org/springframework/data/util/ClassTypeInformation.java index 77d82bd84..bd1b1faea 100644 --- a/src/main/java/org/springframework/data/util/ClassTypeInformation.java +++ b/src/main/java/org/springframework/data/util/ClassTypeInformation.java @@ -89,7 +89,7 @@ public class ClassTypeInformation extends TypeDiscoverer { * @param type */ ClassTypeInformation(Class type) { - super(ClassUtils.getUserClass(type), getTypeVariableMap(type)); + super(ProxyUtils.getUserClass(type), getTypeVariableMap(type)); this.type = type; } diff --git a/src/main/java/org/springframework/data/util/ProxyUtils.java b/src/main/java/org/springframework/data/util/ProxyUtils.java new file mode 100644 index 000000000..2cbaeb754 --- /dev/null +++ b/src/main/java/org/springframework/data/util/ProxyUtils.java @@ -0,0 +1,96 @@ +/* + * Copyright 2018 the original author or authors. + * + * Licensed 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.springframework.data.util; + +import lombok.experimental.UtilityClass; + +import java.util.List; +import java.util.Map; + +import org.springframework.core.io.support.SpringFactoriesLoader; +import org.springframework.util.Assert; +import org.springframework.util.ClassUtils; +import org.springframework.util.ConcurrentReferenceHashMap; + +/** + * Proxy type detection utilities, extensible via {@link ProxyDetector} registered via Spring factories. + * + * @author Oliver Gierke + * @soundtrack Victor Wooten - Cruising Altitude (Trypnotix) + */ +@UtilityClass +public class ProxyUtils { + + private static Map, Class> USER_TYPES = new ConcurrentReferenceHashMap<>(); + + private static final List DETECTORS = SpringFactoriesLoader.loadFactories(ProxyDetector.class, + ProxyUtils.class.getClassLoader()); + + static { + DETECTORS.add(ClassUtils::getUserClass); + } + + /** + * Returns the user class for the given type. + * + * @param type must not be {@literal null}. + * @return + */ + public static Class getUserClass(Class type) { + + Assert.notNull(type, "Type must not be null!"); + + return USER_TYPES.computeIfAbsent(type, it -> { + + Class result = it; + + for (ProxyDetector proxyDetector : DETECTORS) { + result = proxyDetector.getUserType(result); + } + + return result; + }); + } + + /** + * Returns the user class for the given source object. + * + * @param source must not be {@literal null}. + * @return + */ + public static Class getUserClass(Object source) { + + Assert.notNull(source, "Source object must not be null!"); + + return getUserClass(source.getClass()); + } + + /** + * SPI to extend Spring's default proxy detection capabilities. + * + * @author Oliver Gierke + */ + public interface ProxyDetector { + + /** + * Returns the user class for the given type. + * + * @param type will never be {@literal null}. + * @return + */ + Class getUserType(Class type); + } +} diff --git a/src/test/java/org/springframework/data/util/ProxyUtilsUnitTests.java b/src/test/java/org/springframework/data/util/ProxyUtilsUnitTests.java new file mode 100644 index 000000000..28bc06ba8 --- /dev/null +++ b/src/test/java/org/springframework/data/util/ProxyUtilsUnitTests.java @@ -0,0 +1,70 @@ +/* + * Copyright 2018 the original author or authors. + * + * Licensed 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.springframework.data.util; + +import static org.assertj.core.api.Assertions.*; + +import org.junit.Test; +import org.springframework.aop.framework.ProxyFactory; +import org.springframework.data.util.ProxyUtils.ProxyDetector; + +/** + * Unit tests for {@link ProxyUtils}. + * + * @author Oliver Gierke + * @soundtrack Victor Wooten - The 13th Floor (Trypnotix) + */ +public class ProxyUtilsUnitTests { + + @Test // DATACMNS-1324 + public void detectsStandardProxy() { + + ProxyFactory factory = new ProxyFactory(); + factory.setTarget(new Sample()); + Object proxy = factory.getProxy(); + + assertThat(proxy.getClass()).isNotEqualTo(Sample.class); + assertThat(ProxyUtils.getUserClass(proxy)).isEqualTo(Sample.class); + } + + @Test // DATACMNS-1324 + public void usesCustomProxyDetector() { + + ProxyFactory factory = new ProxyFactory(); + factory.setTarget(new AnotherSample()); + Object proxy = factory.getProxy(); + + assertThat(ProxyUtils.getUserClass(proxy)).isEqualTo(UserType.class); + } + + static class SampleProxyDetector implements ProxyDetector { + + /* + * (non-Javadoc) + * @see org.springframework.data.util.ProxyUtils.ProxyDetector#getUserType(java.lang.Class) + */ + @Override + public Class getUserType(Class type) { + return AnotherSample.class.isAssignableFrom(type) ? UserType.class : type; + } + } + + static class Sample {} + + static class UserType {} + + static class AnotherSample {} +} diff --git a/src/test/resources/META-INF/spring.factories b/src/test/resources/META-INF/spring.factories index 81d1c0f82..0e9bee7f8 100644 --- a/src/test/resources/META-INF/spring.factories +++ b/src/test/resources/META-INF/spring.factories @@ -1 +1,2 @@ org.springframework.data.web.config.SpringDataJacksonModules=org.springframework.data.web.config.SampleMixin +org.springframework.data.util.ProxyUtils$ProxyDetector=org.springframework.data.util.ProxyUtilsUnitTests$SampleProxyDetector