modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/HeuristicPojoProcessor.java [299:613]: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Annotation[][] annotations = constructor.getParameterAnnotations(); if (!explict) { // the constructor wasn't defined by an annotation, so check to see // if any of the params have an annotation // which we can impute as explicitly defining the constructor, e.g. // @Property, @Reference, or @Autowire explict = injectionAnnotationsPresent(annotations); } if (explict) { for (int i = 0; i < parameters.length; i++) { if (isAnnotated(parameters[i])) { continue; } else if (!findReferenceOrProperty(parameters[i], props, refs)) { throw new AmbiguousConstructorException(parameters[i].toString()); } } } else { if (!areUnique(parameters)) { throw new AmbiguousConstructorException("Cannot resolve non-unique parameter types, use @Constructor"); } if (!calcPropRefUniqueness(props.values(), refs.values())) { throw new AmbiguousConstructorException("Cannot resolve non-unique parameter types, use @Constructor"); } if (!(props.isEmpty() && refs.isEmpty())) { calcParamNames(parameters, props, refs); } else { heuristicParamNames(type, parameters); } } } private void calcParamNames(JavaParameterImpl[] parameters, Map props, Map refs) throws AmbiguousConstructorException { // the constructor param types must unambiguously match defined // reference or property types for (JavaParameterImpl param : parameters) { if (!findReferenceOrProperty(param, props, refs)) { throw new AmbiguousConstructorException(param.getName()); } } } private void heuristicParamNames(JavaImplementation type, JavaParameterImpl[] parameters) throws IntrospectionException { // heuristically determine refs and props from the parameter types for (JavaParameterImpl p : parameters) { String name = p.getType().getSimpleName().toLowerCase(); if (isReferenceType(p.getType(), p.getGenericType())) { type.getReferences().add(createReference(name, p.getType())); p.setClassifer(Reference.class); type.getReferenceMembers().put(name, p); } else { type.getProperties().add(createProperty(name, p.getType())); p.setClassifer(Property.class); type.getPropertyMembers().put(name, p); } p.setName(name); } } private static boolean areUnique(Class[] collection) { Set set = new HashSet(Arrays.asList(collection)); return set.size() == collection.length; } /** * Returns true if the union of the given collections of properties and * references have unique Java types */ private boolean calcPropRefUniqueness(Collection props, Collection refs) { Class[] classes = new Class[props.size() + refs.size()]; int i = 0; for (JavaElementImpl property : props) { classes[i] = property.getType(); i++; } for (JavaElementImpl reference : refs) { classes[i] = reference.getType(); i++; } return areUnique(classes); } /** * Unambiguously finds the reference or property associated with the given * type * * @return the name of the reference or property if found, null if not * @throws AmbiguousConstructorException if the constructor parameter cannot * be resolved to a property or reference */ private boolean findReferenceOrProperty(JavaParameterImpl parameter, Map props, Map refs) throws AmbiguousConstructorException { boolean found = false; if (!"".equals(parameter.getName())) { // Match by name JavaElementImpl prop = props.get(parameter.getName()); if (prop != null && prop.getType() == parameter.getType()) { parameter.setClassifer(Property.class); return true; } JavaElementImpl ref = refs.get(parameter.getName()); if (ref != null && ref.getType() == parameter.getType()) { parameter.setClassifer(Reference.class); return true; } } for (JavaElementImpl property : props.values()) { if (property.getType() == parameter.getType()) { if (found) { throw new AmbiguousConstructorException("Ambiguous property or reference for constructor type", (Member)parameter.getAnchor()); } parameter.setClassifer(Property.class); parameter.setName(property.getName()); found = true; // do not break since ambiguities must be checked, i.e. more // than one prop or ref of the same type } } for (JavaElementImpl reference : refs.values()) { if (reference.getType() == parameter.getType()) { if (found) { throw new AmbiguousConstructorException("Ambiguous property or reference for constructor type", (Member)parameter.getAnchor()); } parameter.setClassifer(Reference.class); parameter.setName(reference.getName()); found = true; // do not break since ambiguities must be checked, i.e. more // than one prop or ref of the same type } } return found; } /** * Returns true if a given type is reference according to the SCA * specification rules for determining reference types The following rules * are used to determine whether an unannotated field or setter method is a * property or reference: *
    *
  1. If its type is simple, then it is a property. *
  2. If its type is complex, then if the type is an interface marked by * * @Remotable, then it is a reference; otherwise, it is a property. *
  3. Otherwise, if the type associated with the member is an * array or a java.util.Collection, the basetype is the element * type of the array or the parameterized type of the * Collection; otherwise the basetype is the member type. If the * basetype is an interface with an * @Remotable or * @Service annotation then the member is defined as a reference. Otherwise, * it is defined as a property. *
*

* The name of the reference or of the property is derived from the * name found on the setter method or on the field. */ private boolean isReferenceType(Class cls, Type genericType) { Class baseType = JavaIntrospectionHelper.getBaseType(cls, genericType); return baseType.isInterface() && baseType.isAnnotationPresent(Remotable.class); } /** * Returns true if the given operation is defined in the collection of * service interfaces */ private boolean isInServiceInterface(Method operation, List services) { for (org.apache.tuscany.sca.assembly.Service service : services) { Interface interface1 = service.getInterfaceContract().getInterface(); if (interface1 instanceof JavaInterface) { Class clazz = ((JavaInterface)interface1).getJavaClass(); if (isMethodMatched(clazz, operation)) { return true; } } } return false; } /** * Test if the class declares a method which matches the signature of the * given method * * @param clazz * @param method * @return */ private boolean isMethodMatched(Class clazz, Method method) { if (method.getDeclaringClass() == clazz) { return true; } Method[] methods = clazz.getMethods(); for (Method m : methods) { if (JavaIntrospectionHelper.exactMethodMatch(method, m)) { return true; } } return false; } /** * Creates a mapped property. * * @param name the property name * @param paramType the property type */ private org.apache.tuscany.sca.assembly.Property createProperty(String name, Class paramType) { org.apache.tuscany.sca.assembly.Property property = assemblyFactory.createProperty(); property.setName(name); property.setXSDType(JavaXMLMapper.getXMLType(paramType)); return property; } private boolean isAnnotated(JavaParameterImpl parameter) { for (Annotation annotation : parameter.getAnnotations()) { Class annotType = annotation.annotationType(); if (annotType.equals(Property.class) || annotType.equals(Reference.class) || annotType.equals(Resource.class)) { return true; } } return false; } public boolean areUnique(JavaParameterImpl[] parameters) { Set set = new HashSet(parameters.length); for (JavaParameterImpl p : parameters) { if (!set.add(p.getType())) { return false; } } return true; } public org.apache.tuscany.sca.assembly.Reference createReference(String name, Class paramType) throws IntrospectionException { org.apache.tuscany.sca.assembly.Reference reference = assemblyFactory.createReference(); reference.setName(name); JavaInterfaceContract interfaceContract = javaFactory.createJavaInterfaceContract(); reference.setInterfaceContract(interfaceContract); try { JavaInterface callInterface = javaFactory.createJavaInterface(paramType); reference.getInterfaceContract().setInterface(callInterface); if (callInterface.getCallbackClass() != null) { JavaInterface callbackInterface = javaFactory.createJavaInterface(callInterface.getCallbackClass()); reference.getInterfaceContract().setCallbackInterface(callbackInterface); } reference.setMultiplicity(Multiplicity.ZERO_ONE); } catch (InvalidInterfaceException e1) { throw new IntrospectionException(e1); } // FIXME: This part seems to have already been taken care above!! try { processCallback(paramType, reference); } catch (InvalidServiceType e) { throw new IntrospectionException(e); } return reference; } public org.apache.tuscany.sca.assembly.Service createService(Class interfaze) throws InvalidInterfaceException { org.apache.tuscany.sca.assembly.Service service = assemblyFactory.createService(); service.setName(interfaze.getSimpleName()); JavaInterfaceContract interfaceContract = javaFactory.createJavaInterfaceContract(); service.setInterfaceContract(interfaceContract); JavaInterface callInterface = javaFactory.createJavaInterface(interfaze); service.getInterfaceContract().setInterface(callInterface); if (callInterface.getCallbackClass() != null) { JavaInterface callbackInterface = javaFactory.createJavaInterface(callInterface.getCallbackClass()); service.getInterfaceContract().setCallbackInterface(callbackInterface); } Interface javaInterface = service.getInterfaceContract().getInterface(); javaInterface.setRemotable(interfaze.getAnnotation(Remotable.class) != null); service.getInterfaceContract().setInterface(javaInterface); return service; } public void processCallback(Class interfaze, Contract contract) throws InvalidServiceType { Callback callback = interfaze.getAnnotation(Callback.class); if (callback != null && !Void.class.equals(callback.value())) { Class callbackClass = callback.value(); JavaInterface javaInterface; try { javaInterface = javaFactory.createJavaInterface(callbackClass); contract.getInterfaceContract().setCallbackInterface(javaInterface); } catch (InvalidInterfaceException e) { throw new InvalidServiceType("Invalid callback interface "+callbackClass, interfaze); } } else if (callback != null && Void.class.equals(callback.value())) { throw new InvalidServiceType("No callback interface specified on annotation", interfaze); } } public boolean injectionAnnotationsPresent(Annotation[][] annots) { for (Annotation[] annotations : annots) { for (Annotation annotation : annotations) { Class annotType = annotation.annotationType(); if (annotType.equals(Property.class) || annotType.equals(Reference.class) || annotType.equals(Resource.class)) { return true; } } } return false; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - modules/implementation-spring/src/main/java/org/apache/tuscany/sca/implementation/spring/introspect/SpringBeanPojoProcessor.java [340:654]: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Annotation[][] annotations = constructor.getParameterAnnotations(); if (!explict) { // the constructor wasn't defined by an annotation, so check to see // if any of the params have an annotation // which we can impute as explicitly defining the constructor, e.g. // @Property, @Reference, or @Autowire explict = injectionAnnotationsPresent(annotations); } if (explict) { for (int i = 0; i < parameters.length; i++) { if (isAnnotated(parameters[i])) { continue; } else if (!findReferenceOrProperty(parameters[i], props, refs)) { throw new AmbiguousConstructorException(parameters[i].toString()); } } } else { if (!areUnique(parameters)) { throw new AmbiguousConstructorException("Cannot resolve non-unique parameter types, use @Constructor"); } if (!calcPropRefUniqueness(props.values(), refs.values())) { throw new AmbiguousConstructorException("Cannot resolve non-unique parameter types, use @Constructor"); } if (!(props.isEmpty() && refs.isEmpty())) { calcParamNames(parameters, props, refs); } else { heuristicParamNames(type, parameters); } } } private void calcParamNames(JavaParameterImpl[] parameters, Map props, Map refs) throws AmbiguousConstructorException { // the constructor param types must unambiguously match defined // reference or property types for (JavaParameterImpl param : parameters) { if (!findReferenceOrProperty(param, props, refs)) { throw new AmbiguousConstructorException(param.getName()); } } } private void heuristicParamNames(JavaImplementation type, JavaParameterImpl[] parameters) throws IntrospectionException { // heuristically determine refs and props from the parameter types for (JavaParameterImpl p : parameters) { String name = p.getType().getSimpleName().toLowerCase(); if (isReferenceType(p.getType(), p.getGenericType())) { type.getReferences().add(createReference(name, p.getType())); p.setClassifer(Reference.class); type.getReferenceMembers().put(name, p); } else { type.getProperties().add(createProperty(name, p.getType())); p.setClassifer(Property.class); type.getPropertyMembers().put(name, p); } p.setName(name); } } private static boolean areUnique(Class[] collection) { Set set = new HashSet(Arrays.asList(collection)); return set.size() == collection.length; } /** * Returns true if the union of the given collections of properties and * references have unique Java types */ private boolean calcPropRefUniqueness(Collection props, Collection refs) { Class[] classes = new Class[props.size() + refs.size()]; int i = 0; for (JavaElementImpl property : props) { classes[i] = property.getType(); i++; } for (JavaElementImpl reference : refs) { classes[i] = reference.getType(); i++; } return areUnique(classes); } /** * Unambiguously finds the reference or property associated with the given * type * * @return the name of the reference or property if found, null if not * @throws AmbiguousConstructorException if the constructor parameter cannot * be resolved to a property or reference */ private boolean findReferenceOrProperty(JavaParameterImpl parameter, Map props, Map refs) throws AmbiguousConstructorException { boolean found = false; if (!"".equals(parameter.getName())) { // Match by name JavaElementImpl prop = props.get(parameter.getName()); if (prop != null && prop.getType() == parameter.getType()) { parameter.setClassifer(Property.class); return true; } JavaElementImpl ref = refs.get(parameter.getName()); if (ref != null && ref.getType() == parameter.getType()) { parameter.setClassifer(Reference.class); return true; } } for (JavaElementImpl property : props.values()) { if (property.getType() == parameter.getType()) { if (found) { throw new AmbiguousConstructorException("Ambiguous property or reference for constructor type", (Member)parameter.getAnchor()); } parameter.setClassifer(Property.class); parameter.setName(property.getName()); found = true; // do not break since ambiguities must be checked, i.e. more // than one prop or ref of the same type } } for (JavaElementImpl reference : refs.values()) { if (reference.getType() == parameter.getType()) { if (found) { throw new AmbiguousConstructorException("Ambiguous property or reference for constructor type", (Member)parameter.getAnchor()); } parameter.setClassifer(Reference.class); parameter.setName(reference.getName()); found = true; // do not break since ambiguities must be checked, i.e. more // than one prop or ref of the same type } } return found; } /** * Returns true if a given type is reference according to the SCA * specification rules for determining reference types The following rules * are used to determine whether an unannotated field or setter method is a * property or reference: *

    *
  1. If its type is simple, then it is a property. *
  2. If its type is complex, then if the type is an interface marked by * * @Remotable, then it is a reference; otherwise, it is a property. *
  3. Otherwise, if the type associated with the member is an * array or a java.util.Collection, the basetype is the element * type of the array or the parameterized type of the * Collection; otherwise the basetype is the member type. If the * basetype is an interface with an * @Remotable or * @Service annotation then the member is defined as a reference. Otherwise, * it is defined as a property. *
*

* The name of the reference or of the property is derived from the * name found on the setter method or on the field. */ private boolean isReferenceType(Class cls, Type genericType) { Class baseType = JavaIntrospectionHelper.getBaseType(cls, genericType); return baseType.isInterface() && baseType.isAnnotationPresent(Remotable.class); } /** * Returns true if the given operation is defined in the collection of * service interfaces */ private boolean isInServiceInterface(Method operation, List services) { for (org.apache.tuscany.sca.assembly.Service service : services) { Interface interface1 = service.getInterfaceContract().getInterface(); if (interface1 instanceof JavaInterface) { Class clazz = ((JavaInterface)interface1).getJavaClass(); if (isMethodMatched(clazz, operation)) { return true; } } } return false; } /** * Test if the class declares a method which matches the signature of the * given method * * @param clazz * @param method * @return */ private boolean isMethodMatched(Class clazz, Method method) { if (method.getDeclaringClass() == clazz) { return true; } Method[] methods = clazz.getMethods(); for (Method m : methods) { if (JavaIntrospectionHelper.exactMethodMatch(method, m)) { return true; } } return false; } /** * Creates a mapped property. * * @param name the property name * @param paramType the property type */ private org.apache.tuscany.sca.assembly.Property createProperty(String name, Class paramType) { org.apache.tuscany.sca.assembly.Property property = assemblyFactory.createProperty(); property.setName(name); property.setXSDType(JavaXMLMapper.getXMLType(paramType)); return property; } private boolean isAnnotated(JavaParameterImpl parameter) { for (Annotation annotation : parameter.getAnnotations()) { Class annotType = annotation.annotationType(); if (annotType.equals(Property.class) || annotType.equals(Reference.class) || annotType.equals(Resource.class)) { return true; } } return false; } public boolean areUnique(JavaParameterImpl[] parameters) { Set set = new HashSet(parameters.length); for (JavaParameterImpl p : parameters) { if (!set.add(p.getType())) { return false; } } return true; } public org.apache.tuscany.sca.assembly.Reference createReference(String name, Class paramType) throws IntrospectionException { org.apache.tuscany.sca.assembly.Reference reference = assemblyFactory.createReference(); reference.setName(name); JavaInterfaceContract interfaceContract = javaFactory.createJavaInterfaceContract(); reference.setInterfaceContract(interfaceContract); try { JavaInterface callInterface = javaFactory.createJavaInterface(paramType); reference.getInterfaceContract().setInterface(callInterface); if (callInterface.getCallbackClass() != null) { JavaInterface callbackInterface = javaFactory.createJavaInterface(callInterface.getCallbackClass()); reference.getInterfaceContract().setCallbackInterface(callbackInterface); } reference.setMultiplicity(Multiplicity.ZERO_ONE); } catch (InvalidInterfaceException e1) { throw new IntrospectionException(e1); } // FIXME: This part seems to have already been taken care above!! try { processCallback(paramType, reference); } catch (InvalidServiceType e) { throw new IntrospectionException(e); } return reference; } public org.apache.tuscany.sca.assembly.Service createService(Class interfaze) throws InvalidInterfaceException { org.apache.tuscany.sca.assembly.Service service = assemblyFactory.createService(); service.setName(interfaze.getSimpleName()); JavaInterfaceContract interfaceContract = javaFactory.createJavaInterfaceContract(); service.setInterfaceContract(interfaceContract); JavaInterface callInterface = javaFactory.createJavaInterface(interfaze); service.getInterfaceContract().setInterface(callInterface); if (callInterface.getCallbackClass() != null) { JavaInterface callbackInterface = javaFactory.createJavaInterface(callInterface.getCallbackClass()); service.getInterfaceContract().setCallbackInterface(callbackInterface); } Interface javaInterface = service.getInterfaceContract().getInterface(); javaInterface.setRemotable(interfaze.getAnnotation(Remotable.class) != null); service.getInterfaceContract().setInterface(javaInterface); return service; } public void processCallback(Class interfaze, Contract contract) throws InvalidServiceType { Callback callback = interfaze.getAnnotation(Callback.class); if (callback != null && !Void.class.equals(callback.value())) { Class callbackClass = callback.value(); JavaInterface javaInterface; try { javaInterface = javaFactory.createJavaInterface(callbackClass); contract.getInterfaceContract().setCallbackInterface(javaInterface); } catch (InvalidInterfaceException e) { throw new InvalidServiceType("Invalid callback interface "+callbackClass, interfaze); } } else if (callback != null && Void.class.equals(callback.value())) { throw new InvalidServiceType("No callback interface specified on annotation", interfaze); } } public boolean injectionAnnotationsPresent(Annotation[][] annots) { for (Annotation[] annotations : annots) { for (Annotation annotation : annotations) { Class annotType = annotation.annotationType(); if (annotType.equals(Property.class) || annotType.equals(Reference.class) || annotType.equals(Resource.class)) { return true; } } } return false; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -