Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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.introspect;
 
 import java.io.File;
 import java.net.URI;
 import java.net.URL;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
Introspects a Spring XML application-context configuration file to create <implementation-spring../> component type information.

Version:
$Rev: 991751 $ $Date: 2010-09-02 00:00:24 +0100 (Thu, 02 Sep 2010) $
 
 public class SpringXMLComponentTypeLoader {
     private final static Logger log = Logger.getLogger(SpringXMLComponentTypeLoader.class.getName());
 
     private ExtensionPointRegistry registry;
     private AssemblyFactory assemblyFactory;
     private PolicyFactory policyFactory;
     private JavaInterfaceFactory javaFactory;
        super();
        this. = registry;
        FactoryExtensionPoint factories = registry.getExtensionPoint(FactoryExtensionPoint.class);
        this. = factories.getFactory(AssemblyFactory.class);
        this. = factories.getFactory(PolicyFactory.class);
        this. = factories.getFactory(JavaInterfaceFactory.class);
        this. = factories.getFactory(ContributionFactory.class);
        this. =
    }

    
Report a error.

Parameters:
problems
message
model
    private void error(Monitor monitorString messageObject modelObject... messageParameters) {
        if (monitor != null) {
            Problem problem =
                monitor.createProblem(this.getClass().getName(),
                                      "impl-spring-validation-messages",
                                      .,
                                      model,
                                      message,
                                      (Object[])messageParameters);
            monitor.problem(problem);
        }
    }
    
Report a error.

Parameters:
problems
message
model
    private void warning(Monitor monitorString messageObject modelObject... messageParameters) {
        if (monitor != null) {
            Problem problem =
                monitor.createProblem(this.getClass().getName(),
                                      "impl-spring-validation-messages",
                                      .,
                                      model,
                                      message,
                                      (Object[])messageParameters);
            monitor.problem(problem);
        }
    }
        return SpringImplementation.class;
    }

    
Base method which loads the component type from the application-context attached to the Spring implementation
    public void load(SpringImplementation implementationModelResolver resolverProcessorContext context)
        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(implementationresolvercontext);
            if (!componentType.isUnresolved())
                implementation.setUnresolved(false);
        } // end if
          //System.out.println("Spring TypeLoader - load method complete");
    } // end method load
    private Class<?> resolveClass(ModelResolver resolverString classNameProcessorContext context)
        throws ClassNotFoundException {
        ClassReference classReference = new ClassReference(className);
        classReference = resolver.resolveModel(ClassReference.classclassReferencecontext);
        if (classReference.isUnresolved()) {
            throw new ClassNotFoundException(className);
        }
        Class<?> javaClass = classReference.getJavaClass();
        return javaClass;
    }

    
Method which fills out the component type for a Spring implementation by reading the Spring application-context.xml file.

Parameters:
implementation SpringImplementation into which to load the component type information
Throws:
org.apache.tuscany.sca.contribution.processor.ContributionReadException Failed to read the contribution
    private void loadFromXML(SpringImplementation implementationModelResolver resolverProcessorContext context)
        throws ContributionReadException {
        List<SpringBeanElementbeans = new ArrayList<SpringBeanElement>();
        List<SpringSCAServiceElementservices = new ArrayList<SpringSCAServiceElement>();
        List<SpringSCAReferenceElementreferences = new ArrayList<SpringSCAReferenceElement>();
        List<SpringSCAPropertyElementscaproperties = new ArrayList<SpringSCAPropertyElement>();
        URL resource;
        List<URLcontextResources = new ArrayList<URL>();
        String contextPath = implementation.getLocation();
        try {
            resource = resolveLocation(resolvercontextPathcontext);
            contextResources = getApplicationContextResource(resource);
            implementation.setClassLoader(new ContextClassLoader(resolvercontext));
            implementation.setResource(contextResources);
            // The URI is used to uniquely identify the Implementation
            implementation.setURI(resource.toString());
            List<SpringBeanElementappCxtBeans = new ArrayList<SpringBeanElement>();
            List<SpringSCAServiceElementappCxtServices = new ArrayList<SpringSCAServiceElement>();
            List<SpringSCAReferenceElementappCxtReferences = new ArrayList<SpringSCAReferenceElement>();
            List<SpringSCAPropertyElementappCxtProperties = new ArrayList<SpringSCAPropertyElement>();
            if ( != null) {
                .load(contextResources,
                                                   appCxtServices,
                                                   appCxtReferences,
                                                   appCxtProperties,
                                                   appCxtBeans,
                                                   context);
                populatePolicies(appCxtServicesappCxtReferences);
            }
            // Validate the beans from individual application context for uniqueness
            validateBeans(appCxtBeansappCxtServicesappCxtReferencesappCxtPropertiescontext.getMonitor());
            // Add all the validated beans to the generic list
            beans.addAll(appCxtBeans);
            services.addAll(appCxtServices);
            references.addAll(appCxtReferences);
            scaproperties.addAll(appCxtProperties);
        } catch (Throwable 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(implementationresolverbeansservicesreferencesscapropertiescontext);
        return;
    } // end method loadFromXML
    public void populatePolicies(List<SpringSCAServiceElementappCxtServices,
                                 List<SpringSCAReferenceElementappCxtReferences) {
        for (SpringSCAReferenceElement e : appCxtReferences) {
            for (QName qn : e.getIntentNames()) {
                Intent intent = .createIntent();
                intent.setName(qn);
                e.getRequiredIntents().add(intent);
            }
            for (QName qn : e.getPolicySetNames()) {
                PolicySet ps = .createPolicySet();
                ps.setName(qn);
                e.getPolicySets().add(ps);
            }
        }
        
        for (SpringSCAServiceElement e : appCxtServices) {
            for (QName qn : e.getIntentNames()) {
                Intent intent = .createIntent();
                intent.setName(qn);
                e.getRequiredIntents().add(intent);
            }
            for (QName qn : e.getPolicySetNames()) {
                PolicySet ps = .createPolicySet();
                ps.setName(qn);
                e.getPolicySets().add(ps);
            }
        }
    }
    private URL resolveLocation(ModelResolver resolverString contextPathProcessorContext context)
        URL resource = null;
        URI uri = URI.create(contextPath);
        if (!uri.isAbsolute()) {
            Artifact parent = context.getArtifact();
            if (parent != null && parent.getURI() != null) {
                URI base = URI.create("/" + parent.getURI());
                uri = base.resolve(uri);
                // Remove the leading / to make artifact resolver happy
                if (uri.toString().startsWith("/")) {
                    uri = URI.create(uri.toString().substring(1));
                }
            }
            Artifact artifact = .createArtifact();
            artifact.setUnresolved(true);
            artifact.setURI(uri.toString());
            artifact = resolver.resolveModel(Artifact.classartifactcontext);
            if (!artifact.isUnresolved()) {
                resource = new URL(artifact.getLocation());
            } else {
                // The resource can be out of scope of the contribution root
                if (parent != null && parent.getLocation() != null) {
                    resource = new URL(new URL(parent.getLocation()), contextPath);
                    return resource;
                }
                throw new ContributionReadException("Location cannot be resloved: " + contextPath);
            }
        } else {
            resource = new URL(contextPath);
        }
        return resource;
    }

    
Generates the Spring implementation component type from the configuration contained in the lists of beans, services, references and scaproperties derived from the application context
    private void generateComponentType(SpringImplementation implementation,
                                       ModelResolver resolver,
                                       List<SpringBeanElementbeans,
                                       List<SpringSCAServiceElementservices,
                                       List<SpringSCAReferenceElementreferences,
                                       List<SpringSCAPropertyElementscaproperties,
                                       ProcessorContext contextthrows ContributionReadException {
        /*
         * 1. Each sca:service becomes a service in the component type
         * 2. Each sca:reference becomes a reference in the component type
         * 3. Each sca:property becomes a property in the component type
         * 4. IF there are no explicit service elements, each bean becomes a service
         * 5. 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
         * 6. Each bean property which is not a reference and which is not pointing
         *    at another bean in the application context becomes a property in the component type
         */
        JavaImplementation javaImplementation = null;
        ComponentType componentType = implementation.getComponentType();
        try {
            // Deal with the services first....
            Iterator<SpringSCAServiceElementits = services.iterator();
            while (its.hasNext()) {
                SpringSCAServiceElement serviceElement = its.next();
                Class<?> interfaze = resolveClass(resolverserviceElement.getType(), context);
                Service theService = createService(interfazeserviceElement.getName());
                // Spring allows duplication of bean definitions in multiple context scenario,
                // in such cases, the latest bean definition overrides the older ones, hence 
                // we will remove any older definition and use the latest.
                Service duplicate = null;
                for (Service service : componentType.getServices()) {
                    if (service.getName().equals(theService.getName()))
                        duplicate = service;
                }
                if (duplicate != null)
                    componentType.getServices().remove(duplicate);
                componentType.getServices().add(theService);
                // Add this service to the Service / Bean map
                String beanName = serviceElement.getTarget();
                boolean found = false;
                for (SpringBeanElement beanElement : beans) {
                    if (beanName.equals(beanElement.getId())) {
                        if (isValidBeanForService(beanElement)) {
                            // add the required intents and policySets for the service
                            theService.getRequiredIntents().addAll(serviceElement.getRequiredIntents());
                            theService.getPolicySets().addAll(serviceElement.getPolicySets());
                            implementation.setBeanForService(theServicebeanElement);
                            found = true;
                            break;
                        }
                    }
                } // end for
                
                if (!found) {
                    // REVIEW: Adding a SpringBeanElement "proxy" so that the bean id can be used at runtime to look
                    // up the bean instance from the parent context
                    implementation.setBeanForService(theService,
                                                     new SpringBeanElement(serviceElement.getTarget(), null));
                }
            } // end while
            // Next handle the references
            Iterator<SpringSCAReferenceElementitr = references.iterator();
            while (itr.hasNext()) {
                SpringSCAReferenceElement referenceElement = itr.next();
                Class<?> interfaze = resolveClass(resolverreferenceElement.getType(), context);
                Reference theReference = createReference(interfazereferenceElement.getName());
                // Override the older bean definition with the latest ones
                // for the duplicate definitions found.
                Reference duplicate = null;
                for (Reference reference : componentType.getReferences()) {
                    if (reference.getName().equals(theReference.getName()))
                        duplicate = reference;
                }
                if (duplicate != null)
                    componentType.getReferences().remove(duplicate);
                // add the required intents and policySets for this reference
                theReference.getRequiredIntents().addAll(referenceElement.getRequiredIntents());
                theReference.getPolicySets().addAll(referenceElement.getPolicySets());
                componentType.getReferences().add(theReference);
            } // end while
            // Next handle the properties
            Iterator<SpringSCAPropertyElementitsp = scaproperties.iterator();
            while (itsp.hasNext()) {
                SpringSCAPropertyElement scaproperty = itsp.next();
                // Create a component type property if the SCA property element has a name
                // and a type declared...
                if (scaproperty.getType() != null && scaproperty.getName() != null) {
                    Property theProperty = .createProperty();
                    theProperty.setName(scaproperty.getName());
                    // Get the Java class and then an XSD element type for the property
                    Class<?> propType = Class.forName(scaproperty.getType());
                    theProperty.setXSDType(JavaXMLMapper.getXMLType(propType));
                    // Override the older bean definition with the latest ones
                    // for the duplicate definitions found.
                    Property duplicate = null;
                    for (Property property : componentType.getProperties()) {
                        if (property.getName().equals(theProperty.getName()))
                            duplicate = property;
                    }
                    if (duplicate != null)
                        componentType.getProperties().remove(duplicate);
                    componentType.getProperties().add(theProperty);
                    // Remember the Java Class (ie the type) for this property
                    implementation.setPropertyClass(theProperty.getName(), propType);
                } // end if
            } // end while
            // Finally deal with the beans
            Iterator<SpringBeanElementitb;
            // 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();
                    // If its not a valid bean for service, ignore it
                    if (!isValidBeanForService(beanElement)) {
                        continue;
                    }
                    try {
                        // Load the Spring bean class
                        Class<?> beanClass = resolveClass(resolverbeanElement.getClassName(), context);
                        // Introspect the bean
                         = new SpringBeanIntrospector(beanElement.getCustructorArgs());
                        ComponentType beanComponentType = .createComponentType();
                        javaImplementation = .introspectBean(beanClassbeanComponentType);
                        // Set the service name as bean name
                        for (Service componentService : beanComponentType.getServices()) {
                            componentService.setName(beanElement.getId());
                        }
                        // Get the service interface defined by this Spring Bean and add to
                        // the component type of the Spring Assembly
                        List<ServicebeanServices = beanComponentType.getServices();
                        componentType.getServices().addAll(beanServices);
                        // Add these services to the Service / Bean map
                        for (Service beanService : beanServices) {
                            implementation.setBeanForService(beanServicebeanElement);
                        }
                    } catch (Throwable e) {
                        // [rfeng] FIXME: Some Spring beans have constructors that take pararemters injected by Spring and
                        // Tuscany is not happy with that during the introspection
                        .log(.e.getMessage(), e);
                    }
                } // end while
            } // end if
            itb = beans.iterator();
            while (itb.hasNext()) {
                SpringBeanElement beanElement = itb.next();
                // If its not a valid bean for service, ignore it
                if (!isValidBeanForService(beanElement)) {
                    continue;
                }
                // Ignore if the bean has no properties and constructor arguments
                if (beanElement.getProperties().isEmpty() && beanElement.getCustructorArgs().isEmpty())
                    continue;
                ComponentType beanComponentType = .createComponentType();
                try {
                    Class<?> beanClass = resolveClass(resolverbeanElement.getClassName(), context);
                    // Introspect the bean
                     = new SpringBeanIntrospector(beanElement.getCustructorArgs());
                    javaImplementation = .introspectBean(beanClassbeanComponentType);
                } catch (Exception e) {
                    // [rfeng] FIXME: Some Spring beans have constructors that take pararemters injected by Spring and
                    // Tuscany is not happy with that during the introspection
                    .log(.e.getMessage(), e);
                    continue;
                }
                Map<StringJavaElementImplpropertyMap = javaImplementation.getPropertyMembers();
                JavaConstructorImpl constructor = javaImplementation.getConstructor();
                // Get the references by this Spring Bean and add the unresolved ones to
                // the component type of the Spring Assembly
                List<ReferencebeanReferences = beanComponentType.getReferences();
                List<PropertybeanProperties = beanComponentType.getProperties();
                Set<StringexcludedNames = new HashSet<String>();
                Iterator<SpringPropertyElementitp = beanElement.getProperties().iterator();
                while (itp.hasNext()) {
                    SpringPropertyElement propertyElement = itp.next();
                    // Exclude the reference that is also known as a spring property
                    excludedNames.add(propertyElement.getName());
                    for (String propertyRef : propertyElement.getRefs()) {
                        if (propertyRefUnresolved(propertyRefbeansreferencesscaproperties)) {
                            // This means an unresolved reference from the spring bean...
                            for (Reference reference : beanReferences) {
                                if (propertyElement.getName().equals(reference.getName())) {
                                    // The name of the reference in this case is the string in
                                    // the @ref attribute of the Spring property element, NOT the
                                    // name of the field in the Spring bean....
                                    reference.setName(propertyRef);
                                    componentType.getReferences().add(reference);
                                    break;
                                } // end if
                            } // end for
                            // Store the unresolved references as unresolvedBeanRef in the Spring Implementation type
                            for (Property scaproperty : beanProperties) {
                                if (propertyElement.getName().equals(scaproperty.getName())) {
                                    // The name of the reference in this case is the string in
                                    // the @ref attribute of the Spring property element, NOT the
                                    // name of the field in the Spring bean....
                                    Class<?> interfaze =
                                        resolveClass(resolver,
                                                     (propertyMap.get(propertyElement.getName()).getType()).getName(),
                                                     context);
                                    Reference theReference = createReference(interfazepropertyRef);
                                    implementation.setUnresolvedBeanRef(propertyReftheReference);
                                    break;
                                } // end if
                            } // end for
                        } // end if 
                    } // end for
                } // end while
                Iterator<SpringConstructorArgElementitcr = beanElement.getCustructorArgs().iterator();
                while (itcr.hasNext()) {
                    SpringConstructorArgElement conArgElement = itcr.next();
                    for (String constructorArgRef : conArgElement.getRefs()) {
                        if (propertyRefUnresolved(constructorArgRefbeansreferencesscaproperties)) {
                            for (JavaParameterImpl parameter : constructor.getParameters()) {
                                String paramType = parameter.getType().getName();
                                Class<?> interfaze = resolveClass(resolverparamTypecontext);
                                // Create a component type reference/property if the constructor-arg element has a
                                // type attribute OR index attribute declared...
                                if ((conArgElement.getType() != null && paramType.equals(conArgElement.getType())) || (conArgElement
                                    .getIndex() != -1 && (conArgElement.getIndex() == parameter.getIndex()))) {
                                    // [rfeng] Commenting out the following code as the constructor parameter based SCA
                                    // references are added already
                                    /*
                                    if (parameter.getClassifer() == org.oasisopen.sca.annotation.Reference.class) {
                                        Reference theReference = createReference(interfaze, constructorArgRef);
                                        componentType.getReferences().add(theReference);
                                    }
                                    */
                                    if (parameter.getClassifer() == org.oasisopen.sca.annotation.Property.class) {
                                        // Store the unresolved references as unresolvedBeanRef in the Spring Implementation type
                                        // we might need to verify with the component definition later.
                                        Reference theReference = createReference(interfazeconstructorArgRef);
                                        implementation.setUnresolvedBeanRef(constructorArgReftheReference);
                                    }
                                }
                            } // end for
                        } // end if
                    } // end for
                } // end while
                // [rfeng] Add the remaining introspected references (w/ @Reference but without Spring property ref)
                for (Reference ref : beanReferences) {
                    if (!excludedNames.contains(ref.getName()) && componentType.getReference(ref.getName()) == null) {
                        // Only add the ones that not listed by sca:reference
                        componentType.getReferences().add(ref);
                    }
                }
            } // end while
        } catch (ClassNotFoundException e) {
            // Means that either an interface class, property class or a bean was not found
            throw new ContributionReadException(e);
        } catch (InvalidInterfaceException e) {
            throw new ContributionReadException(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 or by an SCA property
     * 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<SpringBeanElementbeans,
                                          List<SpringSCAReferenceElementreferences,
                                          List<SpringSCAPropertyElementscaproperties) {
        boolean unresolved = true;
        if (ref != null) {
            // Scan over the beans looking for a match
            Iterator<SpringBeanElementitb = 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 SCA reference elements looking for a match
            if (unresolved) {
                Iterator<SpringSCAReferenceElementitr = references.iterator();
                while (itr.hasNext()) {
                    SpringSCAReferenceElement referenceElement = itr.next();
                    if (ref.equals(referenceElement.getName())) {
                        unresolved = false;
                        break;
                    } // end if
                } // end while
            } // end if
              // Scan over the SCA property elements looking for a match
            if (unresolved) {
                Iterator<SpringSCAPropertyElementitsp = scaproperties.iterator();
                while (itsp.hasNext()) {
                    SpringSCAPropertyElement propertyElement = itsp.next();
                    if (ref.equals(propertyElement.getName())) {
                        unresolved = false;
                        break;
                    } // end if
                } // end while
            } // end if
        } else {
            // In the case where ref = null, the property is not going to be a reference of any
            // kind and can be ignored
            unresolved = false;
        } // end if
        return unresolved;
    } // end method propertyRefUnresolved

    
Validates whether the <sca:service>, <sca:reference> and <sca:property> elements has unique names within the application context.
    private void validateBeans(List<SpringBeanElementbeans,
                               List<SpringSCAServiceElementservices,
                               List<SpringSCAReferenceElementreferences,
                               List<SpringSCAPropertyElementscaproperties,
                               Monitor monitorthrows ContributionReadException {
        // The @target attribute of a <service/> subelement of a <beans/> element 
        // MUST have the value of the @name attribute of one of the <bean/> 
        // subelements of the <beans/> element.    	
        Iterator<SpringSCAServiceElementits = services.iterator();
        while (its.hasNext()) {
            SpringSCAServiceElement serviceElement = its.next();
            boolean targetBeanExists = false;
            Iterator<SpringBeanElementitb = beans.iterator();
            while (itb.hasNext()) {
                SpringBeanElement beanElement = itb.next();
                if (serviceElement.getTarget().equals(beanElement.getId()))
                    targetBeanExists = true;
            }
            if (!targetBeanExists) {
                // REVIEW: [rfeng] The target bean can exist in the parent Spring application context which we don't know
                // until runtime
                warning(monitor"TargetBeanDoesNotExist"beans);
            }
        } // end while
        // The value of the @name attribute of an <sca:reference/> subelement of a <beans/> 
        // element MUST be unique amongst the @name attributes of the <sca:property/> 
        // subelements and the <bean/> subelements of the <beans/> element.
        // 									AND
        // The @default attribute of a <sca:reference/> subelement of a <beans/>  
        // element MUST have the value of the @name attribute of one of the <bean/> 
        // subelements of the <beans/> element.
        Iterator<SpringSCAReferenceElementitr = references.iterator();
        while (itr.hasNext()) {
            SpringSCAReferenceElement referenceElement = itr.next();
            boolean defaultBeanExists = true;
            boolean isUniqueReferenceName = true;
            Iterator<SpringBeanElementitb = beans.iterator();
            while (itb.hasNext()) {
                SpringBeanElement beanElement = itb.next();
                if (referenceElement.getDefaultBean() != null)
                    if (referenceElement.getDefaultBean().equals(beanElement.getId()))
                        defaultBeanExists = false;
                if (referenceElement.getName().equals(beanElement.getId()))
                    isUniqueReferenceName = false;
            }
            Iterator<SpringSCAPropertyElementitp = scaproperties.iterator();
            while (itp.hasNext()) {
                SpringSCAPropertyElement propertyElement = itp.next();
                if (referenceElement.getName().equals(propertyElement.getName()))
                    isUniqueReferenceName = false;
            }
            if (!defaultBeanExists)
                error(monitor"DefaultBeanDoesNotExist"beans);
            if (!isUniqueReferenceName)
                error(monitor"ScaReferenceNameNotUnique"beans);
        } // end while
        // The value of the @name attribute of an <sca:property/> subelement of a <beans/> 
        // element MUST be unique amongst the @name attributes of the <sca:reference/> 
        // subelements and the <bean/> subelements of the <beans/> element.    	
        Iterator<SpringSCAPropertyElementitp = scaproperties.iterator();
        while (itp.hasNext()) {
            SpringSCAPropertyElement propertyElement = itp.next();
            boolean isUniquePropertyName = true;
            Iterator<SpringBeanElementitb = beans.iterator();
            while (itb.hasNext()) {
                SpringBeanElement beanElement = itb.next();
                if (propertyElement.getName().equals(beanElement.getId()))
                    isUniquePropertyName = false;
            }
            Iterator<SpringSCAReferenceElementitrp = references.iterator();
            while (itrp.hasNext()) {
                SpringSCAReferenceElement referenceElement = itrp.next();
                if (propertyElement.getName().equals(referenceElement.getName()))
                    isUniquePropertyName = false;
            }
            if (!isUniquePropertyName)
                error(monitor"ScaPropertyNameNotUnique"beans);
        } // end while
    }

    
Validates whether a bean definition is valid for exposing as service.
    private boolean isValidBeanForService(SpringBeanElement beanElement) {
        if (beanElement.isInnerBean())
            return false;
        if (beanElement.hasParentAttribute())
            return false;
        if (beanElement.hasFactoryMethodAttribute())
            return false;
        if (beanElement.hasFactoryBeanAttribute())
            return false;
        if (beanElement.getClassName() == null)
            return false;
        if (beanElement.getClassName().startsWith("org.springframework"))
            return false;
        // return true otherwise	
        return true;
    }

    
Gets hold of the application-context.xml file as a Spring resource

Parameters:
locationAttr - the location attribute from the <implementation.spring../> element
cl - the ClassLoader for the Spring implementation
        File manifestFile = null;
        File appXmlFile;
        File appXmlFolder;
        File locationFile = null;
        List<URLappCtxResources = new ArrayList<URL>();
        if (url != null) {
            String path = url.getPath();
            locationFile = new File(path);
        } else {
            throw new ContributionReadException(
                                                "SpringXMLComponentTypeLoader getApplicationContextResource: " + "unable to find resource file "
                                                    + url);
        }
        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) {
                        String[] cxtPaths = appCtxPath.split(";");
                        for (String path : cxtPaths) {
                            appXmlFile = new File(locationFilepath.trim());
                            if (appXmlFile.exists()) {
                                appCtxResources.add(appXmlFile.toURI().toURL());
                            }
                        }
                        return appCtxResources;
                    }
                }
                // No MANIFEST.MF file OR no manifest-specified Spring context , then read all the 
                // xml files available in the META-INF/spring folder.
                appXmlFolder = new File(locationFile"META-INF" + . + "spring");
                if (appXmlFolder.exists()) {
                    File[] files = appXmlFolder.listFiles();
                    for (File appFile : files) {
                        if (appFile.getName().endsWith(".xml")) {
                            appCtxResources.add(appFile.toURI().toURL());
                        }
                    }
                    return appCtxResources;
                }
            } catch (IOException e) {
                throw new ContributionReadException("Error reading manifest " + manifestFile);
            }
        } else {
            if (locationFile.isFile() && locationFile.getName().endsWith(".jar")) {
                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) {
                            String[] cxtPaths = appCtxPath.split(";");
                            for (String path : cxtPaths) {
                                je = jf.getJarEntry(path.trim());
                                if (je != null)
                                    appCtxResources.add(new URL("jar:" + locationFile.toURI().toURL()
                                        + "!/"
                                        + appCtxPath));
                            }
                            return appCtxResources;
                        }
                    }
                    // No MANIFEST.MF file OR no manifest-specified Spring context , then read all the 
                    // .xml files available in the META-INF/spring folder.
                    Enumeration<JarEntryentries = jf.entries();
                    while (entries.hasMoreElements()) {
                        je = entries.nextElement();
                        if (je.getName().startsWith("META-INF/spring/") && je.getName().endsWith(".xml")) {
                            appCtxResources.add(new URL("jar:" + locationFile.toURI().toURL() + "!/" + je.getName()));
                        }
                    }
                    return appCtxResources;
                } catch (IOException e) {
                    // TODO: create a more appropriate exception type
                    throw new ContributionReadException(
                                                        "SpringXMLComponentTypeLoader getApplicationContextResource: " + " IO exception reading context file.",
                                                        e);
                }
            } else {
                if (locationFile.getName().endsWith(".xml")) {
                    appCtxResources.add(url);
                    return appCtxResources;
                } else {
                    // Deal with the directory inside a jar file, in case the contribution itself is a JAR file.
                    try {
                        if (locationFile.getPath().indexOf(".jar") > 0) {
                            String jarPath = url.getPath().substring(5, url.getPath().indexOf("!"));
                            JarFile jf = new JarFile(jarPath);
                            JarEntry je =
                                jf.getJarEntry(url.getPath().substring(url.getPath().indexOf("!/") + 2) + "/"
                                    + "META-INF"
                                    + "/"
                                    + "MANIFEST.MF");
                            if (je != null) {
                                Manifest mf = new Manifest(jf.getInputStream(je));
                                Attributes mainAttrs = mf.getMainAttributes();
                                String appCtxPath = mainAttrs.getValue("Spring-Context");
                                if (appCtxPath != null) {
                                    String[] cxtPaths = appCtxPath.split(";");
                                    for (String path : cxtPaths) {
                                        je =
                                            jf.getJarEntry(url.getPath().substring(url.getPath().indexOf("!/") + 2) + "/"
                                                + path.trim());
                                        if (je != null) {
                                            appCtxResources.add(new URL("jar:" + url.getPath() + "/" + path.trim()));
                                        }
                                    }
                                    return appCtxResources;
                                }
                            }
                            // No MANIFEST.MF file OR no manifest-specified Spring context , then read all the 
                            // .xml files available in the META-INF/spring folder.
                            Enumeration<JarEntryentries = jf.entries();
                            while (entries.hasMoreElements()) {
                                je = entries.nextElement();
                                if (je.getName().startsWith("META-INF/spring/") && je.getName().endsWith(".xml")) {
                                    appCtxResources.add(new URL("jar:" + url.getPath() + "/" + je.getName()));
                                }
                            }
                            return appCtxResources;
                        }
                    } catch (IOException e) {
                        throw new ContributionReadException("Error reading manifest " + manifestFile);
                    }
                }
            }
        }
        throw new ContributionReadException(
                                            "SpringXMLComponentTypeLoader getApplicationContextResource: " + "unable to read resource file "
                                                + url);
    } // end method getApplicationContextResource

    
Creates a Service for the component type based on its name and Java interface
    public Service createService(Class<?> interfazeString namethrows InvalidInterfaceException {
        Service service = .createService();
        JavaInterfaceContract interfaceContract = .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 = .createJavaInterface(interfaze);
        service.getInterfaceContract().setInterface(callInterface);
        if (callInterface.getCallbackClass() != null) {
            JavaInterface callbackInterface = .createJavaInterface(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<?> interfazeString name)
        throws InvalidInterfaceException {
        JavaInterfaceContract interfaceContract = .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(.);
        // Set the call interface and, if present, the callback interface
        JavaInterface callInterface = .createJavaInterface(interfaze);
        reference.getInterfaceContract().setInterface(callInterface);
        if (callInterface.getCallbackClass() != null) {
            JavaInterface callbackInterface = .createJavaInterface(callInterface.getCallbackClass());
            reference.getInterfaceContract().setCallbackInterface(callbackInterface);
        }
        return reference;
    }
    private class ContextClassLoader extends ClassLoader {
        public ContextClassLoader(ModelResolver resolverProcessorContext context) {
            super();
            this. = resolver;
            this. = context;
        }
        private ModelResolver resolver;
        private ProcessorContext context;
        @Override
        protected Class<?> findClass(String namethrows ClassNotFoundException {
            return SpringXMLComponentTypeLoader.this.resolveClass(name);
        }
        @Override
        protected URL findResource(String name) {
            try {
                return resolveLocation(name);
            } catch (Exception e) {
                return null;
            }
        }
        @Override
        protected Enumeration<URLfindResources(String namethrows IOException {
            URL url = findResource(name);
            if (url != null) {
                return Collections.enumeration(Arrays.asList(url));
            } else {
                Collection<