From 20532be8b8127a3f2624e4a62c7cad80a3bbc566 Mon Sep 17 00:00:00 2001 From: antelder Date: Thu, 30 Apr 2009 16:19:21 +0000 Subject: Start to separate the tuscany and spring code into descrete modules with no references to Spring classes in the implementation-spring module and no references to Tuscany classes in the implementation-spring-runtime module. Work in progress, compiles cleanly but the tests don't run but then they didn't run before this commit either git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@770312 13f79535-47bb-0310-9956-ffa450edef68 --- .../modules/implementation-spring-runtime/pom.xml | 32 +--- .../ComponentNameAnnotationProcessor.java | 26 +-- .../processor/ConstructorAnnotationProcessor.java | 19 +- .../processor/InitDestroyAnnotationProcessor.java | 16 +- .../processor/PropertyAnnotationProcessor.java | 152 ++++++++-------- .../processor/ReferenceAnnotationProcessor.java | 140 ++++++++------- .../context/SCAParentApplicationContext.java | 191 +++++++++++++++++++++ .../spring/runtime/context/SpringContextTie.java | 160 +++++++++++++++++ .../runtime/context/SpringImplementationStub.java | 82 +++++++++ 9 files changed, 607 insertions(+), 211 deletions(-) create mode 100644 java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SCAParentApplicationContext.java create mode 100644 java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SpringContextTie.java create mode 100644 java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SpringImplementationStub.java (limited to 'java/sca/modules/implementation-spring-runtime') diff --git a/java/sca/modules/implementation-spring-runtime/pom.xml b/java/sca/modules/implementation-spring-runtime/pom.xml index 4837f81cc7..09fc17509a 100644 --- a/java/sca/modules/implementation-spring-runtime/pom.xml +++ b/java/sca/modules/implementation-spring-runtime/pom.xml @@ -29,37 +29,7 @@ Apache Tuscany SCA Spring Implementation Runtime Model - - org.apache.tuscany.sca - tuscany-assembly - 2.0-SNAPSHOT - - - org.apache.tuscany.sca - tuscany-interface - 2.0-SNAPSHOT - - - org.apache.tuscany.sca - tuscany-assembly-xml - 2.0-SNAPSHOT - - - org.apache.tuscany.sca - tuscany-contribution - 2.0-SNAPSHOT - - - org.apache.tuscany.sca - tuscany-sca-api - 2.0-SNAPSHOT - - - org.apache.tuscany.sca - tuscany-implementation-java-runtime - 2.0-SNAPSHOT - - + org.springframework diff --git a/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/ComponentNameAnnotationProcessor.java b/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/ComponentNameAnnotationProcessor.java index 6e0987791b..53c1988a79 100644 --- a/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/ComponentNameAnnotationProcessor.java +++ b/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/ComponentNameAnnotationProcessor.java @@ -18,30 +18,30 @@ */ package org.apache.tuscany.sca.implementation.spring.processor; +import java.beans.PropertyDescriptor; +import java.lang.annotation.Annotation; +import java.lang.ref.Reference; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.Modifier; -import java.beans.PropertyDescriptor; -import java.lang.annotation.Annotation; -import org.springframework.util.Assert; import org.springframework.beans.BeanUtils; -import org.springframework.util.ReflectionUtils; import org.springframework.beans.BeansException; import org.springframework.beans.FatalBeanException; import org.springframework.beans.factory.config.BeanPostProcessor; - -import org.oasisopen.sca.annotation.ComponentName; -import org.apache.tuscany.sca.runtime.RuntimeComponent; +import org.springframework.util.Assert; +import org.springframework.util.ReflectionUtils; public class ComponentNameAnnotationProcessor implements BeanPostProcessor { - private Class componentNameAnnotationType = ComponentName.class; +// private Class componentNameAnnotationType = ComponentName.class; + private Class componentNameAnnotationType; - private RuntimeComponent component; + private String componentName; - public ComponentNameAnnotationProcessor (RuntimeComponent component) { - this.component = component; + public ComponentNameAnnotationProcessor (Class componentNameAnnotationType,String componentName) { + this.componentNameAnnotationType = componentNameAnnotationType; + this.componentName = componentName; } /** @@ -103,7 +103,7 @@ public class ComponentNameAnnotationProcessor implements BeanPostProcessor { ReflectionUtils.makeAccessible(field); if (field.getType().getName().equals("java.lang.String")) { - Object nameObj = component.getName(); + Object nameObj = componentName; if (nameObj != null) ReflectionUtils.setField(field, bean, nameObj); } else { @@ -133,7 +133,7 @@ public class ComponentNameAnnotationProcessor implements BeanPostProcessor { PropertyDescriptor pd = BeanUtils.findPropertyForMethod(method); if (pd.getPropertyType().getName().equals("java.lang.String")) { - Object nameObj = component.getName(); + Object nameObj = componentName; if (nameObj != null) { try { pd.getWriteMethod().invoke(bean, new Object[] { nameObj }); diff --git a/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/ConstructorAnnotationProcessor.java b/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/ConstructorAnnotationProcessor.java index 689ac27f0f..bdb5c01ae2 100644 --- a/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/ConstructorAnnotationProcessor.java +++ b/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/ConstructorAnnotationProcessor.java @@ -18,27 +18,24 @@ */ package org.apache.tuscany.sca.implementation.spring.processor; -import java.lang.reflect.Method; -import java.lang.reflect.Modifier; -import java.lang.reflect.Constructor; import java.lang.annotation.Annotation; -import java.util.ArrayList; -import java.util.List; +import java.lang.reflect.Constructor; -import org.springframework.util.Assert; import org.springframework.beans.BeansException; -import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter; +import org.springframework.util.Assert; public class ConstructorAnnotationProcessor extends InstantiationAwareBeanPostProcessorAdapter { - private Class constructorAnnotationType - = org.oasisopen.sca.annotation.Constructor.class; +// private Class constructorAnnotationType +// = org.oasisopen.sca.annotation.Constructor.class; + private Class constructorAnnotationType; private Class autowiredAnnotationType = Autowired.class; - public ConstructorAnnotationProcessor () { - // Default constructor. + public ConstructorAnnotationProcessor (Class annotation) { + this.constructorAnnotationType = annotation; } /** diff --git a/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/InitDestroyAnnotationProcessor.java b/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/InitDestroyAnnotationProcessor.java index 129a15e72e..80d67f578f 100644 --- a/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/InitDestroyAnnotationProcessor.java +++ b/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/InitDestroyAnnotationProcessor.java @@ -19,18 +19,22 @@ package org.apache.tuscany.sca.implementation.spring.processor; import java.lang.annotation.Annotation; -import org.oasisopen.sca.annotation.Init; -import org.oasisopen.sca.annotation.Destroy; + import org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor; -import org.springframework.util.Assert; public class InitDestroyAnnotationProcessor extends InitDestroyAnnotationBeanPostProcessor { private static final long serialVersionUID = 0; - private Class initAnnotationType = Init.class; - - private Class destroyAnnotationType = Destroy.class; +// private Class initAnnotationType = Init.class; +// private Class destroyAnnotationType = Destroy.class; + private Class initAnnotationType; + private Class destroyAnnotationType; + + public InitDestroyAnnotationProcessor(Class initAnnotationType, Class destroyAnnotationType) { + this.initAnnotationType = initAnnotationType; + this.destroyAnnotationType = destroyAnnotationType; + } /** * Gets init annotation type. diff --git a/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/PropertyAnnotationProcessor.java b/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/PropertyAnnotationProcessor.java index fbc0e2b36f..a797f8f4b9 100644 --- a/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/PropertyAnnotationProcessor.java +++ b/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/PropertyAnnotationProcessor.java @@ -18,38 +18,32 @@ */ package org.apache.tuscany.sca.implementation.spring.processor; -import java.lang.reflect.Field; -import java.lang.reflect.Method; -import java.lang.reflect.Modifier; import java.beans.PropertyDescriptor; import java.lang.annotation.Annotation; -import java.util.List; +import java.lang.reflect.Field; +import java.lang.reflect.Method; -import org.springframework.util.Assert; -import org.springframework.beans.BeanUtils; -import org.springframework.util.ReflectionUtils; import org.springframework.beans.BeansException; import org.springframework.beans.FatalBeanException; import org.springframework.beans.factory.config.BeanPostProcessor; +import org.springframework.util.Assert; +import org.springframework.util.ReflectionUtils; -import org.oasisopen.sca.annotation.Property; -import org.apache.tuscany.sca.assembly.ComponentProperty; -import org.apache.tuscany.sca.core.factory.ObjectFactory; -import org.apache.tuscany.sca.implementation.java.injection.JavaPropertyValueObjectFactory; -import org.apache.tuscany.sca.runtime.RuntimeComponent; +import com.sun.xml.internal.bind.v2.runtime.property.Property; public class PropertyAnnotationProcessor implements BeanPostProcessor { - private Class propertyAnnotationType = Property.class; - - private RuntimeComponent component; +// private Class propertyAnnotationType = Property.class; + private Class propertyAnnotationType; - private JavaPropertyValueObjectFactory propertyFactory; +// private RuntimeComponent component; +// +// private JavaPropertyValueObjectFactory propertyFactory; - public PropertyAnnotationProcessor (JavaPropertyValueObjectFactory propertyFactory, - RuntimeComponent component) { - this.propertyFactory = propertyFactory; - this.component = component; + public PropertyAnnotationProcessor (Class propertyAnnotationType) { + this.propertyAnnotationType = propertyAnnotationType; +// this.propertyFactory = propertyFactory; +// this.component = component; } /** @@ -97,62 +91,62 @@ public class PropertyAnnotationProcessor implements BeanPostProcessor { ReflectionUtils.doWithMethods(clazz, new ReflectionUtils.MethodCallback() { public void doWith(Method method) { - //Annotation annotation = method.getAnnotation(getPropertyAnnotationType()); - Property annotation = (Property) method.getAnnotation(getPropertyAnnotationType()); - - if (annotation != null) { - if (Modifier.isStatic(method.getModifiers())) { - throw new IllegalStateException("Property annotation is not supported on static methods"); - } - - if (Modifier.isPrivate(method.getModifiers())) { - throw new IllegalStateException("Property annotation is not supported on private methods"); - } - - if (method.getParameterTypes().length == 0) { - throw new IllegalStateException("Property annotation requires at least one argument: " + method); - } - - PropertyDescriptor pd = BeanUtils.findPropertyForMethod(method); - if (pd != null) { - String propName = annotation.name(); - if ("".equals(propName)) { - injectProperty(bean, pd, getPropertyObj(pd.getPropertyType(), pd.getName())); - } else { - injectProperty(bean, pd, getPropertyObj(pd.getPropertyType(), propName)); - } - } - } +// //Annotation annotation = method.getAnnotation(getPropertyAnnotationType()); +// Property annotation = (Property) method.getAnnotation(getPropertyAnnotationType()); +// +// if (annotation != null) { +// if (Modifier.isStatic(method.getModifiers())) { +// throw new IllegalStateException("Property annotation is not supported on static methods"); +// } +// +// if (Modifier.isPrivate(method.getModifiers())) { +// throw new IllegalStateException("Property annotation is not supported on private methods"); +// } +// +// if (method.getParameterTypes().length == 0) { +// throw new IllegalStateException("Property annotation requires at least one argument: " + method); +// } +// +// PropertyDescriptor pd = BeanUtils.findPropertyForMethod(method); +// if (pd != null) { +// String propName = annotation.name(); +// if ("".equals(propName)) { +// injectProperty(bean, pd, getPropertyObj(pd.getPropertyType(), pd.getName())); +// } else { +// injectProperty(bean, pd, getPropertyObj(pd.getPropertyType(), propName)); +// } +// } +// } } }); ReflectionUtils.doWithFields(clazz, new ReflectionUtils.FieldCallback() { public void doWith(Field field) { //Annotation annotation = field.getAnnotation(getPropertyAnnotationType()); - Property annotation = (Property) field.getAnnotation(getPropertyAnnotationType()); - - if (annotation != null) { - if (Modifier.isStatic(field.getModifiers())) { - throw new IllegalStateException("Property annotation is not supported on static fields"); - } - - if (Modifier.isPrivate(field.getModifiers())) { - throw new IllegalStateException("Property annotation is not supported on private fields"); - } - - ReflectionUtils.makeAccessible(field); - - Object propertyObj = null; - String propName = annotation.name(); - if ("".equals(propName)) { - propertyObj = getPropertyObj(field.getType(), field.getName()); - } else { - propertyObj = getPropertyObj(field.getType(), propName); - } - - if (propertyObj != null) - ReflectionUtils.setField(field, bean, propertyObj); - } +// Property annotation = (Property) field.getAnnotation(getPropertyAnnotationType()); +// +// if (annotation != null) { +// if (Modifier.isStatic(field.getModifiers())) { +// throw new IllegalStateException("Property annotation is not supported on static fields"); +// } +// +// if (Modifier.isPrivate(field.getModifiers())) { +// throw new IllegalStateException("Property annotation is not supported on private fields"); +// } +// +// ReflectionUtils.makeAccessible(field); +// +// Object propertyObj = null; +// String propName = annotation.name(); +// if ("".equals(propName)) { +// propertyObj = getPropertyObj(field.getType(), field.getName()); +// } else { +// propertyObj = getPropertyObj(field.getType(), propName); +// } +// +// if (propertyObj != null) +// ReflectionUtils.setField(field, bean, propertyObj); +// } } }); } @@ -164,15 +158,15 @@ public class PropertyAnnotationProcessor implements BeanPostProcessor { Object propertyObj = null; - List props = component.getProperties(); - for (ComponentProperty prop : props) { - if (prop.getName().equals(name)) { - // On finding the property, create a factory for it and create a Bean using - // the factory - ObjectFactory factory = propertyFactory.createValueFactory(prop, prop.getValue(), requiredType); - propertyObj = factory.getInstance(); - } // end if - } // end for +// List props = component.getProperties(); +// for (ComponentProperty prop : props) { +// if (prop.getName().equals(name)) { +// // On finding the property, create a factory for it and create a Bean using +// // the factory +// ObjectFactory factory = propertyFactory.createValueFactory(prop, prop.getValue(), requiredType); +// propertyObj = factory.getInstance(); +// } // end if +// } // end for return propertyObj; } diff --git a/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/ReferenceAnnotationProcessor.java b/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/ReferenceAnnotationProcessor.java index 48c727baab..e1aab78ff5 100644 --- a/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/ReferenceAnnotationProcessor.java +++ b/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/processor/ReferenceAnnotationProcessor.java @@ -18,30 +18,28 @@ */ package org.apache.tuscany.sca.implementation.spring.processor; -import java.lang.reflect.Field; -import java.lang.reflect.Method; -import java.lang.reflect.Modifier; import java.beans.PropertyDescriptor; import java.lang.annotation.Annotation; +import java.lang.reflect.Field; +import java.lang.reflect.Method; + +import javax.naming.Reference; -import org.springframework.util.Assert; -import org.springframework.beans.BeanUtils; -import org.springframework.util.ReflectionUtils; import org.springframework.beans.BeansException; import org.springframework.beans.FatalBeanException; import org.springframework.beans.factory.config.BeanPostProcessor; - -import org.oasisopen.sca.annotation.Reference; -import org.apache.tuscany.sca.runtime.RuntimeComponent; +import org.springframework.util.Assert; +import org.springframework.util.ReflectionUtils; public class ReferenceAnnotationProcessor implements BeanPostProcessor { - private Class referenceAnnotationType = Reference.class; +// private Class referenceAnnotationType = Reference.class; + private Class referenceAnnotationType; - private RuntimeComponent component; +// private RuntimeComponent component; - public ReferenceAnnotationProcessor (RuntimeComponent component) { - this.component = component; + public ReferenceAnnotationProcessor (Class referenceAnnotationType, Object component) { + this.referenceAnnotationType = referenceAnnotationType; } /** @@ -90,61 +88,61 @@ public class ReferenceAnnotationProcessor implements BeanPostProcessor { ReflectionUtils.doWithMethods(clazz, new ReflectionUtils.MethodCallback() { public void doWith(Method method) { //Annotation annotation = method.getAnnotation(getReferenceAnnotationType()); - Reference annotation = (Reference) method.getAnnotation(getReferenceAnnotationType()); - - if (annotation != null) { - if (Modifier.isStatic(method.getModifiers())) { - throw new IllegalStateException("Reference annotation is not supported on static methods"); - } - - if (Modifier.isPrivate(method.getModifiers())) { - throw new IllegalStateException("Reference annotation is not supported on private methods"); - } - - if (method.getParameterTypes().length == 0) { - throw new IllegalStateException("Reference annotation requires at least one argument: " + method); - } - - PropertyDescriptor pd = BeanUtils.findPropertyForMethod(method); - if (pd != null) { - String refName = annotation.name(); - if ("".equals(refName)) { - injectReference(bean, pd, pd.getName()); - } else { - injectReference(bean, pd, refName); - } - } - } +// Reference annotation = (Reference) method.getAnnotation(getReferenceAnnotationType()); +// +// if (annotation != null) { +// if (Modifier.isStatic(method.getModifiers())) { +// throw new IllegalStateException("Reference annotation is not supported on static methods"); +// } +// +// if (Modifier.isPrivate(method.getModifiers())) { +// throw new IllegalStateException("Reference annotation is not supported on private methods"); +// } +// +// if (method.getParameterTypes().length == 0) { +// throw new IllegalStateException("Reference annotation requires at least one argument: " + method); +// } +// +// PropertyDescriptor pd = BeanUtils.findPropertyForMethod(method); +// if (pd != null) { +// String refName = annotation.name(); +// if ("".equals(refName)) { +// injectReference(bean, pd, pd.getName()); +// } else { +// injectReference(bean, pd, refName); +// } +// } +// } } }); ReflectionUtils.doWithFields(clazz, new ReflectionUtils.FieldCallback() { public void doWith(Field field) { //Annotation annotation = field.getAnnotation(getReferenceAnnotationType()); - Reference annotation = (Reference) field.getAnnotation(getReferenceAnnotationType()); - - if (annotation != null) { - if (Modifier.isStatic(field.getModifiers())) { - throw new IllegalStateException("Reference annotation is not supported on static fields"); - } - - if (Modifier.isPrivate(field.getModifiers())) { - throw new IllegalStateException("Reference annotation is not supported on private fields"); - } - - ReflectionUtils.makeAccessible(field); - - Object referenceObj = null; - String refName = annotation.name(); - if ("".equals(refName)) { - referenceObj = component.getComponentContext().getService(field.getType(), field.getName()); - } else { - referenceObj = component.getComponentContext().getService(field.getType(), refName); - } - - if (referenceObj != null) - ReflectionUtils.setField(field, bean, referenceObj); - } +// Reference annotation = (Reference) field.getAnnotation(getReferenceAnnotationType()); +// +// if (annotation != null) { +// if (Modifier.isStatic(field.getModifiers())) { +// throw new IllegalStateException("Reference annotation is not supported on static fields"); +// } +// +// if (Modifier.isPrivate(field.getModifiers())) { +// throw new IllegalStateException("Reference annotation is not supported on private fields"); +// } +// +// ReflectionUtils.makeAccessible(field); +// +// Object referenceObj = null; +// String refName = annotation.name(); +// if ("".equals(refName)) { +// referenceObj = component.getComponentContext().getService(field.getType(), field.getName()); +// } else { +// referenceObj = component.getComponentContext().getService(field.getType(), refName); +// } +// +// if (referenceObj != null) +// ReflectionUtils.setField(field, bean, referenceObj); +// } } }); } @@ -154,15 +152,15 @@ public class ReferenceAnnotationProcessor implements BeanPostProcessor { */ public void injectReference(Object bean, PropertyDescriptor pd, String name) { - Object referenceObj = component.getComponentContext().getService(pd.getPropertyType(), name); - - if (referenceObj != null) { - try { - pd.getWriteMethod().invoke(bean, new Object[] { referenceObj }); - } catch (Throwable e) { - throw new FatalBeanException("Problem injecting reference: " + e.getMessage(), e); - } - } +// Object referenceObj = component.getComponentContext().getService(pd.getPropertyType(), name); +// +// if (referenceObj != null) { +// try { +// pd.getWriteMethod().invoke(bean, new Object[] { referenceObj }); +// } catch (Throwable e) { +// throw new FatalBeanException("Problem injecting reference: " + e.getMessage(), e); +// } +// } } /** diff --git a/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SCAParentApplicationContext.java b/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SCAParentApplicationContext.java new file mode 100644 index 0000000000..5adc7bbf86 --- /dev/null +++ b/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SCAParentApplicationContext.java @@ -0,0 +1,191 @@ +/* + * 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.tuscany.sca.implementation.spring.runtime.context; + +import java.io.IOException; +import java.util.List; +import java.util.Locale; +import java.util.Map; + +import org.springframework.beans.BeansException; +import org.springframework.beans.factory.BeanFactory; +import org.springframework.beans.factory.NoSuchBeanDefinitionException; +import org.springframework.beans.factory.config.AutowireCapableBeanFactory; +import org.springframework.context.ApplicationContext; +import org.springframework.context.ApplicationEvent; +import org.springframework.context.MessageSourceResolvable; +import org.springframework.context.NoSuchMessageException; +import org.springframework.core.io.Resource; + +/** + * A Spring ParentApplicationContext for a given Spring Implementation + * + * The Parent application context is responsible for handling those entities within a Spring + * application context that actually belong to SCA rather than to Spring. The principal things + * are Properties and References. These may be present either through explicit + * and elements in the application context or they may be implicit through + * unresolved Spring bean elements. In either case, it is the Parent application + * context that must provide Spring beans that correspond to the property or reference, as derived + * from the SCA composite in which the Spring application context is an implementation. + * + * @version $Rev: 511195 $ $Date: 2007-02-24 02:29:46 +0000 (Sat, 24 Feb 2007) $ + */ +class SCAParentApplicationContext implements ApplicationContext { + + // The Spring implementation for which this is the parent application context + private SpringImplementationStub implementation; + + private static final String[] EMPTY_ARRAY = new String[0]; + + public SCAParentApplicationContext(SpringImplementationStub implementation) { + this.implementation = implementation; + } // end constructor + + public Object getBean(String name) throws BeansException { + return getBean(name, (Class) null); + } + + /** + * Get a Bean for a reference or for a property. + * + * @param name - the name of the Bean required + * @param requiredType - the required type of the Bean (either a Java class or a Java interface) + * @return Object - a Bean which matches the requested bean + */ + public Object getBean(String name, Class requiredType) throws BeansException { + return implementation.getBean(name, requiredType); + } // end method getBean( String, Class ) + + public Object getBean(String name, Object[] args) throws BeansException { + return getBean(name, ((Class)null)); + } + + public boolean containsBean(String name) { + // TODO + System.out.println("Spring parent context - containsBean called for name: " + name); + return false; + } + + public boolean isSingleton(String name) throws NoSuchBeanDefinitionException { + // TODO + return false; + } + + public boolean isTypeMatch(String name, Class targetType) throws NoSuchBeanDefinitionException { + throw new UnsupportedOperationException(); + } + + public Class getType(String name) throws NoSuchBeanDefinitionException { + return null; + } + + public String[] getAliases(String name) throws NoSuchBeanDefinitionException { + return EMPTY_ARRAY; + } + + public ApplicationContext getParent() { + return null; + } + + public AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException { + return null; + } + + public String getId() { + return this.toString(); + } + + public String getDisplayName() { + return implementation.getURI(); + } + + public long getStartupDate() { + return 0; + } + + public boolean containsBeanDefinition(String beanName) { + return false; + } + + public int getBeanDefinitionCount() { + return 0; + } + + public String[] getBeanDefinitionNames() { + return new String[0]; + } + + public String[] getBeanNamesForType(Class type) { + return new String[0]; + } + + public String[] getBeanNamesForType(Class type, boolean includePrototypes, boolean includeFactoryBeans) { + return new String[0]; + } + + public Map getBeansOfType(Class type) throws BeansException { + return null; + } + + public Map getBeansOfType(Class type, boolean includePrototypes, boolean includeFactoryBeans) throws BeansException { + return null; + } + + public boolean isPrototype(String theString) { + return false; + } + + public BeanFactory getParentBeanFactory() { + return null; + } + + public boolean containsLocalBean(String name) { + return false; + } + + public String getMessage(String code, Object[] args, String defaultMessage, Locale locale) { + return null; + } + + public String getMessage(String code, Object[] args, Locale locale) throws NoSuchMessageException { + return null; + } + + public String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException { + return null; + } + + public void publishEvent(ApplicationEvent event) { + + } + + public Resource[] getResources(String locationPattern) throws IOException { + return new Resource[0]; + } + + public Resource getResource(String location) { + return null; + } + + public ClassLoader getClassLoader() { + // REVIEW: this is almost certainly flawed, but it's not clear how the SCA runtime's + // resource loading mechanism is exposed right now. + return this.getClass().getClassLoader(); + } +} diff --git a/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SpringContextTie.java b/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SpringContextTie.java new file mode 100644 index 0000000000..18d04a56f1 --- /dev/null +++ b/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SpringContextTie.java @@ -0,0 +1,160 @@ +/* + * 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.tuscany.sca.implementation.spring.runtime.context; + +import java.net.URL; +import java.util.Iterator; +import java.util.List; + +import org.apache.tuscany.sca.implementation.spring.processor.ConstructorAnnotationProcessor; +import org.apache.tuscany.sca.implementation.spring.processor.InitDestroyAnnotationProcessor; +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.beans.factory.config.BeanPostProcessor; +import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; +import org.springframework.beans.factory.config.ConstructorArgumentValues; +import org.springframework.beans.factory.config.TypedStringValue; +import org.springframework.beans.factory.support.ManagedList; +import org.springframework.beans.factory.xml.XmlBeanFactory; +import org.springframework.context.support.AbstractApplicationContext; +import org.springframework.context.support.ClassPathXmlApplicationContext; +import org.springframework.context.support.FileSystemXmlApplicationContext; +import org.springframework.context.support.GenericApplicationContext; +import org.springframework.core.io.UrlResource; + +/** + * This is the runtime side tie for the corresponding tuscany side stub class. + * It enables the Tuscany code to invoke methods on a Spring context without + * needing to know about any Spring classes. See the SpringContextStub class + * in the implementation-spring module for what the stub does. + */ +public class SpringContextTie { + + private AbstractApplicationContext springContext; + + public SpringContextTie(SpringImplementationStub implementation, URL resource) { + SCAParentApplicationContext scaParentContext = new SCAParentApplicationContext(implementation); + springContext = createApplicationContext(scaParentContext, resource); + } + + public void start() { + // Do refresh here to ensure that Spring Beans are not touched before the SCA config process is complete... + springContext.refresh(); + springContext.start(); + } + + public void close() { + springContext.close(); + if (springContext instanceof GenericApplicationContext) { + springContext.stop(); + } + } + + /** + * Include BeanPostProcessor to deal with SCA Annotations in Spring Bean + */ +// private Object createApplicationContext(SCAParentApplicationContext scaParentContext) { + + private AbstractApplicationContext createApplicationContext(SCAParentApplicationContext scaParentContext, URL resource) { + + XmlBeanFactory beanFactory = new XmlBeanFactory(new UrlResource(resource)); + AbstractApplicationContext appContext = null; + + for (String bean : beanFactory.getBeanDefinitionNames()) { + String beanClassName = (beanFactory.getType(bean)).getName(); + if (beanClassName.indexOf(".ClassPathXmlApplicationContext") != -1 || + beanClassName.indexOf(".FileSystemXmlApplicationContext") != -1) + { + BeanDefinition beanDef = beanFactory.getBeanDefinition(bean); + String[] listValues = null; + List conArgs = + beanDef.getConstructorArgumentValues().getGenericArgumentValues(); + for (ConstructorArgumentValues.ValueHolder conArg : conArgs) { + if (conArg.getValue() instanceof TypedStringValue) { + TypedStringValue value = (TypedStringValue) conArg.getValue(); + if (value.getValue().indexOf(".xml") != -1) + listValues = new String[]{value.getValue()}; + } + if (conArg.getValue() instanceof ManagedList) { + Iterator itml = ((ManagedList)conArg.getValue()).iterator(); + StringBuffer values = new StringBuffer(); + while (itml.hasNext()) { + TypedStringValue next = (TypedStringValue)itml.next(); + if (next.getValue().indexOf(".xml") != -1) { + values.append(next.getValue()); + values.append("~"); + } + } + listValues = (values.toString()).split("~"); + } + } + + if (beanClassName.indexOf(".ClassPathXmlApplicationContext") != -1) { + appContext = new ClassPathXmlApplicationContext(listValues, false, scaParentContext); + //includeAnnotationProcessors(appContext.getBeanFactory()); + return appContext; + } else { + appContext = new FileSystemXmlApplicationContext(listValues, false, scaParentContext); + //includeAnnotationProcessors(appContext.getBeanFactory()); + return appContext; + } + } + } + + // use the generic application context as default + includeAnnotationProcessors(beanFactory); + appContext = new GenericApplicationContext(beanFactory, scaParentContext); + return appContext; + } + +// public Object getBean(String id) throws SpringInvocationException { +// try { +// return springContext.getBean(beanElement.getId()); +// } catch (BeansException e) { +// throw new SpringInvocationException(e); +// } + + /** + * Include BeanPostProcessor to deal with SCA Annotations in Spring Bean + */ + private void includeAnnotationProcessors(ConfigurableListableBeanFactory beanFactory) { + + // Processor to deal with @Init and @Destroy SCA Annotations +// BeanPostProcessor initDestroyProcessor = new InitDestroyAnnotationProcessor(); +// beanFactory.addBeanPostProcessor(initDestroyProcessor); + +// TODO: implement passing the component and property factory +// // Processor to deal with @Reference SCA Annotations +// BeanPostProcessor referenceProcessor = new ReferenceAnnotationProcessor(component); +// beanFactory.addBeanPostProcessor(referenceProcessor); +// +// // Processor to deal with @Property SCA Annotations +// BeanPostProcessor propertyProcessor = new PropertyAnnotationProcessor(propertyValueObjectFactory, component); +// beanFactory.addBeanPostProcessor(propertyProcessor); +// +// // Processor to deal with @ComponentName SCA Annotations +// BeanPostProcessor componentNameProcessor = new ComponentNameAnnotationProcessor(component); +// beanFactory.addBeanPostProcessor(componentNameProcessor); + + // Processor to deal with @Constructor SCA Annotations +// BeanPostProcessor constructorProcessor = new ConstructorAnnotationProcessor(); +// beanFactory.addBeanPostProcessor(constructorProcessor); + } + +} diff --git a/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SpringImplementationStub.java b/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SpringImplementationStub.java new file mode 100644 index 0000000000..28d40453e9 --- /dev/null +++ b/java/sca/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SpringImplementationStub.java @@ -0,0 +1,82 @@ +/* + * 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.tuscany.sca.implementation.spring.runtime.context; + +import java.lang.reflect.Method; + +import org.springframework.beans.BeansException; +import org.springframework.beans.factory.NoSuchBeanDefinitionException; + +/** + * This is the runtime side stub for the corresponding Tuscany-side stub class. + * It enables the Spring code in the runtime module to invoke methods on a + * Tuscany SpringImplementation without the Spring runtime module + * needing to know about any Tuscany classes. See the SpringImplementationTie class + * in the implementation-spring module for what the tie does. + */ +public class SpringImplementationStub { + + Object tie; + Method getURI; + Method getBean; + + public SpringImplementationStub(Object tie) { + this.tie = tie; + Class tieClass = tie.getClass(); + try { + getURI = tieClass.getMethod("getURI", new Class[]{}); + getBean = tieClass.getMethod("getBean", new Class[]{String.class, Class.class}); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + public String getURI() { + try { + + return (String)getURI.invoke(tie); + + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + /** + * Get a Bean for a reference or for a property. + * + * @param name - the name of the Bean required + * @param requiredType - the required type of the Bean (either a Java class or a Java interface) + * @return Object - a Bean which matches the requested bean + */ + public Object getBean(String name, Class requiredType) throws BeansException { + try { + + Object bean = getBean.invoke(tie, new Object[] {name, requiredType}); + if (bean == null) { + throw new NoSuchBeanDefinitionException("Unable to find Bean with name " + name); + } + return bean; + + } catch (Exception e) { + throw new RuntimeException(e); + } + + } +} -- cgit v1.2.3