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 0474946c..deb27df1 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 @@ -65,7 +65,7 @@ public abstract class AbstractImportingAnnotationConfiguration, O> - implements FactoryBean, InitializingBean { - - private final B builder; - - private O object; - - private List> configurers; - - public BeanDelegatingFactoryBean(B builder){ - this.builder = builder; - } - - @Override - public abstract Class getObjectType(); - - @Override - public O getObject() throws Exception { - return object; - } - - @Override - public boolean isSingleton() { - return true; - } - -// @Override -// public void afterPropertiesSet() throws Exception { -// for (AnnotationConfigurer configurer : configurers) { -// if (configurer.isAssignable(builder)) { -// // we need builder.apply(configurer); -//// builder. -// } -// } -// // should be getOrBuild??? -// object = builder.build(); -// } - - @Autowired(required = false) - public void setConfigurers(List> configurers) { - this.configurers = configurers; - } - - public B getBuilder() { - return builder; - } - - public List> getConfigurers() { - return configurers; - } - - protected void setObject(O object) { - this.object = object; - } - - } - @Override public void setBeanFactory(BeanFactory beanFactory) throws BeansException { Assert.isInstanceOf(ListableBeanFactory.class, beanFactory, @@ -158,7 +101,7 @@ public abstract class AbstractImportingAnnotationConfiguration, O> implements + FactoryBean, BeanFactoryAware, InitializingBean { + + private final B builder; + + private T object; + + private List> configurers; + + private BeanFactory beanFactory; + + private Class clazz; + + public BeanDelegatingFactoryBean(B builder, Class clazz) { + this.builder = builder; + this.clazz = clazz; + } + + @Override + public Class getObjectType() { + return clazz; + } + + @Override + public T getObject() throws Exception { + return object; + } + + @Override + public boolean isSingleton() { + return true; + } + + @Autowired(required = false) + public void setConfigurers(List> configurers) { + this.configurers = configurers; + } + + @Override + public void setBeanFactory(BeanFactory beanFactory) throws BeansException { + this.beanFactory = beanFactory; + } + + public B getBuilder() { + return builder; + } + + public List> getConfigurers() { + return configurers; + } + + protected void setObject(T object) { + this.object = object; + } + + protected BeanFactory getBeanFactory() { + return beanFactory; + } + + } + } 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 87d3e4d0..dc47d9ce 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 @@ -1,17 +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.configuration; import java.lang.annotation.Annotation; -import java.util.List; -import org.springframework.beans.BeansException; -import org.springframework.beans.factory.BeanFactory; -import org.springframework.beans.factory.BeanFactoryAware; -import org.springframework.beans.factory.FactoryBean; -import org.springframework.beans.factory.InitializingBean; -import org.springframework.beans.factory.annotation.Autowired; 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; import org.springframework.statemachine.config.EnumStateMachineFactory; @@ -27,12 +38,21 @@ public class StateMachineConfiguration, E extends Enum> ext AbstractImportingAnnotationConfiguration, StateMachineConfig> { private final StateMachineConfigBuilder builder = new StateMachineConfigBuilder(); - + @Override - protected BeanDefinition buildBeanDefinition() throws Exception { + protected BeanDefinition buildBeanDefinition(AnnotationMetadata importingClassMetadata) throws Exception { + + Class annotationType = getAnnotation(); + AnnotationAttributes attributes = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes( + annotationType.getName(), false)); + String[] names = attributes.getStringArray("name"); + + BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder - .rootBeanDefinition(StateMachineDelegatingFactoryBean.class); + .rootBeanDefinition(StateMachineDelegatingFactoryBean2.class); beanDefinitionBuilder.addConstructorArgValue(builder); + beanDefinitionBuilder.addConstructorArgValue(StateMachine.class); + beanDefinitionBuilder.addConstructorArgValue(names); return beanDefinitionBuilder.getBeanDefinition(); } @@ -41,62 +61,35 @@ public class StateMachineConfiguration, E extends Enum> ext return EnableStateMachine.class; } - private static class StateMachineDelegatingFactoryBean, E extends Enum> implements - FactoryBean>, BeanFactoryAware, InitializingBean { + private static class StateMachineDelegatingFactoryBean2, E extends Enum> + extends BeanDelegatingFactoryBean,StateMachineConfigBuilder,StateMachineConfig> { - private final StateMachineConfigBuilder builder; - - private List, StateMachineConfigBuilder>> configurers; - - private BeanFactory beanFactory; - - private StateMachine stateMachine; - - @SuppressWarnings("unused") - public StateMachineDelegatingFactoryBean(StateMachineConfigBuilder builder) { - this.builder = builder; - } - - @Override - public StateMachine getObject() throws Exception { - return stateMachine; - } + private final String[] beanNames; - @Override - public Class getObjectType() { - return StateMachine.class; - } - - @Override - public boolean isSingleton() { - return true; + public StateMachineDelegatingFactoryBean2(StateMachineConfigBuilder builder, Class> clazz, String[] beanNames) { + super(builder, clazz); + this.beanNames = beanNames; } @Override public void afterPropertiesSet() throws Exception { - for (AnnotationConfigurer, StateMachineConfigBuilder> configurer : configurers) { - builder.apply(configurer); + 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])) { + getBuilder().apply(configurer); + } } - StateMachineConfig stateMachineConfig = builder.getOrBuild(); + StateMachineConfig stateMachineConfig = getBuilder().getOrBuild(); StateMachineTransitions stateMachineTransitions = stateMachineConfig.getTransitions(); StateMachineStates stateMachineStates = stateMachineConfig.getStates(); - EnumStateMachineFactory stateMachineFactory = new EnumStateMachineFactory(stateMachineTransitions, stateMachineStates); - stateMachineFactory.setBeanFactory(beanFactory); - stateMachine = stateMachineFactory.getStateMachine(); + EnumStateMachineFactory stateMachineFactory = new EnumStateMachineFactory( + stateMachineTransitions, stateMachineStates); + stateMachineFactory.setBeanFactory(getBeanFactory()); + setObject(stateMachineFactory.getStateMachine()); } - @Override - public void setBeanFactory(BeanFactory beanFactory) throws BeansException { - this.beanFactory = beanFactory; - } - - @Autowired(required=false) - protected void onConfigurers( - List, StateMachineConfigBuilder>> configurers) - throws Exception { - this.configurers = configurers; - } - } } 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 a0c3adcf..23c522a2 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 @@ -12,6 +12,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.beans.factory.support.BeanDefinitionBuilder; import org.springframework.context.annotation.Configuration; +import org.springframework.core.type.AnnotationMetadata; import org.springframework.statemachine.config.EnableStateMachineFactory; import org.springframework.statemachine.config.EnumStateMachineFactory; import org.springframework.statemachine.config.StateMachineConfig; @@ -27,9 +28,9 @@ public class StateMachineFactoryConfiguration, E extends Enum< AbstractImportingAnnotationConfiguration, StateMachineConfig> { private final StateMachineConfigBuilder builder = new StateMachineConfigBuilder(); - + @Override - protected BeanDefinition buildBeanDefinition() throws Exception { + protected BeanDefinition buildBeanDefinition(AnnotationMetadata importingClassMetadata) throws Exception { BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder .rootBeanDefinition(StateMachineFactoryDelegatingFactoryBean.class); beanDefinitionBuilder.addConstructorArgValue(builder); @@ -45,18 +46,18 @@ public class StateMachineFactoryConfiguration, E extends Enum< FactoryBean>, BeanFactoryAware, InitializingBean { private final StateMachineConfigBuilder builder; - + private List, StateMachineConfigBuilder>> configurers; - + private BeanFactory beanFactory; - + private StateMachineFactory stateMachineFactory; - + @SuppressWarnings("unused") public StateMachineFactoryDelegatingFactoryBean(StateMachineConfigBuilder builder) { this.builder = builder; } - + @Override public StateMachineFactory getObject() throws Exception { return stateMachineFactory; @@ -96,7 +97,7 @@ public class StateMachineFactoryConfiguration, E extends Enum< throws Exception { this.configurers = configurers; } - + } } 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 269a15af..17f8381d 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 @@ -20,6 +20,7 @@ import java.lang.annotation.Annotation; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.beans.factory.support.BeanDefinitionBuilder; import org.springframework.context.annotation.Configuration; +import org.springframework.core.type.AnnotationMetadata; import org.springframework.statemachine.config.common.annotation.AbstractImportingAnnotationConfiguration; import org.springframework.statemachine.config.common.annotation.AnnotationConfigurer; @@ -27,9 +28,9 @@ import org.springframework.statemachine.config.common.annotation.AnnotationConfi public class SimpleTestConfiguration2 extends AbstractImportingAnnotationConfiguration { private final SimpleTestConfigBuilder builder = new SimpleTestConfigBuilder(); - + @Override - protected BeanDefinition buildBeanDefinition() throws Exception { + protected BeanDefinition buildBeanDefinition(AnnotationMetadata importingClassMetadata) throws Exception { BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder .rootBeanDefinition(SimpleTestConfigDelegatingFactoryBean.class); beanDefinitionBuilder.addConstructorArgValue(builder); @@ -41,17 +42,12 @@ public class SimpleTestConfiguration2 extends AbstractImportingAnnotationConfigu return EnableSimpleTest2.class; } - private static class SimpleTestConfigDelegatingFactoryBean extends BeanDelegatingFactoryBean { - + private static class SimpleTestConfigDelegatingFactoryBean extends BeanDelegatingFactoryBean { + public SimpleTestConfigDelegatingFactoryBean(SimpleTestConfigBuilder builder) { - super(builder); + super(builder, SimpleTestConfig.class); } - @Override - public Class getObjectType() { - return SimpleTestConfig.class; - } - @Override public void afterPropertiesSet() throws Exception { for (AnnotationConfigurer configurer : getConfigurers()) { @@ -61,7 +57,7 @@ public class SimpleTestConfiguration2 extends AbstractImportingAnnotationConfigu } setObject(getBuilder().getOrBuild()); } - + } - + }