From a98e50247d888a62e9d4738c0b8ad9674f9f06fc Mon Sep 17 00:00:00 2001 From: Janne Valkealahti Date: Tue, 17 Feb 2015 09:31:14 +0000 Subject: [PATCH] Tweak annotation config concepts --- ...tractImportingAnnotationConfiguration.java | 31 ++++-- .../StateMachineConfiguration.java | 34 +++---- .../StateMachineFactoryConfiguration.java | 11 ++- .../ImportingBeanDefinitionTests.java | 59 ++++++++++++ .../importing/EnableImportingTest.java | 38 ++++++++ .../importing/ImportingTestConfig.java | 28 ++++++ .../importing/ImportingTestConfigBuilder.java | 38 ++++++++ .../importing/ImportingTestConfigurer.java | 22 +++++ .../ImportingTestConfigurerAdapter.java | 35 +++++++ .../SimpleImportingConfiguration.java | 95 +++++++++++++++++++ .../simple/SimpleTestConfiguration2.java | 11 ++- 11 files changed, 368 insertions(+), 34 deletions(-) create mode 100644 spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/ImportingBeanDefinitionTests.java create mode 100644 spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/EnableImportingTest.java create mode 100644 spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/ImportingTestConfig.java create mode 100644 spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/ImportingTestConfigBuilder.java create mode 100644 spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/ImportingTestConfigurer.java create mode 100644 spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/ImportingTestConfigurerAdapter.java create mode 100644 spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/SimpleImportingConfiguration.java diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/common/annotation/AbstractImportingAnnotationConfiguration.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/common/annotation/AbstractImportingAnnotationConfiguration.java index deb27df1..9bf7a0fe 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/common/annotation/AbstractImportingAnnotationConfiguration.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/common/annotation/AbstractImportingAnnotationConfiguration.java @@ -58,14 +58,24 @@ public abstract class AbstractImportingAnnotationConfiguration annotationType = getAnnotation(); - AnnotationAttributes attributes = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes( - annotationType.getName(), false)); - String[] names = attributes.getStringArray("name"); + List> annotationTypes = getAnnotations(); + Class namedAnnotation = null; + String[] names = null; + if (annotationTypes != null) { + for (Class annotationType : annotationTypes) { + AnnotationAttributes attributes = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes( + annotationType.getName(), false)); + if (attributes != null && attributes.containsKey("name")) { + names = attributes.getStringArray("name"); + namedAnnotation = annotationType; + break; + } + } + } BeanDefinition beanDefinition; try { - beanDefinition = buildBeanDefinition(importingClassMetadata); + beanDefinition = buildBeanDefinition(importingClassMetadata, namedAnnotation); } catch (Exception e) { throw new RuntimeException("Error with onConfigurers", e); } @@ -98,17 +108,20 @@ public abstract class AbstractImportingAnnotationConfiguration namedAnnotation) throws Exception; /** - * Gets the annotation specific for this configurer. + * Gets the annotations specific for this configurer. * - * @return the annotation + * @return the annotations */ - protected abstract Class getAnnotation(); + protected abstract List> getAnnotations(); /** * Gets the bean factory. diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configuration/StateMachineConfiguration.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configuration/StateMachineConfiguration.java index dc47d9ce..2a2dd955 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configuration/StateMachineConfiguration.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configuration/StateMachineConfiguration.java @@ -16,12 +16,12 @@ package org.springframework.statemachine.config.configuration; import java.lang.annotation.Annotation; +import java.util.ArrayList; +import java.util.List; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.beans.factory.support.BeanDefinitionBuilder; import org.springframework.context.annotation.Configuration; -import org.springframework.core.annotation.AnnotationAttributes; -import org.springframework.core.annotation.AnnotationUtils; import org.springframework.core.type.AnnotationMetadata; import org.springframework.statemachine.StateMachine; import org.springframework.statemachine.config.EnableStateMachine; @@ -32,6 +32,7 @@ import org.springframework.statemachine.config.builders.StateMachineStates; import org.springframework.statemachine.config.builders.StateMachineTransitions; import org.springframework.statemachine.config.common.annotation.AbstractImportingAnnotationConfiguration; import org.springframework.statemachine.config.common.annotation.AnnotationConfigurer; +import org.springframework.util.ClassUtils; @Configuration public class StateMachineConfiguration, E extends Enum> extends @@ -40,44 +41,39 @@ public class StateMachineConfiguration, E extends Enum> ext private final StateMachineConfigBuilder builder = new StateMachineConfigBuilder(); @Override - protected BeanDefinition buildBeanDefinition(AnnotationMetadata importingClassMetadata) throws Exception { - - Class annotationType = getAnnotation(); - AnnotationAttributes attributes = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes( - annotationType.getName(), false)); - String[] names = attributes.getStringArray("name"); - - + protected BeanDefinition buildBeanDefinition(AnnotationMetadata importingClassMetadata, + Class namedAnnotation) throws Exception { BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder .rootBeanDefinition(StateMachineDelegatingFactoryBean2.class); beanDefinitionBuilder.addConstructorArgValue(builder); beanDefinitionBuilder.addConstructorArgValue(StateMachine.class); - beanDefinitionBuilder.addConstructorArgValue(names); + beanDefinitionBuilder.addConstructorArgValue(importingClassMetadata.getClassName()); return beanDefinitionBuilder.getBeanDefinition(); } @Override - protected Class getAnnotation() { - return EnableStateMachine.class; + protected List> getAnnotations() { + List> types = new ArrayList>(); + types.add(EnableStateMachine.class); + return types; } private static class StateMachineDelegatingFactoryBean2, E extends Enum> extends BeanDelegatingFactoryBean,StateMachineConfigBuilder,StateMachineConfig> { - private final String[] beanNames; + private String clazzName; - public StateMachineDelegatingFactoryBean2(StateMachineConfigBuilder builder, Class> clazz, String[] beanNames) { + public StateMachineDelegatingFactoryBean2(StateMachineConfigBuilder builder, Class> clazz, + String clazzName) { super(builder, clazz); - this.beanNames = beanNames; + this.clazzName = clazzName; } @Override public void afterPropertiesSet() throws Exception { for (AnnotationConfigurer, StateMachineConfigBuilder> configurer : getConfigurers()) { Class clazz = configurer.getClass(); - EnableStateMachine findAnnotation = AnnotationUtils.findAnnotation(clazz, EnableStateMachine.class); - String[] annonames = findAnnotation.name(); - if (beanNames[0].equals(annonames[0])) { + if (ClassUtils.getUserClass(clazz).getName().equals(clazzName)) { getBuilder().apply(configurer); } } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configuration/StateMachineFactoryConfiguration.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configuration/StateMachineFactoryConfiguration.java index 23c522a2..df50d8e2 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configuration/StateMachineFactoryConfiguration.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/configuration/StateMachineFactoryConfiguration.java @@ -1,6 +1,7 @@ package org.springframework.statemachine.config.configuration; import java.lang.annotation.Annotation; +import java.util.ArrayList; import java.util.List; import org.springframework.beans.BeansException; @@ -30,16 +31,20 @@ public class StateMachineFactoryConfiguration, E extends Enum< private final StateMachineConfigBuilder builder = new StateMachineConfigBuilder(); @Override - protected BeanDefinition buildBeanDefinition(AnnotationMetadata importingClassMetadata) throws Exception { + protected BeanDefinition buildBeanDefinition(AnnotationMetadata importingClassMetadata, + Class namedAnnotation) throws Exception { BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder .rootBeanDefinition(StateMachineFactoryDelegatingFactoryBean.class); beanDefinitionBuilder.addConstructorArgValue(builder); return beanDefinitionBuilder.getBeanDefinition(); } + @Override - protected Class getAnnotation() { - return EnableStateMachineFactory.class; + protected List> getAnnotations() { + List> types = new ArrayList>(); + types.add(EnableStateMachineFactory.class); + return types; } private static class StateMachineFactoryDelegatingFactoryBean, E extends Enum> implements diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/ImportingBeanDefinitionTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/ImportingBeanDefinitionTests.java new file mode 100644 index 00000000..9cd914ce --- /dev/null +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/ImportingBeanDefinitionTests.java @@ -0,0 +1,59 @@ +/* + * Copyright 2015 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.statemachine.config.common.annotation; + +import static org.hamcrest.CoreMatchers.sameInstance; +import static org.junit.Assert.assertThat; + +import java.util.UUID; + +import org.junit.Test; +import org.springframework.context.annotation.AnnotationConfigApplicationContext; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.statemachine.config.common.annotation.importing.EnableImportingTest; +import org.springframework.statemachine.config.common.annotation.importing.ImportingTestConfigBuilder; +import org.springframework.statemachine.config.common.annotation.importing.ImportingTestConfigurerAdapter; + +public class ImportingBeanDefinitionTests { + + @Test + public void testCorrentBeanUsed() { + AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class); + Object beanBuilt = ctx.getBean("enableImportingTestBean"); + Object beanInjected = ctx.getBean("uuid"); + assertThat(beanBuilt, sameInstance(beanInjected)); + ctx.close(); + } + + + @Configuration + @EnableImportingTest + static class Config extends ImportingTestConfigurerAdapter { + + @Override + public void configure(ImportingTestConfigBuilder builder) throws Exception { + builder.setUuid(uuid()); + } + + @Bean + public UUID uuid() { + return UUID.randomUUID(); + } + + } + +} diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/EnableImportingTest.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/EnableImportingTest.java new file mode 100644 index 00000000..6ee4eadc --- /dev/null +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/EnableImportingTest.java @@ -0,0 +1,38 @@ +/* + * Copyright 2015 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.statemachine.config.common.annotation.importing; + +import java.lang.annotation.Documented; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +import org.springframework.context.annotation.Import; +import org.springframework.statemachine.config.common.annotation.EnableAnnotationConfiguration; +import org.springframework.statemachine.config.common.annotation.configuration.ObjectPostProcessorConfiguration; + +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.TYPE) +@Documented +@EnableAnnotationConfiguration +@Import({SimpleImportingConfiguration.class, ObjectPostProcessorConfiguration.class}) + +public @interface EnableImportingTest { + + String[] name() default {"enableImportingTestBean"}; + +} diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/ImportingTestConfig.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/ImportingTestConfig.java new file mode 100644 index 00000000..fcb96d64 --- /dev/null +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/ImportingTestConfig.java @@ -0,0 +1,28 @@ +/* + * Copyright 2015 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.statemachine.config.common.annotation.importing; + +import java.util.UUID; + +public class ImportingTestConfig { + + public UUID importingData; + + public void setImportingData(UUID importingData) { + this.importingData = importingData; + } + +} diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/ImportingTestConfigBuilder.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/ImportingTestConfigBuilder.java new file mode 100644 index 00000000..7d411c78 --- /dev/null +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/ImportingTestConfigBuilder.java @@ -0,0 +1,38 @@ +/* + * Copyright 2015 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.statemachine.config.common.annotation.importing; + +import java.util.UUID; + +import org.springframework.statemachine.config.common.annotation.AbstractConfiguredAnnotationBuilder; + +public class ImportingTestConfigBuilder extends + AbstractConfiguredAnnotationBuilder { + + private UUID uuid; + + @Override + protected ImportingTestConfig performBuild() throws Exception { + ImportingTestConfig bean = new ImportingTestConfig(); + bean.setImportingData(uuid); + return bean; + } + + public void setUuid(UUID uuid) { + this.uuid = uuid; + } + +} diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/ImportingTestConfigurer.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/ImportingTestConfigurer.java new file mode 100644 index 00000000..ba76e771 --- /dev/null +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/ImportingTestConfigurer.java @@ -0,0 +1,22 @@ +/* + * Copyright 2015 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.statemachine.config.common.annotation.importing; + +import org.springframework.statemachine.config.common.annotation.AnnotationConfigurer; + +public interface ImportingTestConfigurer extends AnnotationConfigurer { + +} diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/ImportingTestConfigurerAdapter.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/ImportingTestConfigurerAdapter.java new file mode 100644 index 00000000..d10c30ac --- /dev/null +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/ImportingTestConfigurerAdapter.java @@ -0,0 +1,35 @@ +/* + * Copyright 2015 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.statemachine.config.common.annotation.importing; + +import org.springframework.statemachine.config.common.annotation.AnnotationBuilder; + +public class ImportingTestConfigurerAdapter implements ImportingTestConfigurer { + + @Override + public void init(ImportingTestConfigBuilder builder) throws Exception { + } + + @Override + public void configure(ImportingTestConfigBuilder builder) throws Exception { + } + + @Override + public boolean isAssignable(AnnotationBuilder builder) { + return builder instanceof ImportingTestConfigBuilder; + } + +} diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/SimpleImportingConfiguration.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/SimpleImportingConfiguration.java new file mode 100644 index 00000000..f57dd1ca --- /dev/null +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/importing/SimpleImportingConfiguration.java @@ -0,0 +1,95 @@ +/* + * Copyright 2015 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.statemachine.config.common.annotation.importing; + +import java.lang.annotation.Annotation; +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; + +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.beans.factory.support.BeanDefinitionBuilder; +import org.springframework.context.annotation.Configuration; +import org.springframework.core.annotation.AnnotationAttributes; +import org.springframework.core.annotation.AnnotationUtils; +import org.springframework.core.type.AnnotationMetadata; +import org.springframework.statemachine.config.common.annotation.AbstractImportingAnnotationConfiguration; +import org.springframework.statemachine.config.common.annotation.AnnotationConfigurer; + +@Configuration +public class SimpleImportingConfiguration extends + AbstractImportingAnnotationConfiguration { + + private final ImportingTestConfigBuilder builder = new ImportingTestConfigBuilder(); + + @Override + protected BeanDefinition buildBeanDefinition(AnnotationMetadata importingClassMetadata, + Class namedAnnotation) throws Exception { + List> annotationTypes = getAnnotations(); + String[] names = null; + if (annotationTypes != null) { + for (Class annotationType : annotationTypes) { + AnnotationAttributes attributes = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes( + annotationType.getName(), false)); + if (attributes.containsKey("name")) { + names = attributes.getStringArray("name"); + break; + } + } + } + + BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder + .rootBeanDefinition(SimpleUUIDDelegatingFactoryBean.class); + beanDefinitionBuilder.addConstructorArgValue(builder); + beanDefinitionBuilder.addConstructorArgValue(UUID.class); + beanDefinitionBuilder.addConstructorArgValue(names); + return beanDefinitionBuilder.getBeanDefinition(); + } + + + @Override + protected List> getAnnotations() { + List> types = new ArrayList>(); + types.add(EnableImportingTest.class); + return types; + } + + private static class SimpleUUIDDelegatingFactoryBean extends + BeanDelegatingFactoryBean { + + private final String[] beanNames; + + public SimpleUUIDDelegatingFactoryBean(ImportingTestConfigBuilder builder, Class clazz, String[] beanNames) { + super(builder, clazz); + this.beanNames = beanNames; + } + + @Override + public void afterPropertiesSet() throws Exception { + for (AnnotationConfigurer configurer : getConfigurers()) { + Class clazz = configurer.getClass(); + EnableImportingTest findAnnotation = AnnotationUtils.findAnnotation(clazz, EnableImportingTest.class); + String[] annonames = findAnnotation.name(); + if (beanNames[0].equals(annonames[0])) { + getBuilder().apply(configurer); + } + } + setObject(getBuilder().getOrBuild().importingData); + } + + } + +} diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/simple/SimpleTestConfiguration2.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/simple/SimpleTestConfiguration2.java index 17f8381d..64739a29 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/simple/SimpleTestConfiguration2.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/simple/SimpleTestConfiguration2.java @@ -16,6 +16,8 @@ package org.springframework.statemachine.config.common.annotation.simple; import java.lang.annotation.Annotation; +import java.util.ArrayList; +import java.util.List; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.beans.factory.support.BeanDefinitionBuilder; @@ -30,7 +32,8 @@ public class SimpleTestConfiguration2 extends AbstractImportingAnnotationConfigu private final SimpleTestConfigBuilder builder = new SimpleTestConfigBuilder(); @Override - protected BeanDefinition buildBeanDefinition(AnnotationMetadata importingClassMetadata) throws Exception { + protected BeanDefinition buildBeanDefinition(AnnotationMetadata importingClassMetadata, + Class namedAnnotation) throws Exception { BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder .rootBeanDefinition(SimpleTestConfigDelegatingFactoryBean.class); beanDefinitionBuilder.addConstructorArgValue(builder); @@ -38,8 +41,10 @@ public class SimpleTestConfiguration2 extends AbstractImportingAnnotationConfigu } @Override - protected Class getAnnotation() { - return EnableSimpleTest2.class; + protected List> getAnnotations() { + List> types = new ArrayList>(); + types.add(EnableSimpleTest2.class); + return types; } private static class SimpleTestConfigDelegatingFactoryBean extends BeanDelegatingFactoryBean {