diff options
Diffstat (limited to 'sandbox/implementation-spring2/src/main/java')
22 files changed, 1943 insertions, 0 deletions
diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCAApplicationContext.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCAApplicationContext.java new file mode 100644 index 0000000000..fb5f53c7aa --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCAApplicationContext.java @@ -0,0 +1,50 @@ +/* + * 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.implementation.spring; + +import org.springframework.beans.factory.xml.XmlBeanDefinitionReader; +import org.springframework.context.ApplicationContext; +import org.springframework.context.support.AbstractXmlApplicationContext; +import org.springframework.core.io.Resource; + +/** + * An <code>ApplicationContext</code> specialization that registers namespace handlers for + * SCA elements - in particular the <service/>, <reference/> and <property/> elements which + * are provided as SCA extensions to the Spring application context schema + * + */ +public class SCAApplicationContext extends AbstractXmlApplicationContext { + public static final String APP_CONTEXT_PROP = "org.springframework.sca.application.context"; + private Resource appXml; + + public SCAApplicationContext(ApplicationContext parent, Resource appXml) { + super(parent); + this.appXml = appXml; + refresh(); + } + + protected void initBeanDefinitionReader(XmlBeanDefinitionReader beanDefinitionReader) { + ClassLoader cl = getClassLoader(); + beanDefinitionReader.setNamespaceHandlerResolver(new SCANamespaceHandlerResolver(cl)); + } + + protected Resource[] getConfigResources() { + return new Resource[]{appXml}; + } +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCANamespaceHandlerResolver.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCANamespaceHandlerResolver.java new file mode 100644 index 0000000000..7f6f9263da --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCANamespaceHandlerResolver.java @@ -0,0 +1,51 @@ +/* + * 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.implementation.spring; + +import org.springframework.beans.factory.xml.DefaultNamespaceHandlerResolver; +import org.springframework.beans.factory.xml.NamespaceHandler; + +/** + * Overrides the default Spring namespace resolver to automatically register {@link ScaNamespaceHandler} instead of + * requiring a value to be supplied in a Spring configuration + * + * @version $$Rev: 511195 $$ $$Date: 2007-02-24 02:29:46 +0000 (Sat, 24 Feb 2007) $$ + */ +public class SCANamespaceHandlerResolver extends DefaultNamespaceHandlerResolver { + private static final String SCA_NAMESPACE = "http://www.springframework.org/schema/sca"; + + private ScaNamespaceHandler handler; + + public SCANamespaceHandlerResolver(ClassLoader classLoader) { + super(classLoader); + handler = new ScaNamespaceHandler(/*componentType*/); + } + + public SCANamespaceHandlerResolver(String handlerMappingsLocation, ClassLoader classLoader) { + super(classLoader, handlerMappingsLocation); + handler = new ScaNamespaceHandler(/*componentType*/); + } + + public NamespaceHandler resolve(String namespaceUri) { + if (SCA_NAMESPACE.equals(namespaceUri)) { + return handler; + } + return super.resolve(namespaceUri); + } +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCAParentApplicationContext.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCAParentApplicationContext.java new file mode 100644 index 0000000000..27dc6fc130 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCAParentApplicationContext.java @@ -0,0 +1,155 @@ +package org.apache.tuscany.implementation.spring; + +import java.io.IOException; +import java.util.Locale; +import java.util.Map; + +import org.springframework.beans.BeansException; +import org.springframework.beans.factory.BeanFactory; +import org.springframework.beans.factory.BeanNotOfRequiredTypeException; +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 + * TODO - incomplete at present + * @author MikeEdwards + * + */ +class SCAParentApplicationContext implements ApplicationContext { + + // The Spring implementation for which this is the parent application context + private SpringImplementation implementation; + + private static final String[] EMPTY_ARRAY = new String[0]; + + public SCAParentApplicationContext( SpringImplementation implementation ) { + this.implementation = implementation; + } // end constructor + + public Object getBean(String name) throws BeansException { + return getBean(name, null); + } + + @SuppressWarnings("unchecked") + public Object getBean(String name, Class requiredType) throws BeansException { + // TODO provide a real implementation of this + System.out.println("Spring parent context - getBean called for name: " + name ); + return null; + } // end method getBean( String, Class ) + + 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 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/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaNamespaceHandler.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaNamespaceHandler.java new file mode 100644 index 0000000000..521daedb75 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaNamespaceHandler.java @@ -0,0 +1,38 @@ +/* + * Copyright 2002-2006 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. + * + * Created on 10-Apr-2006 by Adrian Colyer + */ +package org.apache.tuscany.implementation.spring; + +import org.springframework.beans.factory.xml.NamespaceHandlerSupport; + +/** + * Handler for the <sca:> namespace in an application context + * + * @version $Rev: 511195 $ $Date: 2007-02-24 02:29:46 +0000 (Sat, 24 Feb 2007) $ + */ +public class ScaNamespaceHandler extends NamespaceHandlerSupport { + + public ScaNamespaceHandler() { + init(); + } + + public final void init() { + registerBeanDefinitionParser("reference", new ScaReferenceBeanDefinitionParser()); + registerBeanDefinitionParser("service", new ScaServiceBeanDefinitionParser()); + } + +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaReferenceBeanDefinitionParser.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaReferenceBeanDefinitionParser.java new file mode 100644 index 0000000000..c23b39e57f --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaReferenceBeanDefinitionParser.java @@ -0,0 +1,38 @@ +/* + * Copyright 2002-2006 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. + * + * Created on 10-Apr-2006 by Adrian Colyer + */ +package org.apache.tuscany.implementation.spring; + +import org.w3c.dom.Element; + +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.beans.factory.xml.BeanDefinitionParser; +import org.springframework.beans.factory.xml.ParserContext; + +/** + * Parser for the <sca:reference> element + * + * @version $Rev: 511195 $ $Date: 2007-02-24 02:29:46 +0000 (Sat, 24 Feb 2007) $ + */ +public class ScaReferenceBeanDefinitionParser implements BeanDefinitionParser { + + public BeanDefinition parse(Element element, ParserContext parserContext) { + // do nothing, this is handled by Tuscany + return null; + } + +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaServiceBeanDefinitionParser.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaServiceBeanDefinitionParser.java new file mode 100644 index 0000000000..7b34c45a70 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaServiceBeanDefinitionParser.java @@ -0,0 +1,38 @@ +/* + * Copyright 2002-2006 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. + * + * Created on 10-Apr-2006 by Adrian Colyer + */ +package org.apache.tuscany.implementation.spring; + +import org.w3c.dom.Element; + +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.beans.factory.xml.BeanDefinitionParser; +import org.springframework.beans.factory.xml.ParserContext; + +/** + * Parser for the <sca:service/> element + * + * @version $Rev: 511195 $ $Date: 2007-02-24 02:29:46 +0000 (Sat, 24 Feb 2007) $ + */ +public class ScaServiceBeanDefinitionParser implements BeanDefinitionParser { + + public BeanDefinition parse(Element element, ParserContext parserContext) { + // do nothing, handled by Tuscany + return null; + } + +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringArtifactProcessor.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringArtifactProcessor.java new file mode 100644 index 0000000000..65c65dd289 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringArtifactProcessor.java @@ -0,0 +1,204 @@ +/* + * 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.implementation.spring; + +import static javax.xml.stream.XMLStreamConstants.END_ELEMENT; + +import javax.xml.namespace.QName; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; +import javax.xml.stream.XMLStreamWriter; + +import org.apache.tuscany.sca.assembly.AssemblyFactory; +import org.apache.tuscany.sca.assembly.ComponentType; +import org.apache.tuscany.sca.assembly.Property; +import org.apache.tuscany.sca.assembly.Reference; +import org.apache.tuscany.sca.assembly.Service; +import org.apache.tuscany.sca.assembly.xml.Constants; +import org.apache.tuscany.sca.contribution.resolver.ModelResolver; +import org.apache.tuscany.sca.contribution.service.ContributionReadException; +import org.apache.tuscany.sca.contribution.service.ContributionResolveException; +import org.apache.tuscany.sca.contribution.service.ContributionWireException; +import org.apache.tuscany.sca.contribution.service.ContributionWriteException; +import org.apache.tuscany.implementation.spring.xml.SpringXMLComponentTypeLoader; +import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor; + +import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory; +import org.apache.tuscany.sca.policy.PolicyFactory; +import org.apache.tuscany.sca.interfacedef.java.introspect.JavaInterfaceIntrospector; + + +/* + * SpringArtifactProcessor is responsible for processing the XML of an <implementation.spring.../> + * element in an SCA SCDL file. + */ +public class SpringArtifactProcessor implements StAXArtifactProcessor<SpringImplementation> { + + private static final String LOCATION = "location"; + private static final String IMPLEMENTATION_SPRING = "implementation.spring"; + private static final QName IMPLEMENTATION_SPRING_QNAME = + new QName(Constants.SCA10_NS, IMPLEMENTATION_SPRING); + private static final String MSG_LOCATION_MISSING = "Reading implementation.spring - location attribute missing"; + + private AssemblyFactory assemblyFactory; + private JavaInterfaceFactory javaFactory; + private JavaInterfaceIntrospector interfaceIntrospector; + private PolicyFactory policyFactory; + // TODO: runtime needs to provide a better way to get the PropertyValueObjectFactory + private SpringPropertyValueObjectFactory propertyFactory; + + + public SpringArtifactProcessor( AssemblyFactory assemblyFactory, + JavaInterfaceFactory javaFactory, + JavaInterfaceIntrospector interfaceIntrospector, + PolicyFactory policyFactory, + SpringPropertyValueObjectFactory propertyFactory ) { + this.assemblyFactory = assemblyFactory; + this.javaFactory = javaFactory; + this.interfaceIntrospector = interfaceIntrospector; + this.policyFactory = policyFactory; + this.propertyFactory = propertyFactory; + + } + + /* + * Read the XML and parse out the attributes. + * + * <implementation.spring.../> has a single required attribute: + * "location" - which is the target URI of of an archive file or a directory that contains the Spring + * application context files. + * If the resource identified by the location attribute is an archive file, then the file + * META-INF/MANIFEST.MF is read from the archive. + * If the location URI identifies a directory, then META-INF/MANIFEST.MF must exist + * underneath that directory. + * If the manifest file contains a header "Spring-Context" of the format: + * Spring-Context ::= path ( ';' path )* + * + * Where path is a relative path with respect to the location URI, then the set of paths + * specified in the header identify the context configuration files. + * If there is no MANIFEST.MF file or no Spring-Context header within that file, + * then the default behaviour is to build an application context using all the *.xml files + * in the METAINF/spring directory. + */ + public SpringImplementation read(XMLStreamReader reader) throws ContributionReadException { + + try { + /* Read the location attribute for the spring implementation */ + String springLocation = reader.getAttributeValue(null, LOCATION); + if (springLocation == null) { + throw new ContributionReadException( MSG_LOCATION_MISSING ); + } + /* Create the Spring implementation and set the location into it */ + SpringImplementation springImplementation = new SpringImplementation(); + springImplementation.setSpringLocation( springLocation ); + + // Skip to end element + while (reader.hasNext()) { + if (reader.next() == END_ELEMENT && IMPLEMENTATION_SPRING_QNAME.equals(reader.getName())) { + break; + } + } // end while + + processComponentType(springImplementation); + + return springImplementation; + + } catch (XMLStreamException e) { + throw new ContributionReadException(e); + } + } // end read + + /* + * Handles the component type for the Spring implementation + * @param springImplementation - a Spring implementation. The component type information + * is created for this implementation + * + */ + private void processComponentType(SpringImplementation springImplementation) { + + // Create a ComponentType and mark it unresolved + ComponentType componentType = assemblyFactory.createComponentType(); + componentType.setUnresolved(true); + springImplementation.setComponentType(componentType); + } // end processComponentType + + /* + * Write out the XML representation of the Spring implementation + * <implementation.spring location="..." /> + */ + public void write(SpringImplementation springImplementation, XMLStreamWriter writer) throws ContributionWriteException { + try { + + writer.writeStartElement(Constants.SCA10_NS, IMPLEMENTATION_SPRING); + if (springImplementation.getSpringLocation() != null) { + writer.writeAttribute(LOCATION, springImplementation.getSpringLocation()); + } + writer.writeEndElement(); + + } catch (XMLStreamException e) { + throw new ContributionWriteException(e); + } + } // end write + + /** + * Resolves the Spring implementation - loads the Spring application-context XML and + * derives the spring implementation componentType from it + */ + public void resolve(SpringImplementation springImplementation, ModelResolver resolver) + throws ContributionResolveException { + + /* Load the Spring component type by reading the Spring application context */ + SpringXMLComponentTypeLoader springLoader = + new SpringXMLComponentTypeLoader( assemblyFactory, interfaceIntrospector, + javaFactory, policyFactory ); + try { + // Load the Spring Implementation information from its application context file... + springLoader.load( springImplementation ); + } catch ( ContributionReadException e ) { + throw new ContributionResolveException( e ); + } + + ComponentType ct = springImplementation.getComponentType(); + if( ct.isUnresolved() ) { + // If the introspection fails to resolve, try to find a side file... + ComponentType componentType = resolver.resolveModel(ComponentType.class, ct); + if (componentType.isUnresolved()) { + throw new ContributionResolveException("SpringArtifactProcessor: unable to resolve componentType for Spring component"); + } + springImplementation.setComponentType(componentType); + + springImplementation.setUnresolved(false); + } // end if + + } // end method resolve + + public void wire(SpringImplementation model) throws ContributionWireException { + // TODO Auto-generated method stub + } + + public QName getArtifactType() { + return IMPLEMENTATION_SPRING_QNAME; + } + + public Class<SpringImplementation> getModelType() { + return SpringImplementation.class; + } + +} // end class SpringArtifactProcessor diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringBeanNotFoundException.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringBeanNotFoundException.java new file mode 100644 index 0000000000..44d6803848 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringBeanNotFoundException.java @@ -0,0 +1,11 @@ +package org.apache.tuscany.implementation.spring; + +public class SpringBeanNotFoundException extends Exception { + + private static final long serialVersionUID = -1157790036638157553L; + + public SpringBeanNotFoundException( String msg ) { + super( msg ); + } + +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementation.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementation.java new file mode 100644 index 0000000000..5107bc8599 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementation.java @@ -0,0 +1,118 @@ +/* + * 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.implementation.spring; + +import java.util.List; +import java.util.Hashtable; + +import org.apache.tuscany.sca.assembly.ComponentType; +import org.apache.tuscany.sca.assembly.Implementation; +import org.apache.tuscany.sca.assembly.Reference; +import org.apache.tuscany.sca.assembly.Service; +import org.apache.tuscany.sca.assembly.impl.ComponentTypeImpl; + +import org.springframework.core.io.Resource; + +import org.apache.tuscany.implementation.spring.xml.SpringBeanElement; + +/** + * Represents a Spring implementation. + * + * TBD: Incomplete and needs substantial work... MJE, 4th May 2007 + */ +public class SpringImplementation extends ComponentTypeImpl implements Implementation { + + // The location attribute which points to the Spring application-context XML file + private String springLocation; + // The application-context file as a Spring Resource + private Resource resource; + private ComponentType componentType; + // Mapping of Services to Beans + private Hashtable<String,SpringBeanElement> serviceMap; + + protected SpringImplementation() { + this.springLocation = null; + this.resource = null; + setUnresolved(true); + serviceMap = new Hashtable<String,SpringBeanElement>(); + } + + /* Returns the location attribute for this Spring implementation */ + public String getSpringLocation() { + return springLocation; + } + + /** + * Sets the location attribute for this Spring implementation + * location - a URI to the Spring application-context file + */ + public void setSpringLocation(String location) { + this.springLocation = location; + return; + } + + public void setResource( Resource resource ) { + this.resource = resource; + } + + public Resource getResource() { + return resource; + } + + /* + * Returns the componentType for this Spring implementation + */ + public ComponentType getComponentType() { + return componentType; + } + + /* + * Sets the componentType for this Spring implementation + */ + public void setComponentType(ComponentType componentType) { + this.componentType = componentType; + } + + public List<Service> getServices() { + return componentType.getServices(); + } + + public List<Reference> getReferences() { + return componentType.getReferences(); + } + + /** + * Returns the Spring Bean which implements a particular service + * @param service the service + * @return the bean which implements the service, as a SpringBeanElement + */ + public SpringBeanElement getBeanFromService( Service service ) { + SpringBeanElement theBean = serviceMap.get( service.getName() ); + return theBean; + } + + /** + * Sets the mapping from a service to the Spring Bean that implements the service + * @param service the service + * @param theBean a SpringBeanElement for the Bean implementing the service + */ + public void setBeanForService( Service service, SpringBeanElement theBean ) { + serviceMap.put( service.getName(), theBean ); + } +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementationProvider.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementationProvider.java new file mode 100644 index 0000000000..fb5a81b2b6 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementationProvider.java @@ -0,0 +1,71 @@ +package org.apache.tuscany.implementation.spring; + +import java.net.URI; + +import org.apache.tuscany.sca.assembly.ComponentService; +import org.apache.tuscany.sca.assembly.Service; +import org.apache.tuscany.sca.core.invocation.ProxyFactory; +import org.apache.tuscany.sca.databinding.DataBindingExtensionPoint; +import org.apache.tuscany.sca.factory.ObjectFactory; +import org.apache.tuscany.sca.interfacedef.Operation; +import org.apache.tuscany.sca.invocation.Invoker; +import org.apache.tuscany.sca.runtime.RuntimeComponent; +import org.apache.tuscany.sca.runtime.RuntimeComponentService; +import org.apache.tuscany.sca.provider.ImplementationProvider; +import org.osoa.sca.ComponentContext; + +import org.springframework.context.support.AbstractApplicationContext; + +// TODO - create a working version of this class... +/** + * A provider class for runtime Spring implementation instances + */ +public class SpringImplementationProvider implements ImplementationProvider { + private SpringImplementation implementation; + private RuntimeComponent component; + + // A Spring application context object + private AbstractApplicationContext springContext; + + /** + * Constructor for the provider - takes a component definition and a Spring implementation + * description + * @param component - the component in the assembly + * @param implementation - the implementation + */ + public SpringImplementationProvider( RuntimeComponent component, + SpringImplementation implementation ) { + super(); + this.implementation = implementation; + this.component = component; + SCAParentApplicationContext scaParentContext = + new SCAParentApplicationContext( implementation ); + springContext = new SCAApplicationContext(scaParentContext, implementation.getResource() ); + } // end constructor + + public Invoker createInvoker(RuntimeComponentService service, Operation operation) { + return new SpringInvoker( component, springContext, service, operation ); + } + + public Invoker createCallbackInvoker(Operation operation) { + return new SpringInvoker( component, springContext, null, operation ); + } + + /** + * Start this Spring implementation instance + */ + public void start() { + springContext.start(); + System.out.println("SpringImplementationProvider: Spring context started"); + } // end method start() + + /** + * Stop this implementation instance + */ + public void stop() { + // TODO - complete + springContext.stop(); + System.out.println("SpringImplementationProvider: Spring context stopped"); + } // end method stop + +} // end class SpringImplementationProvider diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementationProviderFactory.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementationProviderFactory.java new file mode 100644 index 0000000000..d005dc5c75 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementationProviderFactory.java @@ -0,0 +1,40 @@ +package org.apache.tuscany.implementation.spring; + +import org.apache.tuscany.sca.provider.ImplementationProvider; +import org.apache.tuscany.sca.provider.ImplementationProviderFactory; +import org.apache.tuscany.sca.runtime.RuntimeComponent; + +/** + * ImplementationProviderFactory for Spring implementation type + * @author MikeEdwards + * + */ +public class SpringImplementationProviderFactory implements ImplementationProviderFactory<SpringImplementation> { + + /** + * Simple constructor + * + */ + public SpringImplementationProviderFactory() { + super(); + } + + /** + * Returns a SpringImplementationProvider for a given component and Spring implementation + * @param component the component for which implementation instances are required + * @param implementation the Spring implementation with details of the component + * implementation + * @return the SpringImplementationProvider for the specified component + */ + public ImplementationProvider createImplementationProvider(RuntimeComponent component, + SpringImplementation implementation) { + return new SpringImplementationProvider( component, implementation ); + } + + /** + * Returns the class of the Spring implementation + */ + public Class<SpringImplementation> getModelType() { + return SpringImplementation.class; + } +} // end class SpringImplementationProviderFactory diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringInvocationException.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringInvocationException.java new file mode 100644 index 0000000000..953d3e5083 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringInvocationException.java @@ -0,0 +1,11 @@ +package org.apache.tuscany.implementation.spring; + +public class SpringInvocationException extends Exception { + + private static final long serialVersionUID = -1157790036638157513L; + + public SpringInvocationException( String msg ) { + super( msg ); + } + +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringInvoker.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringInvoker.java new file mode 100644 index 0000000000..f93e61f230 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringInvoker.java @@ -0,0 +1,101 @@ +package org.apache.tuscany.implementation.spring; + + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +import org.apache.tuscany.sca.core.invocation.ThreadMessageContext; +import org.apache.tuscany.sca.interfacedef.ConversationSequence; +import org.apache.tuscany.sca.interfacedef.Operation; +import org.apache.tuscany.sca.interfacedef.java.impl.JavaInterfaceUtil; +import org.apache.tuscany.sca.invocation.Invoker; +import org.apache.tuscany.sca.invocation.Message; +import org.apache.tuscany.sca.runtime.RuntimeComponent; +import org.apache.tuscany.sca.runtime.RuntimeComponentService; +import org.apache.tuscany.sca.scope.InstanceWrapper; + +import org.apache.tuscany.implementation.spring.xml.SpringBeanElement; + +import org.springframework.context.support.AbstractApplicationContext; +import org.springframework.beans.BeansException; + +/** + * Initial implementation of a Spring bean invoker + * @author MikeEdwards + * + */ +public class SpringInvoker implements Invoker { + + private Method theMethod; + private Object bean; + private SpringBeanElement beanElement; + private boolean badInvoker = false; + + /** + * SpringInvoker constructor + * @param component - the Spring component to invoke + * @param service - the service to invoke + * @param operation - the operation to invoke + */ + public SpringInvoker( RuntimeComponent component, + AbstractApplicationContext springContext, + RuntimeComponentService service, + Operation operation) { + + // From the component and the service, identify the Spring Bean which is the target + SpringImplementation theImplementation = (SpringImplementation) component.getImplementation(); + beanElement = theImplementation.getBeanFromService( service.getService() ); + + if( beanElement == null ) { + badInvoker = true; + return; + } + // Now load the class for the bean and get the method relating to the operation.... + try { + bean = springContext.getBean( beanElement.getId() ); + Class<?> beanClass = bean.getClass(); + theMethod = JavaInterfaceUtil.findMethod( beanClass, operation ); + System.out.println("SpringInvoker - found method " + theMethod.getName() ); + } catch ( BeansException e ) { + badInvoker = true; + } catch ( NoSuchMethodException e ) { + badInvoker = true; + } + } // end constructor SpringInvoker + + private Object doInvoke(Object payload) throws SpringInvocationException { + if( badInvoker ) throw new SpringInvocationException("Spring invoker incorrectly configured"); + // Invoke the method on the Spring bean using the payload, returning the results + try { + Object ret; + + if (payload != null && !payload.getClass().isArray()) { + ret = theMethod.invoke(bean, payload); + } else { + ret = theMethod.invoke(bean, (Object[])payload); + } + return ret; + } catch (InvocationTargetException e) { + throw new SpringInvocationException( e.getMessage() ); + } catch (Exception e) { + throw new SpringInvocationException( e.getMessage() ); + } + + } // end method doInvoke + + /** + * @param msg the message to invoke on the target bean + */ + public Message invoke(Message msg) { + try { + Object resp = doInvoke(msg.getBody()); + msg.setBody(resp); + } catch (SpringInvocationException e) { + msg.setFaultBody(e.getCause()); + } + System.out.println("Spring Invoker - invoke called"); + return msg; + } // end method invoke + + +} // end class SpringInvoker diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringModuleActivator.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringModuleActivator.java new file mode 100644 index 0000000000..7d37909d36 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringModuleActivator.java @@ -0,0 +1,127 @@ +/* + * 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.implementation.spring; + +import java.util.Map; + +import org.apache.tuscany.sca.assembly.AssemblyFactory; +import org.apache.tuscany.sca.assembly.DefaultAssemblyFactory; +import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint; +import org.apache.tuscany.sca.core.ExtensionPointRegistry; +import org.apache.tuscany.sca.core.ModuleActivator; +import org.apache.tuscany.sca.databinding.DataBindingExtensionPoint; +import org.apache.tuscany.sca.databinding.TransformerExtensionPoint; +import org.apache.tuscany.sca.databinding.Mediator; +import org.apache.tuscany.sca.databinding.impl.MediatorImpl; +import org.apache.tuscany.sca.implementation.java.context.JavaPropertyValueObjectFactory; +import org.apache.tuscany.sca.implementation.java.introspect.DefaultJavaClassIntrospectorExtensionPoint; +import org.apache.tuscany.sca.implementation.java.introspect.JavaClassIntrospectorExtensionPoint; +import org.apache.tuscany.sca.implementation.java.invocation.JavaImplementationProviderFactory; + +import org.apache.tuscany.sca.interfacedef.java.DefaultJavaInterfaceFactory; +import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory; +import org.apache.tuscany.sca.interfacedef.java.introspect.JavaInterfaceIntrospector; +import org.apache.tuscany.sca.interfacedef.java.introspect.JavaInterfaceIntrospectorExtensionPoint; +import org.apache.tuscany.sca.interfacedef.java.introspect.ExtensibleJavaInterfaceIntrospector; +import org.apache.tuscany.sca.policy.DefaultPolicyFactory; +import org.apache.tuscany.sca.policy.PolicyFactory; +import org.apache.tuscany.sca.provider.ProviderFactoryExtensionPoint; + +/* + * ModuleActivator class for the Spring module + * - this class is invoked by the Tuscany SCA core when the Spring module is included in the + * runtime package + * - it registers a series of extension points which the core will use when dealing with + * components which use <implementation.spring.../> + * + */ +public class SpringModuleActivator implements ModuleActivator { + + private SpringArtifactProcessor springArtifactProcessor; + private AssemblyFactory assemblyFactory; + private JavaInterfaceFactory javaFactory; + private PolicyFactory policyFactory; + private JavaInterfaceIntrospector interfaceIntrospector; + private JavaClassIntrospectorExtensionPoint classVisitors; + + public SpringModuleActivator() { + assemblyFactory = new DefaultAssemblyFactory(); + javaFactory = new DefaultJavaInterfaceFactory(); + policyFactory = new DefaultPolicyFactory(); + + } // end constructor + + /* + * start() is called when the Tuscany core starts the Spring module + * + * It is in this method that the registration of the extension points takes place: + * - SpringArtifactProcessor processes the XML for <implementation.spring.../> + * - SpringComponentBuilder actually builds components based on <implementation.spring.../> + * - SpringPropertyValueObjectFactory handles properties for implementation.spring components + */ + public void start(ExtensionPointRegistry registry) { + + DataBindingExtensionPoint dataBindingRegistry = registry.getExtensionPoint(DataBindingExtensionPoint.class); + + // TODO: could the runtime have a default PropertyValueObjectFactory in the registry + DataBindingExtensionPoint dataBindings = registry.getExtensionPoint(DataBindingExtensionPoint.class); + TransformerExtensionPoint transformers = registry.getExtensionPoint(TransformerExtensionPoint.class); + MediatorImpl mediator = new MediatorImpl(dataBindings, transformers); + SpringPropertyValueObjectFactory propertyFactory = new SpringPropertyValueObjectFactory(mediator); + + // Tools for Java interface handling + JavaInterfaceIntrospectorExtensionPoint interfaceVisitors = + registry.getExtensionPoint(JavaInterfaceIntrospectorExtensionPoint.class); + interfaceIntrospector = new ExtensibleJavaInterfaceIntrospector(javaFactory, interfaceVisitors); + + // Create the artifact processor for Spring artifacts and add to artifact processors + springArtifactProcessor = new SpringArtifactProcessor( assemblyFactory, javaFactory, + interfaceIntrospector, policyFactory, propertyFactory ); + + StAXArtifactProcessorExtensionPoint staxProcessors = registry.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class); + staxProcessors.addArtifactProcessor(springArtifactProcessor); + + // Create SpringImplementationFactory and add to provider factories + SpringImplementationProviderFactory springImplementationProviderFactory = + new SpringImplementationProviderFactory(); + + ProviderFactoryExtensionPoint providerFactories = registry.getExtensionPoint(ProviderFactoryExtensionPoint.class); + providerFactories.addProviderFactory(springImplementationProviderFactory); + } + + /* + * stop() is called when the Tuscany core stops the Spring module + * At present, no action is taken + */ + public void stop(ExtensionPointRegistry registry) { + StAXArtifactProcessorExtensionPoint staxProcessors = registry.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class); + staxProcessors.removeArtifactProcessor(springArtifactProcessor); + } + + /* + * Return a map of the extension points for the Spring module. + * Not implemented at present (the core does not seem to require it) + */ + public Object[] getExtensionPoints() { + classVisitors = new DefaultJavaClassIntrospectorExtensionPoint(); + return new Object[] { classVisitors }; + } + +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringOperationNotFoundException.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringOperationNotFoundException.java new file mode 100644 index 0000000000..36b3e1f786 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringOperationNotFoundException.java @@ -0,0 +1,12 @@ +package org.apache.tuscany.implementation.spring; + +public class SpringOperationNotFoundException extends Exception { + + private static final long serialVersionUID = -1157790036638157554L; + + public SpringOperationNotFoundException( String msg ) { + super( msg ); + } + + +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringPropertyValueObjectFactory.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringPropertyValueObjectFactory.java new file mode 100644 index 0000000000..658a96a0d4 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringPropertyValueObjectFactory.java @@ -0,0 +1,46 @@ +/* + * 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.implementation.spring; + +import org.apache.tuscany.sca.implementation.java.context.JavaPropertyValueObjectFactory; +import org.apache.tuscany.sca.databinding.Mediator; + +/** + * + * @author MikeEdwards + * + * Factory class for PropertyValueObjects for Spring implementations + * + * 6th May 2007: Chosen a very simple design for this class - since Spring implementations are a form + * of Java POJO, the simple design chosen for this class is to re-use the PropertyValueObjectFactory + * implementation from the base implementation-java-runtime package of Tuscany SCA Java, since the + * same properties are going to be rendered in the same way to simple Tuscany POJOs and to Spring + * Bean POJOs. Mike Edwards + */ +public class SpringPropertyValueObjectFactory extends JavaPropertyValueObjectFactory { + + /** + * Constructor simply defers to the superclass, along with the complete implementation... + */ + public SpringPropertyValueObjectFactory(Mediator mediator) { + super(mediator); + } // end constructor JavaPropertyValueObjectFactory(Mediator mediator) + +} // end class SpringPropertyValueObjectFactory
\ No newline at end of file diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringBeanElement.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringBeanElement.java new file mode 100644 index 0000000000..d658859e60 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringBeanElement.java @@ -0,0 +1,60 @@ +/* + * 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.implementation.spring.xml; + +import java.util.List; +import java.util.ArrayList; + + +/** + * Represents a <bean> element in a Spring application-context + * - this has id and className attributes + * - plus zero or more property elements as children + * + * @version $Rev: 512919 $ $Date: 2007-02-28 19:32:56 +0000 (Wed, 28 Feb 2007) $ + */ +public class SpringBeanElement { + + private String id; + private String className; + private List<SpringPropertyElement> properties = new ArrayList<SpringPropertyElement>(); + + public SpringBeanElement( String id, String className ) { + this.id = id; + this.className = className; + } + + public String getClassName() { + return className; + } + + public String getId() { + return id; + } + + public List<SpringPropertyElement> getProperties() { + return properties; + } + + public void addProperty( SpringPropertyElement property ) { + properties.add( property ); + } + + +} // end class SpringBeanElement
\ No newline at end of file diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringBeanIntrospector.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringBeanIntrospector.java new file mode 100644 index 0000000000..0fdeb4da71 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringBeanIntrospector.java @@ -0,0 +1,151 @@ +/* + * 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.implementation.spring.xml; + +import java.util.List; +import java.util.ArrayList; +import java.util.Iterator; + +import org.apache.tuscany.sca.assembly.AssemblyFactory; +import org.apache.tuscany.sca.contribution.service.ContributionResolveException; +import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory; +import org.apache.tuscany.sca.interfacedef.java.introspect.JavaInterfaceIntrospector; +import org.apache.tuscany.sca.implementation.java.DefaultJavaImplementationFactory; +import org.apache.tuscany.sca.implementation.java.JavaImplementation; +import org.apache.tuscany.sca.implementation.java.JavaImplementationFactory; +import org.apache.tuscany.sca.implementation.java.introspect.DefaultJavaClassIntrospectorExtensionPoint; +import org.apache.tuscany.sca.implementation.java.introspect.ExtensibleJavaClassIntrospector; +import org.apache.tuscany.sca.implementation.java.introspect.IntrospectionException; +import org.apache.tuscany.sca.implementation.java.introspect.JavaClassIntrospector; +import org.apache.tuscany.sca.implementation.java.introspect.JavaClassIntrospectorExtensionPoint; +import org.apache.tuscany.sca.implementation.java.introspect.JavaClassVisitor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.AllowsPassByReferenceProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.BaseJavaClassVisitor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.ConstructorProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.ContextProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.ConversationProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.DestroyProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.EagerInitProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.HeuristicPojoProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.InitProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.PolicyProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.PropertyProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.ReferenceProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.ResourceProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.ScopeProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.ServiceProcessor; +import org.apache.tuscany.sca.policy.PolicyFactory; + +import org.apache.tuscany.sca.assembly.ComponentType; +import org.apache.tuscany.sca.assembly.Reference; +import org.apache.tuscany.sca.assembly.Service; + +/** + * Provides introspection functions for Spring beans + * This version leans heavily on the implementation-java classes + * + * @version $Rev: 512919 $ $Date: 2007-02-28 19:32:56 +0000 (Wed, 28 Feb 2007) $ + */ +public class SpringBeanIntrospector { + + private JavaClassIntrospector classIntrospector; + private JavaClassIntrospectorExtensionPoint classVisitors = + new DefaultJavaClassIntrospectorExtensionPoint(); + private JavaImplementationFactory javaImplementationFactory; + + /** + * The constructor sets up the various visitor elements that will be used to inrospect + * the Spring bean and extract SCA information + * @param assemblyFactory - an AssemblyFactory + * @param interfaceIntrospector - an Java InterfaceIntrospector + * @param javaFactory - a Java Interface Factory + */ + public SpringBeanIntrospector( AssemblyFactory assemblyFactory, + JavaInterfaceIntrospector interfaceIntrospector, + JavaInterfaceFactory javaFactory, + PolicyFactory policyFactory ) { + + // Create the list of class visitors + BaseJavaClassVisitor[] extensions = new BaseJavaClassVisitor[] { + new ConstructorProcessor(assemblyFactory), + new AllowsPassByReferenceProcessor(assemblyFactory), + new ContextProcessor(assemblyFactory), + new ConversationProcessor(assemblyFactory), + new DestroyProcessor(assemblyFactory), + new EagerInitProcessor(assemblyFactory), + new InitProcessor(assemblyFactory), + new PropertyProcessor(assemblyFactory), + new ReferenceProcessor(assemblyFactory, javaFactory, interfaceIntrospector), + new ResourceProcessor(assemblyFactory), + new ScopeProcessor(assemblyFactory), + new ServiceProcessor(assemblyFactory, javaFactory, interfaceIntrospector), + new HeuristicPojoProcessor(assemblyFactory, javaFactory, interfaceIntrospector), + new PolicyProcessor(assemblyFactory, policyFactory) + }; + for (JavaClassVisitor extension : extensions) { + classVisitors.addClassVisitor(extension); + } + this.classIntrospector = new ExtensibleJavaClassIntrospector(classVisitors); + + javaImplementationFactory = new DefaultJavaImplementationFactory(); + + } // end constructor + + /** + * Introspect a Spring Bean and extract the features important to SCA + * @param beanClass the Spring Bean class to introspect + * @param componentType the componentType that is filled in through the introspection + * process (assumed empty on invocation, filled on return + * @throws ContributionResolveException - if there was a problem resolving the + * Spring Bean or its componentType + * + */ + public void introspectBean( Class<?> beanClass, ComponentType componentType ) + throws ContributionResolveException { + + if( componentType == null ) throw new ContributionResolveException( + "Introspect Spring bean: supplied componentType is null" ); + + // Create a Java implementation ready for the introspection + JavaImplementation javaImplementation = javaImplementationFactory.createJavaImplementation(); + + try { + // Introspect the bean...the results of the introspection are placed into the Java implementation + classIntrospector.introspect( beanClass, javaImplementation); + + // Extract the services, references & properties found through introspection + // put the services, references and properties into the component type + componentType.getServices().addAll( javaImplementation.getServices() ); + componentType.getReferences().addAll( javaImplementation.getReferences() ); + componentType.getProperties().addAll( javaImplementation.getProperties() ); + } catch (IntrospectionException e) { + throw new ContributionResolveException(e); + } // end try + + List<Service> services = javaImplementation.getServices(); + for ( Service service : services ) { + String name = service.getName(); + System.out.println("Spring Bean: found service with name: " + name); + } // end for + + } // end method introspectBean + + + +} // end class SpringBeanIntrospector
\ No newline at end of file diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringPropertyElement.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringPropertyElement.java new file mode 100644 index 0000000000..45cb4f01b6 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringPropertyElement.java @@ -0,0 +1,46 @@ +/* + * 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.implementation.spring.xml; + + +/** + * Represents a <property> element in a Spring application-context + * - this has name and ref attributes + * + * @version $Rev: 512919 $ $Date: 2007-02-28 19:32:56 +0000 (Wed, 28 Feb 2007) $ + */ +public class SpringPropertyElement { + + private String name; + private String ref; + + public SpringPropertyElement( String name, String ref ) { + this.name = name; + this.ref = ref; + } + + public String getName() { + return name; + } + + public String getRef() { + return ref; + } + +} // end class SpringPropertyElement
\ No newline at end of file diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringSCAReferenceElement.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringSCAReferenceElement.java new file mode 100644 index 0000000000..4105034f54 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringSCAReferenceElement.java @@ -0,0 +1,47 @@ +/* + * 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.implementation.spring.xml; + + +/** + * Represents a <sca:reference> element in a Spring application-context + * - this has id and className attributes + * - plus zero or more property elements as children + * + * @version $Rev: 512919 $ $Date: 2007-02-28 19:32:56 +0000 (Wed, 28 Feb 2007) $ + */ +public class SpringSCAReferenceElement { + + private String name; + private String type; + + public SpringSCAReferenceElement( String name, String type ) { + this.name = name; + this.type = type; + } + + public String getName() { + return name; + } + + public String getType() { + return type; + } + +} // end class SpringSCAReferenceElement
\ No newline at end of file diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringSCAServiceElement.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringSCAServiceElement.java new file mode 100644 index 0000000000..ad2060b8d7 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringSCAServiceElement.java @@ -0,0 +1,53 @@ +/* + * 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.implementation.spring.xml; + + +/** + * Represents a <sca:service> element in a Spring application-context + * - this has id and className attributes + * - plus zero or more property elements as children + * + * @version $Rev: 512919 $ $Date: 2007-02-28 19:32:56 +0000 (Wed, 28 Feb 2007) $ + */ +public class SpringSCAServiceElement { + + private String name; + private String type; + private String target; + + public SpringSCAServiceElement( String name, String type, String target ) { + this.name = name; + this.type = type; + this.target = target; + } + + public String getName() { + return name; + } + + public String getType() { + return type; + } + + public String getTarget() { + return target; + } + +} // end class SpringSCAServiceElement
\ No newline at end of file diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringXMLComponentTypeLoader.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringXMLComponentTypeLoader.java new file mode 100644 index 0000000000..ee6a0423bd --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringXMLComponentTypeLoader.java @@ -0,0 +1,475 @@ +/* + * 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.implementation.spring.xml; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.net.MalformedURLException; +import java.net.URI; +import java.net.URL; +import java.util.jar.Attributes; +import java.util.jar.JarEntry; +import java.util.jar.JarFile; +import java.util.jar.Manifest; +import java.util.List; +import java.util.ArrayList; +import java.util.Iterator; + +import javax.xml.namespace.QName; +import javax.xml.stream.XMLInputFactory; +import static javax.xml.stream.XMLStreamConstants.END_ELEMENT; +import static javax.xml.stream.XMLStreamConstants.START_ELEMENT; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; + +import org.apache.tuscany.implementation.spring.SpringImplementation; +import org.apache.tuscany.sca.assembly.ComponentType; +import org.apache.tuscany.sca.assembly.Reference; +import org.apache.tuscany.sca.assembly.Service; +import org.apache.tuscany.sca.contribution.service.ContributionReadException; +import org.apache.tuscany.sca.interfacedef.InvalidInterfaceException; + +import org.springframework.core.io.Resource; +import org.springframework.core.io.UrlResource; + +import org.apache.tuscany.sca.assembly.AssemblyFactory; +import org.apache.tuscany.sca.assembly.Multiplicity; +import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory; +import org.apache.tuscany.sca.interfacedef.java.introspect.JavaInterfaceIntrospector; +import org.apache.tuscany.sca.interfacedef.java.JavaInterface; +import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceContract; +import org.apache.tuscany.sca.policy.PolicyFactory; +import org.apache.tuscany.sca.contribution.service.ContributionResolveException; + +/** + * Introspects a Spring XML application-context configuration file to create <implementation-spring../> + * component type information. + * + * + * @version $Rev: 512919 $ $Date: 2007-02-28 19:32:56 +0000 (Wed, 28 Feb 2007) $ + */ +public class SpringXMLComponentTypeLoader { + private static final String SCA_NS = "http://www.springframework.org/schema/sca"; + private static final String SPRING_NS = "http://www.springframework.org/schema/beans"; + private static final QName SERVICE_ELEMENT = new QName(SCA_NS, "service"); + private static final QName REFERENCE_ELEMENT = new QName(SCA_NS, "reference"); + private static final QName BEANS_ELEMENT = new QName(SPRING_NS, "beans"); + private static final QName BEAN_ELEMENT = new QName(SPRING_NS, "bean"); + private static final QName PROPERTY_ELEMENT = new QName(SPRING_NS, "property"); + private static final String APPLICATION_CONTEXT = "application-context.xml"; + + private AssemblyFactory assemblyFactory; + private JavaInterfaceIntrospector interfaceIntrospector; + private JavaInterfaceFactory javaFactory; + private PolicyFactory policyFactory; + private ClassLoader cl; + + private SpringBeanIntrospector beanIntrospector; + + public SpringXMLComponentTypeLoader( AssemblyFactory assemblyFactory, + JavaInterfaceIntrospector interfaceIntrospector, + JavaInterfaceFactory javaFactory, + PolicyFactory policyFactory) { + super(); + this.assemblyFactory = assemblyFactory; + this.interfaceIntrospector = interfaceIntrospector; + this.javaFactory = javaFactory; + this.policyFactory = policyFactory; + beanIntrospector = new SpringBeanIntrospector( assemblyFactory, + interfaceIntrospector, javaFactory, policyFactory ); + } + + protected Class<SpringImplementation> getImplementationClass() { + return SpringImplementation.class; + } + + /** + * Base method which loads the component type from the application-context attached to the + * Spring implementation + * + */ + public void load( SpringImplementation implementation ) throws ContributionReadException { + System.out.println("Spring TypeLoader - load method start"); + ComponentType componentType = implementation.getComponentType(); + /* Check that there is a component type object already set */ + if ( componentType == null) { + throw new ContributionReadException("SpringXMLLoader load: implementation has no ComponentType object"); + } + if ( componentType.isUnresolved() ) { + /* Fetch the location of the application-context file from the implementation */ + loadFromXML( implementation ); + if( !componentType.isUnresolved() ) implementation.setUnresolved( false ); + } // end if + System.out.println("Spring TypeLoader - load method complete"); + } // end method load + + /** + * Method which fills out the component type for a Spring implementation by reading the + * Spring application-context.xml file + * @param componentType - the component type to complete + * @param location - a string containing the relative location of the application-context.xml + * @return a Spring Resource for the application-context + * file + */ + private void loadFromXML( SpringImplementation implementation ) + throws ContributionReadException { + XMLStreamReader reader; + List<SpringBeanElement> beans = new ArrayList<SpringBeanElement>(); + List<SpringSCAServiceElement> services = new ArrayList<SpringSCAServiceElement>(); + List<SpringSCAReferenceElement> references = new ArrayList<SpringSCAReferenceElement>(); + SpringBeanElement bean = null; + + Resource resource; + + String location = implementation.getSpringLocation(); + + try { + // FIXME - is the ContextClassLoader the right place to start the search? + cl = Thread.currentThread().getContextClassLoader(); + + resource = getApplicationContextResource( location, cl ); + implementation.setResource( resource ); + // FIXME - need a better way to handle the XMLInputFactory than allocating a new one every time + XMLInputFactory xmlFactory = XMLInputFactory.newInstance(); + reader = xmlFactory.createXMLStreamReader(resource.getInputStream()); + + // System.out.println("Spring TypeLoader - starting to read context file"); + + boolean completed = false; + while ( !completed ) { + switch (reader.next()) { + case START_ELEMENT: + QName qname = reader.getName(); + //System.out.println("Spring TypeLoader - found element with name: " + qname.toString()); + if (SERVICE_ELEMENT.equals(qname)) { + SpringSCAServiceElement service = new SpringSCAServiceElement( + reader.getAttributeValue(SCA_NS, "name"), + reader.getAttributeValue(SCA_NS, "type"), + reader.getAttributeValue(SCA_NS, "target") ); + services.add( service ); + } else if (REFERENCE_ELEMENT.equals(qname)) { + SpringSCAReferenceElement reference = new SpringSCAReferenceElement( + reader.getAttributeValue(SCA_NS, "name"), + reader.getAttributeValue(SCA_NS, "type") ); + references.add( reference ); + } else if (BEAN_ELEMENT.equals(qname)) { + // TODO FIX THIS !! + int count=reader.getAttributeCount(); + bean = new SpringBeanElement( + reader.getAttributeValue( null, "id"), + reader.getAttributeValue( null, "class") ); + beans.add( bean ); + } else if (PROPERTY_ELEMENT.equals(qname)) { + SpringPropertyElement property = new SpringPropertyElement( + reader.getAttributeValue(SPRING_NS, "name"), + reader.getAttributeValue(SPRING_NS, "ref")); + bean.addProperty( property ); + } // end if + break; + case END_ELEMENT: + if (BEANS_ELEMENT.equals(reader.getName())) { + //System.out.println("Spring TypeLoader - finished read of context file"); + completed = true; + break; + } // end if + } // end switch + } // end while + + } catch (IOException e) { + throw new ContributionReadException(e); + } catch (XMLStreamException e) { + throw new ContributionReadException(e); + } + + /* At this point, the complete application-context.xml file has been read and its contents */ + /* stored in the lists of beans, services, references. These are now used to generate */ + /* the implied componentType for the application context */ + generateComponentType( implementation, beans, services, references ); + + return; + } // end method loadFromXML + + /** + * Generates the Spring implementation component type from the configuration contained in the + * lists of beans, services and references derived from the application context + */ + private void generateComponentType( SpringImplementation implementation, + List<SpringBeanElement> beans, + List<SpringSCAServiceElement> services, + List<SpringSCAReferenceElement> references ) + throws ContributionReadException { + /* + * Each service becomes a service in the component type + * Each reference becomes a reference in the component type + * Each bean becomes a service, unless it is the target of a service element or unless it + * is the target of a bean reference property + * Each bean property which is a reference not pointing at another bean in the + * application context becomes a reference unless it is pointing at one of the references + */ + + ComponentType componentType = implementation.getComponentType(); + + try { + // Deal with the services first.... + Iterator<SpringSCAServiceElement> its = services.iterator(); + while( its.hasNext() ) { + SpringSCAServiceElement serviceElement = its.next(); + Class<?> interfaze = cl.loadClass( serviceElement.getType() ); + Service theService = createService( interfaze, serviceElement.getName() ); + componentType.getServices().add( theService ); + // Add this service to the Service / Bean map + String beanName = serviceElement.getTarget(); + for( SpringBeanElement beanElement : beans ) { + if( beanName == beanElement.getId() ) { + implementation.setBeanForService( theService, beanElement ); + } + } // end for + } // end while + + // Next handle the references + Iterator<SpringSCAReferenceElement> itr = references.iterator(); + while( itr.hasNext() ) { + SpringSCAReferenceElement referenceElement = itr.next(); + Class<?> interfaze = cl.loadClass( referenceElement.getType() ); + Reference theReference = createReference( interfaze, referenceElement.getName() ); + componentType.getReferences().add( theReference ); + } // end while + + // Finally deal with the beans + Iterator<SpringBeanElement> itb; + // If there are no explicit service elements, then expose all the beans + if( services.isEmpty() ) { + itb = beans.iterator(); + // Loop through all the beans found + while( itb.hasNext() ) { + SpringBeanElement beanElement = itb.next(); + // Load the Spring bean class + Class<?> beanClass = cl.loadClass( beanElement.getClassName() ); + // Introspect the bean + ComponentType beanComponentType = assemblyFactory.createComponentType(); + beanIntrospector.introspectBean( beanClass, beanComponentType ); + // Get the service interface defined by this Spring Bean and add to + // the component type of the Spring Assembly + List<Service> beanServices = beanComponentType.getServices(); + componentType.getServices().addAll( beanServices ); + // Add these services to the Service / Bean map + for( Service beanService : beanServices ) { + implementation.setBeanForService( beanService, beanElement ); + } + } // end while + } // end if + // Now check to see if there are any more references + itb = beans.iterator(); + while( itb.hasNext() ) { + SpringBeanElement beanElement = itb.next(); + if( !beanElement.getProperties().isEmpty() ) { + Iterator<SpringPropertyElement> itp = beanElement.getProperties().iterator(); + while( itp.hasNext() ) { + SpringPropertyElement propertyElement = itp.next(); + if( propertyRefUnresolved( propertyElement.getRef(), beans, references ) ) { + // This means an unresolved reference from the spring bean... + // TODO + } // end if + } // end while + } // end if + + //Reference theReference = createReference( interfaze, referenceElement.getName() ); + //componentType.getReferences().add( theReference ); + } // end while + + } catch ( ClassNotFoundException e ) { + // Means that either an interface class or a bean was not found + throw new ContributionReadException( e ); + } catch ( InvalidInterfaceException e ) { + throw new ContributionReadException( e ); + } catch ( ContributionResolveException e ) { + + } // end try + + // If we get here, the Spring assembly component type is resolved + componentType.setUnresolved( false ); + implementation.setComponentType( componentType ); + return; + } // end method generateComponentType + + /* + * Determines whether a reference attribute of a Spring property element is resolved either + * by a bean in the application context or by an SCA reference element + * @param ref - a String containing the name of the reference - may be null + * @param beans - a List of SpringBean elements + * @param references - a List of SCA reference elements + * @return true if the property is not resolved, false if it is resolved + */ + private boolean propertyRefUnresolved( String ref, + List<SpringBeanElement> beans, + List<SpringSCAReferenceElement> references ) { + boolean unresolved = true; + + if( ref != null ) { + // Scan over the beans looking for a match + Iterator<SpringBeanElement> itb = beans.iterator(); + while( itb.hasNext() ) { + SpringBeanElement beanElement = itb.next(); + // Does the bean name match the ref? + if( ref.equals(beanElement.getId()) ) { + unresolved = false; + break; + } // end if + } // end while + // Scan over the references looking for a match + if( unresolved ) { + Iterator<SpringSCAReferenceElement> itr = references.iterator(); + while( itr.hasNext() ) { + SpringSCAReferenceElement referenceElement = itr.next(); + if( ref.equals(referenceElement.getName()) ) { + unresolved = false; + break; + } // end if + } // end while + } // end if + } // end if + + return unresolved; + + } // end method propertyRefUnresolved + + /** + * Gets hold of the application-context.xml file as a Spring resource + * @param locationAttr - the location attribute from the <implementation.spring../> element + * @param cl - the classloader for the Spring implementation + */ + protected Resource getApplicationContextResource( String locationAttr, ClassLoader cl ) + throws ContributionReadException { + File manifestFile = null; + File appXmlFile; + File locationFile = new File(locationAttr); + + if (!locationFile.exists()) { + // FIXME hack + URL url = cl.getResource(locationAttr); + if (url != null) { + return new UrlResource(url); + } + throw new ContributionReadException("SpringXMLLoader getApplicationContextResource: " + + "unable to find resource file " + locationFile.toString()); + } + + if (locationFile.isDirectory()) { + try { + manifestFile = new File(locationFile, "META-INF/MANIFEST.MF"); + if (manifestFile.exists()) { + Manifest mf = new Manifest(new FileInputStream(manifestFile)); + Attributes mainAttrs = mf.getMainAttributes(); + String appCtxPath = mainAttrs.getValue("Spring-Context"); + if (appCtxPath != null) { + appXmlFile = new File(locationFile, appCtxPath); + if (appXmlFile.exists()) { + return new UrlResource(appXmlFile.toURL()); + } + } + } + // no manifest-specified Spring context, use default + appXmlFile = new File(locationFile, APPLICATION_CONTEXT); + if (appXmlFile.exists()) { + return new UrlResource(appXmlFile.toURL()); + } + } catch (IOException e) { + throw new ContributionReadException("Error reading manifest " + manifestFile); + } + } else { + try { + JarFile jf = new JarFile(locationFile); + JarEntry je; + Manifest mf = jf.getManifest(); + if (mf != null) { + Attributes mainAttrs = mf.getMainAttributes(); + String appCtxPath = mainAttrs.getValue("Spring-Context"); + if (appCtxPath != null) { + je = jf.getJarEntry(appCtxPath); + if (je != null) { + // TODO return a Spring specific Resouce type for jars + return new UrlResource(new URL("jar:" + locationFile.toURL() + "!/" + appCtxPath)); + } + } + } + je = jf.getJarEntry(APPLICATION_CONTEXT); + if (je != null) { + return new UrlResource(new URL("jar:" + locationFile.toURI().toURL() + "!" + APPLICATION_CONTEXT)); + } + } catch (IOException e) { + // bad archive + // TODO: create a more appropriate exception type + throw new ContributionReadException("SpringXMLLoader getApplicationContextResource: " + + " IO exception reading context file.", e); + } + } + + throw new ContributionReadException("SpringXMLLoader getApplicationContextResource: " + + APPLICATION_CONTEXT + "not found"); + } // end method getApplicationContextResource + + /** + * Creates a Service for the component type based on its name and Java interface + */ + public Service createService( Class<?> interfaze, String name ) + throws InvalidInterfaceException { + Service service = assemblyFactory.createService(); + JavaInterfaceContract interfaceContract = javaFactory.createJavaInterfaceContract(); + service.setInterfaceContract(interfaceContract); + + // Set the name for the service + service.setName( name ); + + // Set the call interface and, if present, the callback interface + JavaInterface callInterface = interfaceIntrospector.introspect(interfaze); + service.getInterfaceContract().setInterface(callInterface); + if (callInterface.getCallbackClass() != null) { + JavaInterface callbackInterface = interfaceIntrospector.introspect(callInterface.getCallbackClass()); + service.getInterfaceContract().setCallbackInterface(callbackInterface); + } + return service; + } // end method createService + + /** + * Creates a Reference for the component type based on its name and Java interface + */ + private org.apache.tuscany.sca.assembly.Reference createReference( Class<?> interfaze, String name ) + throws InvalidInterfaceException { + org.apache.tuscany.sca.assembly.Reference reference = assemblyFactory.createReference(); + JavaInterfaceContract interfaceContract = javaFactory.createJavaInterfaceContract(); + reference.setInterfaceContract(interfaceContract); + + // Set the name of the reference to the supplied name and the multiplicity of the reference + // to 1..1 - for Spring implementations, this is the only multiplicity supported + reference.setName(name); + reference.setMultiplicity(Multiplicity.ONE_ONE); + + // Set the call interface and, if present, the callback interface + JavaInterface callInterface = interfaceIntrospector.introspect( interfaze ); + reference.getInterfaceContract().setInterface( callInterface ); + if (callInterface.getCallbackClass() != null) { + JavaInterface callbackInterface = + interfaceIntrospector.introspect(callInterface.getCallbackClass()); + reference.getInterfaceContract().setCallbackInterface(callbackInterface); + } + + return reference; + } +} // end class SpringXMLComponentTypeLoader
\ No newline at end of file |