Branch for 1.4

git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@722428 13f79535-47bb-0310-9956-ffa450edef68

62 files changed, 5622 insertions, 0 deletions

diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/BaseJavaImplementation.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/BaseJavaImplementation.java
new file mode 100644
index 0000000000..c8b7c072ac
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/BaseJavaImplementation.java
@@ -0,0 +1,59 @@
+/*
+ * 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.java;
+
+import org.apache.tuscany.sca.assembly.Extensible;
+import org.apache.tuscany.sca.assembly.Implementation;
+
+/**
+ * Represents a Java implementation.
+ * 
+ * @version $Rev$ $Date$
+ */
+public interface BaseJavaImplementation extends Implementation, Extensible {
+
+    /**
+     * Returns the name of the Java implementation class.
+     * 
+     * @return the name of the Java implementation class
+     */
+    String getName();
+
+    /**
+     * Sets the name of the Java implementation class.
+     * 
+     * @param className the name of the Java implementation class
+     */
+    void setName(String className);
+
+    /**
+     * Returns the Java implementation class.
+     * 
+     * @return the Java implementation class
+     */
+    Class<?> getJavaClass();
+
+    /**
+     * Sets the Java implementation class.
+     * 
+     * @param javaClass the Java implementation class
+     */
+    void setJavaClass(Class<?> javaClass);
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/DefaultJavaImplementationFactory.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/DefaultJavaImplementationFactory.java
new file mode 100644
index 0000000000..e44ebd7c91
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/DefaultJavaImplementationFactory.java
@@ -0,0 +1,33 @@
+/*
+ * 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.java;
+
+/**
+ * A factory for the Java model.
+ *
+ * @version $Rev$ $Date$
+ */
+import org.apache.tuscany.sca.implementation.java.impl.JavaImplementationFactoryImpl;
+
+public class DefaultJavaImplementationFactory extends JavaImplementationFactoryImpl implements JavaImplementationFactory {
+
+    public DefaultJavaImplementationFactory() {
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/IntrospectionException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/IntrospectionException.java
new file mode 100644
index 0000000000..2198a632c0
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/IntrospectionException.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.sca.implementation.java;
+
+import java.lang.reflect.Member;
+
+/**
+ * Denotes a problem processing annotations on a POJO implementation
+ * 
+ * @version $Rev$ $Date$
+ */
+public class IntrospectionException extends Exception {
+    private static final long serialVersionUID = -361025119035104470L;
+    private Member member;
+
+    public IntrospectionException() {
+    }
+
+    public IntrospectionException(String message) {
+        super(message);
+    }
+
+    public IntrospectionException(String message, Member member) {
+        super(message);
+        this.member = member;
+    }
+
+    public IntrospectionException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public IntrospectionException(Throwable cause) {
+        super(cause);
+    }
+
+    public Member getMember() {
+        return member;
+    }
+
+    public void setMember(Member member) {
+        this.member = member;
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/JavaImplementation.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/JavaImplementation.java
new file mode 100644
index 0000000000..2ad7edbd6f
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/JavaImplementation.java
@@ -0,0 +1,198 @@
+/*
+ * 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.java;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.tuscany.sca.implementation.java.impl.JavaConstructorImpl;
+import org.apache.tuscany.sca.implementation.java.impl.JavaElementImpl;
+import org.apache.tuscany.sca.implementation.java.impl.JavaResourceImpl;
+import org.apache.tuscany.sca.implementation.java.impl.JavaScopeImpl;
+import org.apache.tuscany.sca.policy.util.PolicyHandlerTuple;
+
+/**
+ * Represents a Java implementation.
+ *
+ * @version $Rev$ $Date$
+ */
+public interface JavaImplementation extends BaseJavaImplementation {
+
+    /**
+     * Returns the constructor used to instantiate implementation instances.
+     *
+     * @return the constructor used to instantiate implementation instances
+     */
+    JavaConstructorImpl<?> getConstructor();
+
+    /**
+     * Sets the constructor used to instantiate implementation instances
+     *
+     * @param definition the constructor used to instantiate implementation instances
+     */
+    void setConstructor(JavaConstructorImpl<?> definition);
+
+    /**
+     * Returns the component initializer method.
+     *
+     * @return the component initializer method
+     */
+    Method getInitMethod();
+
+    /**
+     * Sets the component initializer method.
+     *
+     * @param initMethod the component initializer method
+     */
+    void setInitMethod(Method initMethod);
+
+    /**
+     * Returns the component destructor method.
+     *
+     * @return the component destructor method
+     */
+    Method getDestroyMethod();
+
+    /**
+     * Sets the component destructor method.
+     *
+     * @param destroyMethod the component destructor method
+     */
+    void setDestroyMethod(Method destroyMethod);
+
+    /**
+     * Returns the resources injected into this implementation.
+     *
+     * @return
+     */
+    Map<String, JavaResourceImpl> getResources();
+
+    /**
+     * Returns the Java member used to inject a conversation ID.
+     *
+     * @return
+     */
+    List<Member> getConversationIDMembers();
+
+    /**
+     * Sets the Java member used to inject a conversation ID.
+     *
+     * @param conversationIDMember
+     */
+    void addConversationIDMember(Member conversationIDMember);
+
+    /**
+     * Returns true if AllowsPassReference is set.
+     *
+     * @return true if AllowsPassByReference is set
+     */
+    boolean isAllowsPassByReference();
+
+    /**
+     * @param allowsPassByReference the allowsPassByReference to set
+     */
+    void setAllowsPassByReference(boolean allowsPassByReference);
+
+    /**
+     * @return the allowsPassByReferenceMethods
+     */
+    List<Method> getAllowsPassByReferenceMethods();
+
+    /**
+     * @param method
+     * @return
+     */
+    boolean isAllowsPassByReference(Method method);
+
+    /**
+     * @return the constructors
+     */
+    Map<Constructor, JavaConstructorImpl> getConstructors();
+
+    /**
+     * @return the eagerInit
+     */
+    boolean isEagerInit();
+
+    /**
+     * @param eagerInit the eagerInit to set
+     */
+    void setEagerInit(boolean eagerInit);
+
+    /**
+     * @return the callbacks
+     */
+    Map<String, Collection<JavaElementImpl>> getCallbackMembers();
+
+    /**
+     * @return the properties
+     */
+    Map<String, JavaElementImpl> getPropertyMembers();
+
+    /**
+     * @return the references
+     */
+    Map<String, JavaElementImpl> getReferenceMembers();
+
+    /**
+     * @return the scope
+     */
+    JavaScopeImpl getJavaScope();
+
+    /**
+     * @param scope the scope to set
+     */
+    void setJavaScope(JavaScopeImpl scope);
+
+    /**
+     * @return the maxAge
+     */
+    long getMaxAge();
+
+    /**
+     * @param maxAge the maxAge to set
+     */
+    void setMaxAge(long maxAge);
+
+    /**
+     * @return the maxIdleTime
+     */
+    long getMaxIdleTime();
+
+    /**
+     * @param maxIdleTime the maxIdleTime to set
+     */
+    void setMaxIdleTime(long maxIdleTime);
+
+    /**
+     * @return the map of a policy handler class names
+     */
+    List<PolicyHandlerTuple> getPolicyHandlerClassNames();
+
+    /**
+     * @param policyHandlerClassNames Map of policyhandler class names
+     */
+    void setPolicyHandlerClassNames(List<PolicyHandlerTuple> policyHandlerClassNames);
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/JavaImplementationFactory.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/JavaImplementationFactory.java
new file mode 100644
index 0000000000..8228c80372
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/JavaImplementationFactory.java
@@ -0,0 +1,75 @@
+/*
+ * 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.java;
+
+import java.util.List;
+
+import org.apache.tuscany.sca.implementation.java.introspect.JavaClassVisitor;
+
+
+/**
+ * Factory for the Java model
+ * 
+ * @version $Rev$ $Date$
+ */
+public interface JavaImplementationFactory {
+
+    /**
+     * Creates a new Java implementation model.
+     * 
+     * @return
+     */
+    JavaImplementation createJavaImplementation();
+    
+    /**
+     * Creates a new Java implementation model from an implementation class.
+     * 
+     * @param implementationClass The implementation class to introspect.
+     * @return
+     */
+    JavaImplementation createJavaImplementation(Class<?> implementationClass) throws IntrospectionException;
+
+    /**
+     * Creates the contents of a Java implementation model from an implementation class.
+     * 
+     * @param implementationClass The implementation class to introspect.
+     * @return
+     */
+    void createJavaImplementation(JavaImplementation javaImplementation, Class<?> implementationClass) throws IntrospectionException;
+
+    /**
+     * Registers the given visitor.
+     * 
+     * @param visitor
+     */
+    void addClassVisitor(JavaClassVisitor visitor);
+
+    /**
+     * Deregisters the given visitor.
+     */
+    void removeClassVisitor(JavaClassVisitor visitor);
+    
+    /**
+     * Returns the list of visitors.
+     * 
+     * @return
+     */
+    List<JavaClassVisitor> getClassVisitors();
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/BaseJavaImplementationImpl.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/BaseJavaImplementationImpl.java
new file mode 100644
index 0000000000..97773879fa
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/BaseJavaImplementationImpl.java
@@ -0,0 +1,89 @@
+/*
+ * 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.java.impl;
+
+import org.apache.tuscany.sca.assembly.impl.ImplementationImpl;
+import org.apache.tuscany.sca.implementation.java.BaseJavaImplementation;
+
+/**
+ * Represents a Java implementation.
+ * 
+ * @version $Rev$ $Date$
+ */
+abstract class BaseJavaImplementationImpl extends ImplementationImpl implements BaseJavaImplementation {
+
+    private String className;
+    private Class<?> javaClass;
+    
+    protected BaseJavaImplementationImpl() {
+    }
+
+    public String getName() {
+        if (isUnresolved()) {
+            return className;
+        } else if (javaClass != null) {
+            return javaClass.getName();
+        } else {
+            return null;
+        }
+    }
+
+    public void setName(String className) {
+        if (!isUnresolved()) {
+            throw new IllegalStateException();
+        }
+        this.className = className;
+    }
+
+    public Class<?> getJavaClass() {
+        return javaClass;
+    }
+
+    public void setJavaClass(Class<?> javaClass) {
+        this.javaClass = javaClass;
+        if (this.className == null) {
+            this.className = javaClass.getName();
+        }
+    }
+
+    @Override
+    public String toString() {
+        return getName();
+    }
+
+    @Override
+    public int hashCode() {
+        return String.valueOf(getName()).hashCode();
+    }
+    
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        } else if (obj instanceof BaseJavaImplementation) {
+            if (getName() != null) {
+                return getName().equals(((BaseJavaImplementation)obj).getName());
+            } else {
+                return ((BaseJavaImplementation)obj).getName() == null;
+            }
+        } else {
+            return false;
+        }
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaClassIntrospectorImpl.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaClassIntrospectorImpl.java
new file mode 100644
index 0000000000..0bcec3c78f
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaClassIntrospectorImpl.java
@@ -0,0 +1,141 @@
+/*
+ * 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.java.impl;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.Set;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.apache.tuscany.sca.implementation.java.introspect.JavaClassVisitor;
+import org.apache.tuscany.sca.implementation.java.introspect.impl.JavaIntrospectionHelper;
+
+/**
+ * An extensible Java class introspector implementation.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class JavaClassIntrospectorImpl {
+    
+    private List<JavaClassVisitor> visitors;
+
+    public JavaClassIntrospectorImpl(List<JavaClassVisitor> visitors) {
+        this.visitors = visitors;
+    }
+
+    /**
+     * JSR-250 PFD recommends the following guidelines for how annotations
+     * interact with inheritance in order to keep the resulting complexity in
+     * control:
+     * <ol>
+     * <li>Class-level annotations only affect the class they annotate and
+     * their members, that is, its methods and fields. They never affect a
+     * member declared by a superclass, even if it is not hidden or overridden
+     * by the class in question.
+     * <li>In addition to affecting the annotated class, class-level
+     * annotations may act as a shorthand for member-level annotations. If a
+     * member carries a specific member-level annotation, any annotations of the
+     * same type implied by a class-level annotation are ignored. In other
+     * words, explicit member-level annotations have priority over member-level
+     * annotations implied by a class-level annotation.
+     * <li>The interfaces implemented by a class never contribute annotations
+     * to the class itself or any of its members.
+     * <li>Members inherited from a superclass and which are not hidden or
+     * overridden maintain the annotations they had in the class that declared
+     * them, including member-level annotations implied by class-level ones.
+     * <li>Member-level annotations on a hidden or overridden member are always
+     * ignored.
+     * </ol>
+     */
+    public void introspectClass(JavaImplementation type, Class<?> clazz)
+        throws IntrospectionException {
+        for (JavaClassVisitor extension : visitors) {
+            extension.visitClass(clazz, type);
+        }
+
+        for (Constructor<?> constructor : clazz.getConstructors()) {
+            for (JavaClassVisitor extension : visitors) {
+                extension.visitConstructor(constructor, type);
+                // Assuming the visitClass or visitConstructor will populate the
+                // type.getConstructors
+                JavaConstructorImpl<?> definition = type.getConstructors().get(constructor);
+                if (definition != null) {
+                    for (JavaParameterImpl p : definition.getParameters()) {
+                        extension.visitConstructorParameter(p, type);
+                    }
+                }
+            }
+        }
+
+        Set<Field> fields = JavaIntrospectionHelper.getAllPublicAndProtectedFields(clazz, true);
+        for (Field field : fields) {
+            for (JavaClassVisitor extension : visitors) {
+                extension.visitField(field, type);
+            }
+        }
+
+        // Check if any private fields have illegal annotations that should be raised as errors
+        Set<Field> privateFields = JavaIntrospectionHelper.getPrivateFields(clazz);
+        for (Field field : privateFields) {
+            for (JavaClassVisitor processor : visitors) {
+                processor.visitField(field, type);
+            }
+        }
+        
+        Set<Method> methods = JavaIntrospectionHelper.getAllUniquePublicProtectedMethods(clazz, true);
+        for (Method method : methods) {
+            for (JavaClassVisitor processor : visitors) {
+                processor.visitMethod(method, type);
+            }
+        }
+
+        // Check if any private methods have illegal annotations that should be raised as errors
+        Set<Method> privateMethods = JavaIntrospectionHelper.getPrivateMethods(clazz);
+        for (Method method : privateMethods) {
+            for (JavaClassVisitor processor : visitors) {
+                processor.visitMethod(method, type);
+            }
+        }
+
+        Class superClass = clazz.getSuperclass();
+        if (superClass != null) {
+            visitSuperClass(superClass, type);
+        }
+
+        for (JavaClassVisitor extension : visitors) {
+            extension.visitEnd(clazz, type);
+        }
+    }
+
+    private void visitSuperClass(Class<?> clazz, JavaImplementation type) throws IntrospectionException {
+        if (!Object.class.equals(clazz)) {
+            for (JavaClassVisitor extension : visitors) {
+                extension.visitSuperClass(clazz, type);
+            }
+            clazz = clazz.getSuperclass();
+            if (clazz != null) {
+                visitSuperClass(clazz, type);
+            }
+        }
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaConstructorImpl.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaConstructorImpl.java
new file mode 100644
index 0000000000..c0b04b4b4e
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaConstructorImpl.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.sca.implementation.java.impl;
+
+import java.lang.reflect.Constructor;
+
+/**
+ * Hold injection information for the constructor used to instantiate a
+ * component implementation instance
+ * 
+ * @version $Rev$ $Date$
+ */
+public class JavaConstructorImpl<T> {
+
+    private Constructor<T> constructor;
+    private JavaParameterImpl[] parameters;
+
+    public JavaConstructorImpl(Constructor<T> constructor) {
+        this.constructor = constructor;
+        int size = constructor.getParameterTypes().length;
+        parameters = new JavaParameterImpl[size];
+        for (int i = 0; i < size; i++) {
+            parameters[i] = new JavaParameterImpl(constructor, i);
+        }
+    }
+
+    public Constructor<T> getConstructor() {
+        return constructor;
+    }
+
+    /**
+     * @return the parameters
+     */
+    public JavaParameterImpl[] getParameters() {
+        return parameters;
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaElementImpl.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaElementImpl.java
new file mode 100644
index 0000000000..2365298f71
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaElementImpl.java
@@ -0,0 +1,224 @@
+/*
+ * 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.java.impl;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+
+/**
+ * This class represents a java element such as a Package, Class, Constructor,
+ * Field, Method or Parameter.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class JavaElementImpl {
+    private AnnotatedElement anchor;
+    private ElementType elementType;
+    private Class<?> type;
+    private Type genericType;
+    private int index = -1;
+    private String name;
+    private Class<? extends Annotation> classifer;
+
+    public JavaElementImpl(Package pkg) {
+        this.anchor = pkg;
+        this.elementType = ElementType.PACKAGE;
+        this.name = pkg.getName();
+    }
+
+    public JavaElementImpl(Class<?> cls) {
+        this.anchor = cls;
+        this.elementType = ElementType.TYPE;
+        this.type = cls;
+        this.genericType = cls;
+        this.name = cls.getName();
+    }
+
+    public JavaElementImpl(Field field) {
+        this.anchor = field;
+        this.elementType = ElementType.FIELD;
+        this.type = field.getType();
+        this.genericType = field.getGenericType();
+        this.name = field.getName();
+    }
+
+    public JavaElementImpl(Constructor<?> constructor, int index) {
+        this.anchor = constructor;
+        this.elementType = ElementType.PARAMETER;
+        this.type = constructor.getParameterTypes()[index];
+        this.genericType = constructor.getGenericParameterTypes()[index];
+        this.index = index;
+        this.name = "";
+    }
+
+    public JavaElementImpl(Method method, int index) {
+        this.anchor = method;
+        this.elementType = ElementType.PARAMETER;
+        this.type = method.getParameterTypes()[index];
+        this.genericType = method.getGenericParameterTypes()[index];
+        this.index = index;
+        this.name = "";
+    }
+
+    /**
+     * For testing purpose
+     * 
+     * @param name
+     * @param type
+     * @param classifer TODO
+     * @param elementType
+     */
+    public JavaElementImpl(String name, Class<?> type, Class<? extends Annotation> classifer) {
+        super();
+        this.type = type;
+        this.name = name;
+        this.classifer = classifer;
+    }
+
+    /**
+     * @return the anchor
+     */
+    public AnnotatedElement getAnchor() {
+        return anchor;
+    }
+
+    /**
+     * @return the elementType
+     */
+    public ElementType getElementType() {
+        return elementType;
+    }
+
+    /**
+     * @return the genericType
+     */
+    public Type getGenericType() {
+        return genericType;
+    }
+
+    /**
+     * @return the index
+     */
+    public int getIndex() {
+        return index;
+    }
+
+    /**
+     * @return the type
+     */
+    public Class<?> getType() {
+        return type;
+    }
+
+    public Annotation[] getAnnotations() {
+        if (elementType == ElementType.PARAMETER) {
+            if (anchor instanceof Method) {
+                // We only care about the method-level annotations
+                return ((Method)anchor).getAnnotations();
+            }
+            if (anchor instanceof Constructor) {
+                return ((Constructor)anchor).getParameterAnnotations()[index];
+            }
+        }
+        return anchor.getAnnotations();
+    }
+
+    public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
+        for (Annotation a : getAnnotations()) {
+            if (a.annotationType() == annotationType) {
+                return annotationType.cast(a);
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public String toString() {
+        return anchor.toString() + (elementType == ElementType.PARAMETER ? "[" + index + "]" : "");
+    }
+
+    @Override
+    public int hashCode() {
+        final int PRIME = 31;
+        int result = 1;
+        result = PRIME * result + ((anchor == null) ? 0 : anchor.hashCode());
+        result = PRIME * result + index;
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        final JavaElementImpl other = (JavaElementImpl)obj;
+        if (anchor == null) {
+            if (other.anchor != null) {
+                return false;
+            }
+        } else if (!anchor.equals(other.anchor)) {
+            return false;
+        }
+        if (index != other.index) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * @return the name
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * @param name the name to set
+     */
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    /**
+     * @return the classifier
+     */
+    public Class<? extends Annotation> getClassifer() {
+        return classifer;
+    }
+
+    /**
+     * @param classifer the classifier to set
+     */
+    public void setClassifer(Class<? extends Annotation> classifer) {
+        this.classifer = classifer;
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaImplementationActivator.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaImplementationActivator.java
new file mode 100644
index 0000000000..46594e0f50
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaImplementationActivator.java
@@ -0,0 +1,86 @@
+/*
+ * 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.java.impl;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+import org.apache.tuscany.sca.core.ModuleActivator;
+import org.apache.tuscany.sca.implementation.java.JavaImplementationFactory;
+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.ComponentNameProcessor;
+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.ConversationIDProcessor;
+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.interfacedef.java.JavaInterfaceFactory;
+import org.apache.tuscany.sca.policy.PolicyFactory;
+
+/**
+ * A module activator for the Java implementation model.
+ *
+ * @version $Rev$ $Date$
+ */
+public class JavaImplementationActivator implements ModuleActivator {
+
+    public void start(ExtensionPointRegistry registry) {
+        ModelFactoryExtensionPoint modelFactories = registry.getExtensionPoint(ModelFactoryExtensionPoint.class);
+        AssemblyFactory assemblyFactory = modelFactories.getFactory(AssemblyFactory.class);
+        JavaInterfaceFactory javaFactory = modelFactories.getFactory(JavaInterfaceFactory.class);
+        PolicyFactory policyFactory = modelFactories.getFactory(PolicyFactory.class);
+        
+        BaseJavaClassVisitor[] extensions =
+            new BaseJavaClassVisitor[] {new ConstructorProcessor(assemblyFactory),
+                                        new AllowsPassByReferenceProcessor(assemblyFactory),
+                                        new ComponentNameProcessor(assemblyFactory),
+                                        new ContextProcessor(assemblyFactory),
+                                        new ConversationIDProcessor(assemblyFactory),
+                                        new ConversationProcessor(assemblyFactory),
+                                        new DestroyProcessor(assemblyFactory), new EagerInitProcessor(assemblyFactory),
+                                        new InitProcessor(assemblyFactory), new PropertyProcessor(assemblyFactory),
+                                        new ReferenceProcessor(assemblyFactory, javaFactory),
+                                        new ResourceProcessor(assemblyFactory), new ScopeProcessor(assemblyFactory),
+                                        new ServiceProcessor(assemblyFactory, javaFactory),
+                                        new HeuristicPojoProcessor(assemblyFactory, javaFactory),
+                                        new PolicyProcessor(assemblyFactory, policyFactory)};
+
+        JavaImplementationFactory javaImplementationFactory = modelFactories.getFactory(JavaImplementationFactory.class);
+        for (JavaClassVisitor extension : extensions) {
+            javaImplementationFactory.addClassVisitor(extension);
+        }
+
+    }
+
+    public void stop(ExtensionPointRegistry registry) {
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaImplementationFactoryImpl.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaImplementationFactoryImpl.java
new file mode 100644
index 0000000000..0cc78498e6
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaImplementationFactoryImpl.java
@@ -0,0 +1,70 @@
+/*
+ * 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.java.impl;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.apache.tuscany.sca.implementation.java.JavaImplementationFactory;
+import org.apache.tuscany.sca.implementation.java.introspect.JavaClassVisitor;
+
+/**
+ * A factory for the Java model.
+ *
+ * @version $Rev$ $Date$
+ */
+public abstract class JavaImplementationFactoryImpl implements JavaImplementationFactory {
+    
+    private List<JavaClassVisitor> visitors = new ArrayList<JavaClassVisitor>();
+    private JavaClassIntrospectorImpl introspector;
+    
+    public JavaImplementationFactoryImpl() {
+        introspector = new JavaClassIntrospectorImpl(visitors);
+    }
+
+    public JavaImplementation createJavaImplementation() {
+        JavaImplementation javaImplementation = new JavaImplementationImpl();
+        return javaImplementation;
+    }
+    
+    public JavaImplementation createJavaImplementation(Class<?> implementationClass) throws IntrospectionException {
+        JavaImplementation javaImplementation = createJavaImplementation();
+        introspector.introspectClass(javaImplementation, implementationClass);
+        return javaImplementation;
+    }
+    
+    public void createJavaImplementation(JavaImplementation javaImplementation, Class<?> implementationClass) throws IntrospectionException {
+        introspector.introspectClass(javaImplementation, implementationClass);
+    }
+
+    public void addClassVisitor(JavaClassVisitor visitor) {
+        visitors.add(visitor);
+    }
+
+    public void removeClassVisitor(JavaClassVisitor visitor) {
+        visitors.remove(visitor);
+    }
+    
+    public List<JavaClassVisitor> getClassVisitors() {
+        return visitors;
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaImplementationImpl.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaImplementationImpl.java
new file mode 100644
index 0000000000..375896cf26
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaImplementationImpl.java
@@ -0,0 +1,168 @@
+/*
+ * 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.java.impl;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.apache.tuscany.sca.policy.util.PolicyHandlerTuple;
+
+/**
+ * A component type specialization for POJO implementations
+ *
+ * @version $Rev$ $Date$
+ */
+public class JavaImplementationImpl extends BaseJavaImplementationImpl implements JavaImplementation {
+    private JavaConstructorImpl<?> constructorDefinition;
+    private Map<Constructor, JavaConstructorImpl> constructors = new HashMap<Constructor, JavaConstructorImpl>();
+    private Method initMethod;
+    private Method destroyMethod;
+    private final Map<String, JavaResourceImpl> resources = new HashMap<String, JavaResourceImpl>();
+    private final Map<String, JavaElementImpl> propertyMembers = new HashMap<String, JavaElementImpl>();
+    private final Map<String, JavaElementImpl> referenceMembers = new HashMap<String, JavaElementImpl>();
+    private final Map<String, Collection<JavaElementImpl>> callbackMembers = new HashMap<String, Collection<JavaElementImpl>>();
+    private List<Member> conversationIDMember = new ArrayList<Member>();
+    private boolean eagerInit;
+    private boolean allowsPassByReference;
+    private List<Method> allowsPassByReferenceMethods = new ArrayList<Method>();
+    private long maxAge = -1;
+    private long maxIdleTime = -1;
+    private JavaScopeImpl scope = JavaScopeImpl.STATELESS;
+    private List<PolicyHandlerTuple> policyHandlerClassNames = null;
+    
+    protected JavaImplementationImpl() {
+        super();
+    }    
+
+    public JavaConstructorImpl<?> getConstructor() {
+        return constructorDefinition;
+    }
+
+    public void setConstructor(JavaConstructorImpl<?> definition) {
+        this.constructorDefinition = definition;
+    }
+
+    public Method getInitMethod() {
+        return initMethod;
+    }
+
+    public void setInitMethod(Method initMethod) {
+        this.initMethod = initMethod;
+    }
+
+    public Method getDestroyMethod() {
+        return destroyMethod;
+    }
+
+    public void setDestroyMethod(Method destroyMethod) {
+        this.destroyMethod = destroyMethod;
+    }
+
+    public Map<String, JavaResourceImpl> getResources() {
+        return resources;
+    }
+
+    public List<Member> getConversationIDMembers() {
+        return this.conversationIDMember;
+    }
+
+    public void addConversationIDMember(Member conversationIDMember) {
+        this.conversationIDMember.add(conversationIDMember);
+    }
+
+    public boolean isAllowsPassByReference() {
+        return allowsPassByReference;
+    }
+
+    public void setAllowsPassByReference(boolean allowsPassByReference) {
+        this.allowsPassByReference = allowsPassByReference;
+    }
+
+    public List<Method> getAllowsPassByReferenceMethods() {
+        return allowsPassByReferenceMethods;
+    }
+    
+    public boolean isAllowsPassByReference(Method method) {
+        return allowsPassByReference || allowsPassByReferenceMethods.contains(method);
+    }
+
+    public Map<Constructor, JavaConstructorImpl> getConstructors() {
+        return constructors;
+    }
+
+    public boolean isEagerInit() {
+        return eagerInit;
+    }
+
+    public void setEagerInit(boolean eagerInit) {
+        this.eagerInit = eagerInit;
+    }
+
+    public Map<String, Collection<JavaElementImpl>> getCallbackMembers() {
+        return callbackMembers;
+    }
+
+    public Map<String, JavaElementImpl> getPropertyMembers() {
+        return propertyMembers;
+    }
+
+    public Map<String, JavaElementImpl> getReferenceMembers() {
+        return referenceMembers;
+    }
+
+    public JavaScopeImpl getJavaScope() {
+        return scope;
+    }
+
+    public void setJavaScope(JavaScopeImpl scope) {
+        this.scope = scope;
+    }
+
+    public long getMaxAge() {
+        return maxAge;
+    }
+
+    public void setMaxAge(long maxAge) {
+        this.maxAge = maxAge;
+    }
+
+    public long getMaxIdleTime() {
+        return maxIdleTime;
+    }
+
+    public void setMaxIdleTime(long maxIdleTime) {
+        this.maxIdleTime = maxIdleTime;
+    }
+
+    public List<PolicyHandlerTuple> getPolicyHandlerClassNames() {
+        return policyHandlerClassNames;
+    }
+
+    public void setPolicyHandlerClassNames(List<PolicyHandlerTuple> policyHandlerClassNames) {
+        this.policyHandlerClassNames = policyHandlerClassNames;
+    }
+ 
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaParameterImpl.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaParameterImpl.java
new file mode 100644
index 0000000000..c4c528f4f2
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaParameterImpl.java
@@ -0,0 +1,35 @@
+/*
+ * 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.java.impl;
+
+import java.lang.reflect.Constructor;
+
+/**
+ * @version $Rev$ $Date$
+ */
+public class JavaParameterImpl extends JavaElementImpl {
+    /**
+     * @param constructor
+     * @param index
+     */
+    public JavaParameterImpl(Constructor<?> constructor, int index) {
+        super(constructor, index);
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaResourceImpl.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaResourceImpl.java
new file mode 100644
index 0000000000..1aca15ebb8
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaResourceImpl.java
@@ -0,0 +1,85 @@
+/*
+ * 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.java.impl;
+
+
+/**
+ * A resource dependency declared by a Java component implementation
+ * 
+ * @version $Rev$ $Date$
+ */
+public class JavaResourceImpl {
+    private JavaElementImpl element;
+    private String mappedName;
+    private boolean optional;
+
+    public JavaResourceImpl(JavaElementImpl element) {
+        this.element = element;
+    }
+
+    /**
+     * The name of the resource
+     * 
+     * @return the name of the resource
+     */
+    public String getName() {
+        return element.getName();
+    }
+
+    /**
+     * Returns the URI of the resource
+     * 
+     * @return the URI of the resource
+     */
+    public String getMappedName() {
+        return mappedName;
+    }
+
+    /**
+     * Sets the resource URI
+     */
+    public void setMappedName(String mappedName) {
+        this.mappedName = mappedName;
+    }
+
+    /**
+     * If true, the resource is optional
+     * 
+     * @return true if the resource is optional
+     */
+    public boolean isOptional() {
+        return optional;
+    }
+
+    /**
+     * Sets whether the resource is optional
+     */
+    public void setOptional(boolean optional) {
+        this.optional = optional;
+    }
+
+    /**
+     * @return the element
+     */
+    public JavaElementImpl getElement() {
+        return element;
+    }
+
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaScopeImpl.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaScopeImpl.java
new file mode 100644
index 0000000000..85c2f73f75
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/impl/JavaScopeImpl.java
@@ -0,0 +1,66 @@
+/*
+ * 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.java.impl;
+
+/**
+ * The default implementation scopes supported by assemblies.
+ *
+ * @version $Rev$ $Date$
+ */
+public class JavaScopeImpl {
+    public static final JavaScopeImpl STATELESS = new JavaScopeImpl("STATELESS");
+    public static final JavaScopeImpl REQUEST = new JavaScopeImpl("REQUEST");
+    public static final JavaScopeImpl SESSION = new JavaScopeImpl("SESSION");
+    public static final JavaScopeImpl CONVERSATION = new JavaScopeImpl("CONVERSATION");
+    public static final JavaScopeImpl COMPOSITE = new JavaScopeImpl("COMPOSITE");
+    public static final JavaScopeImpl SYSTEM = new JavaScopeImpl("SYSTEM");
+    public static final JavaScopeImpl UNDEFINED = new JavaScopeImpl("UNDEFINED");
+
+    private String scope;
+
+    public JavaScopeImpl(String scope) {
+        this.scope = scope.toUpperCase().intern();
+    }
+
+    public String getScope() {
+        return scope;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        final JavaScopeImpl scope1 = (JavaScopeImpl) o;
+        return !(scope != null ? scope != scope1.scope.intern() : scope1.scope != null);
+    }
+
+    @Override
+    public int hashCode() {
+        return scope != null ? scope.hashCode() : 0;
+    }
+
+    @Override
+    public String toString() {
+        return scope;
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/JavaClassVisitor.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/JavaClassVisitor.java
new file mode 100644
index 0000000000..4fa40dee4b
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/JavaClassVisitor.java
@@ -0,0 +1,126 @@
+/*
+ * 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.java.introspect;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.apache.tuscany.sca.implementation.java.impl.JavaParameterImpl;
+
+/**
+ * Implementations process class-level metadata, typically parsing annotations
+ * and updating the corresponding <code>ComponentType</code>. A processor
+ * may, for example, create a Property which is responsible for injecting a
+ * complex type on a component implementation instance when it is instantiated.
+ * <p/> Processors will receive callbacks as the implementation class is walked
+ * while evaluating an assembly. It is the responsibility of the parser to
+ * determine whether to perform an action during the callback.
+ * 
+ * @version $Rev$ $Date$
+ */
+public interface JavaClassVisitor {
+
+    /**
+     * A callback received when the component implementation class is first
+     * loaded
+     * 
+     * @param clazz the component implementation class
+     * @param type the incomplete component type associated with the
+     *            implementation class
+     * @throws IntrospectionException if an error is encountered while processing
+     *             metadata
+     */
+    <T> void visitClass(Class<T> clazz, JavaImplementation type) throws IntrospectionException;
+
+    /**
+     * A callback received as the component implementation class hierarchy is
+     * evaluated
+     * 
+     * @param clazz the superclass in the component implmentation's class
+     *            hierarchy
+     * @param type the incomplete component type associated with the
+     *            implementation class
+     * @throws IntrospectionException if an error is encountered while processing
+     *             metadata
+     */
+    <T> void visitSuperClass(Class<T> clazz, JavaImplementation type) throws IntrospectionException;
+
+    /**
+     * A callback received as the component implementation's public and
+     * protected methods are evaluated
+     * 
+     * @param method the current public or protected method being evaluated
+     * @param type the incomplete component type associated with the
+     *            implementation class
+     * @throws IntrospectionException if an error is encountered while processing
+     *             metadata
+     */
+    void visitMethod(Method method, JavaImplementation type) throws IntrospectionException;
+
+    /**
+     * A callback received as the component implementation's constructor used
+     * for instantiation by the runtime is evaluated. If an implementation
+     * contains more than one constructor, the constructor passed to the
+     * callback will be chosen according to the algorithm described in the SCA
+     * Java Client and Implementation Model Specification.
+     * 
+     * @param constructor the constructor used for instantiating component
+     *            implementation instances
+     * @param type the incomplete component type associated with the
+     *            implementation class
+     * @throws IntrospectionException if an error is encountered while processing
+     *             metadata
+     */
+    <T> void visitConstructor(Constructor<T> constructor, JavaImplementation type) throws IntrospectionException;
+
+    /**
+     * @param parameter
+     * @param type
+     * @throws IntrospectionException
+     */
+    void visitConstructorParameter(JavaParameterImpl parameter, JavaImplementation type) throws IntrospectionException;
+
+    /**
+     * A callback received as the component implementation's public and
+     * protected fields are evaluated
+     * 
+     * @param field the current public or protected field being evaluated
+     * @param type the incomplete component type associated with the
+     *            implementation class
+     * @throws IntrospectionException if an error is encountered while processing
+     *             metadata
+     */
+    void visitField(Field field, JavaImplementation type) throws IntrospectionException;
+
+    /**
+     * The final callback received when all other callbacks during evaluation of
+     * the component implementation have been issued
+     * 
+     * @param clazz the component implementation class
+     * @param type the incomplete component type associated with the
+     *            implementation class
+     * @throws IntrospectionException if an error is encountered while processing
+     *             metadata
+     */
+    <T> void visitEnd(Class<T> clazz, JavaImplementation type) throws IntrospectionException;
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/AbstractPropertyProcessor.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/AbstractPropertyProcessor.java
new file mode 100644
index 0000000000..9596fe0808
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/AbstractPropertyProcessor.java
@@ -0,0 +1,192 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.Property;
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.apache.tuscany.sca.implementation.java.impl.JavaElementImpl;
+import org.apache.tuscany.sca.implementation.java.impl.JavaParameterImpl;
+import org.apache.tuscany.sca.interfacedef.util.JavaXMLMapper;
+
+/**
+ * Base class for ImplementationProcessors that handle annotations that add
+ * Properties.
+ * 
+ * @version $Rev$ $Date$
+ */
+public abstract class AbstractPropertyProcessor<A extends Annotation> extends BaseJavaClassVisitor {
+    private final Class<A> annotationClass;
+
+    protected AbstractPropertyProcessor(AssemblyFactory assemblyFactory, Class<A> annotationClass) {
+        super(assemblyFactory);
+        this.annotationClass = annotationClass;
+    }
+    
+    private boolean removeProperty(JavaElementImpl prop, JavaImplementation type) {
+        if(prop==null) {
+            return false;
+        }
+        List<Property> props = type.getProperties();
+        for(int i=0;i<props.size();i++) {
+            if(props.get(i).getName().equals(prop.getName())) {
+                props.remove(i);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void visitMethod(Method method, JavaImplementation type) throws IntrospectionException {
+        A annotation = method.getAnnotation(annotationClass);
+        if (annotation == null) {
+            return;
+        }
+
+        if (!JavaIntrospectionHelper.isSetter(method)) {
+            throw new IllegalPropertyException("Annotated method is not a setter: " + method, method);
+        }
+
+        String name = getName(annotation);
+        if (name == null || "".equals(name)) {
+            name = method.getName();
+            if (name.startsWith("set")) {
+                name = JavaIntrospectionHelper.toPropertyName(method.getName());
+            }
+        }
+
+        Map<String, JavaElementImpl> properties = type.getPropertyMembers();
+        JavaElementImpl prop = properties.get(name);
+        // Setter override field
+        if (prop != null && prop.getElementType() != ElementType.FIELD) {
+            throw new DuplicatePropertyException(name);
+        }
+
+        removeProperty(prop, type);
+        
+        JavaElementImpl element = new JavaElementImpl(method, 0);
+        Property property = createProperty(name, element);
+
+        // add databinding available as annotations, as extensions
+
+        initProperty(property, annotation);
+        type.getProperties().add(property);
+        properties.put(name, element);
+    }
+
+    @Override
+    public void visitField(Field field, JavaImplementation type) throws IntrospectionException {
+
+        A annotation = field.getAnnotation(annotationClass);
+        if (annotation == null) {
+            return;
+        }
+
+        String name = getName(annotation);
+        if (name == null) {
+            name = "";
+        }
+        if ("".equals(name) || name.equals(field.getType().getName())) {
+            name = field.getName();
+        }
+
+        Map<String, JavaElementImpl> properties = type.getPropertyMembers();
+        JavaElementImpl prop = properties.get(name);
+        // Setter override field
+        if (prop != null && prop.getElementType() == ElementType.FIELD) {
+            throw new DuplicatePropertyException(name);
+        }
+
+        if (prop == null) {
+            JavaElementImpl element = new JavaElementImpl(field);
+            Property property = createProperty(name, element);
+            initProperty(property, annotation);
+            type.getProperties().add(property);
+            properties.put(name, element);
+        }
+    }
+
+    @Override
+    public void visitConstructorParameter(JavaParameterImpl parameter, JavaImplementation type)
+        throws IntrospectionException {
+
+        Map<String, JavaElementImpl> properties = type.getPropertyMembers();
+        A annotation = parameter.getAnnotation(annotationClass);
+        if (annotation != null) {
+            String name = getName(annotation);
+            if (name == null) {
+                name = parameter.getType().getName();
+            }
+            if (!"".equals(name) && !"".equals(parameter.getName()) && !name.equals(parameter.getName())) {
+                throw new InvalidConstructorException("Mismatched property name: " + parameter);
+            }
+            if ("".equals(name) && "".equals(parameter.getName())) {
+                throw new InvalidPropertyException("Missing property name: " + parameter);
+            }
+            if ("".equals(name)) {
+                name = parameter.getName();
+            }
+
+            JavaElementImpl prop = properties.get(name);
+            // Setter override field
+            if (prop != null && prop.getElementType() != ElementType.FIELD) {
+                throw new DuplicatePropertyException(name);
+            }
+            removeProperty(prop, type);
+            
+            parameter.setName(name);
+            parameter.setClassifer(annotationClass);
+            Property property = createProperty(name, parameter);
+            initProperty(property, annotation);
+            type.getProperties().add(property);
+            properties.put(name, parameter);
+        }
+    }
+
+    protected abstract String getName(A annotation);
+
+    protected abstract void initProperty(Property property, A annotation) throws IntrospectionException;
+
+    @SuppressWarnings("unchecked")
+    protected Property createProperty(String name, JavaElementImpl element) throws IntrospectionException {
+
+        Property property = assemblyFactory.createProperty();
+        property.setName(name);
+        Class<?> baseType = JavaIntrospectionHelper.getBaseType(element.getType(), element.getGenericType());
+        property.setXSDType(JavaXMLMapper.getXMLType(baseType));
+
+        Class<?> javaType = element.getType();
+        if (javaType.isArray() || Collection.class.isAssignableFrom(javaType)) {
+            property.setMany(true);
+        }
+        return property;
+
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/AllowsPassByReferenceProcessor.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/AllowsPassByReferenceProcessor.java
new file mode 100644
index 0000000000..4a3ce0c343
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/AllowsPassByReferenceProcessor.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.sca.implementation.java.introspect.impl;
+
+import java.lang.reflect.Method;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.osoa.sca.annotations.AllowsPassByReference;
+
+/**
+ * Processes {@link AllowsPassByReference} on an implementation
+ * 
+ * @version $Rev$ $Date$
+ */
+public class AllowsPassByReferenceProcessor extends BaseJavaClassVisitor {
+    
+    public AllowsPassByReferenceProcessor(AssemblyFactory factory) {
+        super(factory);
+    }
+
+    @Override
+    public <T> void visitClass(Class<T> clazz, JavaImplementation type) throws IntrospectionException {
+        type.setAllowsPassByReference(clazz.isAnnotationPresent(AllowsPassByReference.class));
+    }
+
+    @Override
+    public void visitMethod(Method method, JavaImplementation type) throws IntrospectionException {
+        boolean pbr = method.isAnnotationPresent(AllowsPassByReference.class);
+        if (pbr) {
+            type.getAllowsPassByReferenceMethods().add(method);
+        }
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/AmbiguousConstructorException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/AmbiguousConstructorException.java
new file mode 100644
index 0000000000..c6e6b6e4d6
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/AmbiguousConstructorException.java
@@ -0,0 +1,40 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.reflect.Member;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Thrown when constructor parameters cannot be unambiguously resolved to a property or reference
+ *
+ * @version $Rev$ $Date$
+ */
+public class AmbiguousConstructorException extends IntrospectionException {
+    private static final long serialVersionUID = 3662860753837091880L;
+
+    public AmbiguousConstructorException(String message) {
+        super(message);
+    }
+    
+    public AmbiguousConstructorException(String message, Member member) {
+        super(message, member);
+    }    
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/BaseJavaClassVisitor.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/BaseJavaClassVisitor.java
new file mode 100644
index 0000000000..bc6551d45d
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/BaseJavaClassVisitor.java
@@ -0,0 +1,64 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.apache.tuscany.sca.implementation.java.impl.JavaParameterImpl;
+import org.apache.tuscany.sca.implementation.java.introspect.JavaClassVisitor;
+
+/**
+ * A convenience class for annotation processors which alleviates the need to
+ * implement unused callbacks
+ * 
+ * @version $Rev$ $Date$
+ */
+public abstract class BaseJavaClassVisitor implements JavaClassVisitor {
+    protected AssemblyFactory assemblyFactory;
+    
+    protected BaseJavaClassVisitor(AssemblyFactory factory) {
+        this.assemblyFactory = factory;
+    }
+
+    public <T> void visitClass(Class<T> clazz, JavaImplementation type) throws IntrospectionException {
+    }
+
+    public <T> void visitSuperClass(Class<T> clazz, JavaImplementation type) throws IntrospectionException {
+    }
+
+    public void visitMethod(Method method, JavaImplementation type) throws IntrospectionException {
+    }
+
+    public <T> void visitConstructor(Constructor<T> constructor, JavaImplementation type) throws IntrospectionException {
+    }
+
+    public void visitField(Field field, JavaImplementation type) throws IntrospectionException {
+    }
+
+    public <T> void visitEnd(Class<T> clazz, JavaImplementation type) throws IntrospectionException {
+    }
+
+    public void visitConstructorParameter(JavaParameterImpl parameter, JavaImplementation type) throws IntrospectionException {
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ComponentNameProcessor.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ComponentNameProcessor.java
new file mode 100644
index 0000000000..556f0b77e9
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ComponentNameProcessor.java
@@ -0,0 +1,80 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.apache.tuscany.sca.implementation.java.impl.JavaElementImpl;
+import org.apache.tuscany.sca.implementation.java.impl.JavaResourceImpl;
+import org.osoa.sca.annotations.ComponentName;
+
+/**
+ * Processes {@link @ComponentName} annotations on a component implementation and adds
+ * a {@link JavaMappedProperty} to the component type which will be used to
+ * inject the appropriate component name.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class ComponentNameProcessor extends BaseJavaClassVisitor {
+    
+    public ComponentNameProcessor(AssemblyFactory factory) {
+        super(factory);
+    }
+
+    @Override
+    public void visitMethod(Method method, JavaImplementation type) throws IntrospectionException {
+        if (method.getAnnotation(ComponentName.class) == null) {
+            return;
+        }
+        if (method.getParameterTypes().length != 1) {
+            throw new IllegalContextException("ComponentName setter must have one parameter", method);
+        }
+        Class<?> paramType = method.getParameterTypes()[0];
+        String name = JavaIntrospectionHelper.toPropertyName(method.getName());
+        if (String.class.equals(paramType)) {
+            JavaElementImpl element = new JavaElementImpl(method, 0);
+            element.setName(name);
+            element.setClassifer(org.apache.tuscany.sca.implementation.java.introspect.impl.Resource.class);
+            JavaResourceImpl resource = new JavaResourceImpl(element);
+            type.getResources().put(resource.getName(), resource);
+        } else {
+            throw new IllegalContextException(paramType.getName());
+        }
+    }
+
+    @Override
+    public void visitField(Field field, JavaImplementation type) throws IntrospectionException {
+        if (field.getAnnotation(ComponentName.class) == null) {
+            return;
+        }
+        Class<?> paramType = field.getType();
+        if (String.class.equals(paramType)) {
+            JavaElementImpl element = new JavaElementImpl(field);
+            element.setClassifer(Resource.class);
+            JavaResourceImpl resource = new JavaResourceImpl(element);
+            type.getResources().put(resource.getName(), resource);
+        } else {
+            throw new IllegalContextException(paramType.getName());
+        }
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ConstructorProcessor.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ConstructorProcessor.java
new file mode 100644
index 0000000000..17e28479d3
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ConstructorProcessor.java
@@ -0,0 +1,83 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.reflect.Constructor;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.apache.tuscany.sca.implementation.java.impl.JavaConstructorImpl;
+import org.apache.tuscany.sca.implementation.java.impl.JavaParameterImpl;
+
+/**
+ * Handles processing of a constructor decorated with
+ * {@link org.osoa.sca.annotations.Constructor}
+ * 
+ * @version $Rev$ $Date$
+ */
+@SuppressWarnings("unchecked")
+public class ConstructorProcessor extends BaseJavaClassVisitor {
+    
+    public ConstructorProcessor(AssemblyFactory factory) {
+        super(factory);
+    }
+
+    @Override
+    public <T> void visitClass(Class<T> clazz, JavaImplementation type) throws IntrospectionException {
+        Constructor[] ctors = clazz.getConstructors();
+        boolean found = false;
+        for (Constructor constructor : ctors) {
+            JavaConstructorImpl<?> definition = new JavaConstructorImpl(constructor);
+            type.getConstructors().put(constructor, definition);
+            if (constructor.getAnnotation(org.osoa.sca.annotations.Constructor.class) != null) {
+                if (found) {
+                    throw new DuplicateConstructorException("Multiple constructors marked with @Constructor", constructor);
+                }
+                found = true;
+                type.setConstructor(definition);
+            }
+        }
+    }
+
+    @Override
+    public <T> void visitConstructor(Constructor<T> constructor, JavaImplementation type)
+        throws IntrospectionException {
+        org.osoa.sca.annotations.Constructor annotation = constructor
+            .getAnnotation(org.osoa.sca.annotations.Constructor.class);
+        if (annotation == null) {
+            return;
+        }
+        JavaConstructorImpl<?> definition = type.getConstructor();
+        if (definition == null) {
+            definition = new JavaConstructorImpl(constructor);
+            type.setConstructor(definition);
+        }
+        JavaParameterImpl[] parameters = definition.getParameters();
+        String[] value = annotation.value();
+        boolean isDefault = value.length == 0 || (value.length == 1 && "".equals(value[0]));
+        if (!isDefault && value.length != parameters.length) {
+            throw new InvalidConstructorException("Invalid Number of names in @Constructor");
+        }
+        for (int i = 0; i < parameters.length; i++) {
+            parameters[i].setName(i < value.length ? value[i] : "");
+        }
+        type.setConstructor(definition);
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ContextProcessor.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ContextProcessor.java
new file mode 100644
index 0000000000..177ceaa57c
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ContextProcessor.java
@@ -0,0 +1,82 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.apache.tuscany.sca.implementation.java.introspect.impl;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.apache.tuscany.sca.implementation.java.impl.JavaElementImpl;
+import org.apache.tuscany.sca.implementation.java.impl.JavaResourceImpl;
+import org.osoa.sca.ComponentContext;
+import org.osoa.sca.RequestContext;
+import org.osoa.sca.annotations.Context;
+
+/**
+ * Processes {@link @Context} annotations on a component implementation and adds
+ * a {@link JavaMappedProperty} to the component type which will be used to
+ * inject the appropriate context
+ * 
+ * @version $Rev$ $Date$
+ */
+public class ContextProcessor extends BaseJavaClassVisitor {
+    
+    public ContextProcessor(AssemblyFactory factory) {
+        super(factory);
+    }
+
+    @Override
+    public void visitMethod(Method method, JavaImplementation type) throws IntrospectionException {
+        if (method.getAnnotation(Context.class) == null) {
+            return;
+        }
+        if (method.getParameterTypes().length != 1) {
+            throw new IllegalContextException("Context setter must have one parameter", method);
+        }
+        Class<?> paramType = method.getParameterTypes()[0];
+        String name = JavaIntrospectionHelper.toPropertyName(method.getName());
+        if (ComponentContext.class.equals(paramType) || RequestContext.class.equals(paramType)) {
+            JavaElementImpl element = new JavaElementImpl(method, 0);
+            element.setName(name);
+            element.setClassifer(org.apache.tuscany.sca.implementation.java.introspect.impl.Resource.class);
+            JavaResourceImpl resource = new JavaResourceImpl(element);
+            type.getResources().put(resource.getName(), resource);
+        } else {
+            throw new UnknownContextTypeException(paramType.getName());
+        }
+    }
+
+    @Override
+    public void visitField(Field field, JavaImplementation type) throws IntrospectionException {
+        if (field.getAnnotation(Context.class) == null) {
+            return;
+        }
+        Class<?> paramType = field.getType();
+        if (ComponentContext.class.equals(paramType) || RequestContext.class.equals(paramType)) {
+            JavaElementImpl element = new JavaElementImpl(field);
+            element.setClassifer(Resource.class);
+            JavaResourceImpl resource = new JavaResourceImpl(element);
+            type.getResources().put(resource.getName(), resource);
+        } else {
+            throw new UnknownContextTypeException(paramType.getName());
+        }
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ConversationIDProcessor.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ConversationIDProcessor.java
new file mode 100644
index 0000000000..985f8baa82
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ConversationIDProcessor.java
@@ -0,0 +1,70 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.apache.tuscany.sca.implementation.java.impl.JavaElementImpl;
+import org.apache.tuscany.sca.implementation.java.impl.JavaResourceImpl;
+import org.osoa.sca.annotations.ConversationID;
+
+/**
+ * Processes {@link @ConversationID} annotations on a component implementation and adds
+ * a {@link JavaMappedProperty} to the component type which will be used to
+ * inject the appropriate conversationId
+ *
+ * @version $Rev$ $Date$
+ */
+public class ConversationIDProcessor extends BaseJavaClassVisitor {
+    
+    public ConversationIDProcessor(AssemblyFactory factory) {
+        super(factory);
+    }
+
+    @Override
+    public void visitMethod(Method method, JavaImplementation type) throws IntrospectionException {
+        if (method.getAnnotation(ConversationID.class) == null) {
+            return;
+        }
+        if (method.getParameterTypes().length != 1) {
+            throw new IllegalContextException("ConversationID setter must have one parameter", method);
+        }
+        String name = JavaIntrospectionHelper.toPropertyName(method.getName());
+        JavaElementImpl element = new JavaElementImpl(method, 0);
+        element.setName(name);
+        element.setClassifer(org.apache.tuscany.sca.implementation.java.introspect.impl.Resource.class);
+        JavaResourceImpl resource = new JavaResourceImpl(element);
+        type.getResources().put(resource.getName(), resource);
+    }
+
+    @Override
+    public void visitField(Field field, JavaImplementation type) throws IntrospectionException {
+        if (field.getAnnotation(ConversationID.class) == null) {
+            return;
+        }
+        JavaElementImpl element = new JavaElementImpl(field);
+        element.setClassifer(org.apache.tuscany.sca.implementation.java.introspect.impl.Resource.class);
+        JavaResourceImpl resource = new JavaResourceImpl(element);
+        type.getResources().put(resource.getName(), resource);
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ConversationProcessor.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ConversationProcessor.java
new file mode 100644
index 0000000000..efd04262dd
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ConversationProcessor.java
@@ -0,0 +1,132 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.osoa.sca.annotations.ConversationAttributes;
+import org.osoa.sca.annotations.ConversationID;
+import org.osoa.sca.annotations.Scope;
+
+/**
+ * @version $Rev$ $Date$
+ */
+public class ConversationProcessor extends BaseJavaClassVisitor {
+    private static final String SECONDS = " SECONDS";
+    private static final String MINUTES = " MINUTES";
+    private static final String HOURS = " HOURS";
+    private static final String DAYS = " DAYS";
+    private static final String YEARS = " YEARS";
+    
+    public ConversationProcessor(AssemblyFactory factory) {
+        super(factory);
+    }
+
+    @Override
+    public <T> void visitClass(Class<T> clazz, JavaImplementation type) throws IntrospectionException {
+
+        ConversationAttributes conversation = clazz.getAnnotation(ConversationAttributes.class);
+        if (conversation == null) {
+            return;
+        }
+        Scope scope = clazz.getAnnotation(Scope.class);
+        if (scope == null) {
+            // implicitly assume conversation
+            type.setJavaScope(org.apache.tuscany.sca.implementation.java.impl.JavaScopeImpl.CONVERSATION);
+        } else if (conversation != null) {
+            long maxAge;
+            long maxIdleTime;
+            String maxAgeVal = conversation.maxAge();
+            String maxIdleTimeVal = conversation.maxIdleTime();
+            try {
+                if (maxAgeVal.length() > 0) {
+                    maxAge = convertTimeMillis(maxAgeVal);
+                    type.setMaxAge(maxAge);
+                }
+            } catch (NumberFormatException e) {
+                throw new InvalidConversationalImplementation("Invalid maximum age", e);
+            }
+            try {
+                if (maxIdleTimeVal.length() > 0) {
+                    maxIdleTime = convertTimeMillis(maxIdleTimeVal);
+                    type.setMaxIdleTime(maxIdleTime);
+                }
+            } catch (NumberFormatException e) {
+                throw new InvalidConversationalImplementation("Invalid maximum idle time", e);
+            }
+        }
+
+    }
+
+    @Override
+    public void visitMethod(Method method,
+                            JavaImplementation type) throws IntrospectionException {
+        ConversationID conversationID = method.getAnnotation(ConversationID.class);
+        if (conversationID == null) {
+            return;
+        }
+        type.addConversationIDMember(method);
+    }
+
+    @Override
+    public void visitField(Field field,
+                           JavaImplementation type) throws IntrospectionException {
+        ConversationID conversationID = field.getAnnotation(ConversationID.class);
+        if (conversationID == null) {
+            return;
+        }
+        type.addConversationIDMember(field);
+    }
+
+    protected long convertTimeMillis(String expr) throws NumberFormatException {
+        expr = expr.trim().toUpperCase();
+        int i = expr.lastIndexOf(SECONDS);
+        if (i >= 0) {
+            String units = expr.substring(0, i);
+            return Long.parseLong(units) * 1000;
+        }
+        i = expr.lastIndexOf(MINUTES);
+        if (i >= 0) {
+            String units = expr.substring(0, i);
+            return Long.parseLong(units) * 60000;
+        }
+
+        i = expr.lastIndexOf(HOURS);
+        if (i >= 0) {
+            String units = expr.substring(0, i);
+            return Long.parseLong(units) * 3600000;
+        }
+        i = expr.lastIndexOf(DAYS);
+        if (i >= 0) {
+            String units = expr.substring(0, i);
+            return Long.parseLong(units) * 86400000;
+        }
+        i = expr.lastIndexOf(YEARS);
+        if (i >= 0) {
+            String units = expr.substring(0, i);
+            return Long.parseLong(units) * 31556926000L;
+        }
+        return Long.parseLong(expr) * 1000; // assume seconds if no suffix
+                                            // specified
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DestroyProcessor.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DestroyProcessor.java
new file mode 100644
index 0000000000..50e4d46e97
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DestroyProcessor.java
@@ -0,0 +1,61 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.osoa.sca.annotations.Destroy;
+
+/**
+ * Processes the {@link @Destroy} annotation on a component implementation and
+ * updates the component type with the decorated destructor method
+ * 
+ * @version $Rev$ $Date$
+ */
+public class DestroyProcessor extends BaseJavaClassVisitor {
+    
+    public DestroyProcessor(AssemblyFactory factory) {
+        super(factory);
+    }
+
+    @Override
+    public void visitMethod(Method method, JavaImplementation type) throws IntrospectionException {
+        Destroy annotation = method.getAnnotation(Destroy.class);
+        if (annotation == null) {
+            return;
+        }
+        if (method.getParameterTypes().length != 0) {
+            throw new IllegalDestructorException("Destructor must not have argments", method);
+        }
+        if(!method.getReturnType().equals(void.class)) {
+            throw new IllegalDestructorException("Destructor must return void.", method);
+        }
+        if (type.getDestroyMethod() != null) {
+            throw new DuplicateDestructorException("More than one destructor found on implementation");
+        }
+        if (!Modifier.isPublic(method.getModifiers())) {
+            throw new IllegalDestructorException("Destructor must be a public method. Invalid annotation @Destroy found on "+method);
+        }
+        type.setDestroyMethod(method);
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DuplicateConstructorException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DuplicateConstructorException.java
new file mode 100644
index 0000000000..88a245cbf3
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DuplicateConstructorException.java
@@ -0,0 +1,41 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.reflect.Member;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Thrown when more than one component implementation constructor is annotated with {@link
+ * org.osoa.sca.annotations.Constructor}
+ *
+ * @version $Rev$ $Date$
+ */
+public class DuplicateConstructorException extends IntrospectionException {
+    private static final long serialVersionUID = -5926763756570552986L;
+
+    public DuplicateConstructorException(String message) {
+        super(message);
+    }
+
+    public DuplicateConstructorException(String message, Member member) {
+        super(message, member);
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DuplicateDestructorException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DuplicateDestructorException.java
new file mode 100644
index 0000000000..9b834e7e87
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DuplicateDestructorException.java
@@ -0,0 +1,35 @@
+/*
+ * 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.java.introspect.impl;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Thrown when an implementation is annotated multiple times with {@link org.osoa.sca.annotations.Destroy}
+ *
+ * @version $Rev$ $Date$
+ */
+public class DuplicateDestructorException extends IntrospectionException {
+    private static final long serialVersionUID = -7474912510114895203L;
+
+    public DuplicateDestructorException(String message) {
+        super(message);
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DuplicateInitException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DuplicateInitException.java
new file mode 100644
index 0000000000..4325faef26
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DuplicateInitException.java
@@ -0,0 +1,35 @@
+/*
+ * 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.java.introspect.impl;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Thrown when an implementation is annotated multiple times with {@link @org.osoa.sca.annotations.Init}
+ *
+ * @version $Rev$ $Date$
+ */
+public class DuplicateInitException extends IntrospectionException {
+    private static final long serialVersionUID = -6282935288115512057L;
+
+    public DuplicateInitException(String message) {
+        super(message);
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DuplicatePropertyException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DuplicatePropertyException.java
new file mode 100644
index 0000000000..b9e1923e73
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DuplicatePropertyException.java
@@ -0,0 +1,34 @@
+/*
+ * 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.java.introspect.impl;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Thrown when an implementation has more than one property injection site with the same name
+ *
+ * @version $Rev$ $Date$
+ */
+public class DuplicatePropertyException extends IntrospectionException {
+    private static final long serialVersionUID = 5536415875694904037L;
+
+    public DuplicatePropertyException(String message) {
+        super(message);
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DuplicateReferenceException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DuplicateReferenceException.java
new file mode 100644
index 0000000000..300ad6817e
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DuplicateReferenceException.java
@@ -0,0 +1,35 @@
+/*
+ * 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.java.introspect.impl;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Thrown when an implementation has more than one reference injection site with the same name
+ *
+ * @version $Rev$ $Date$
+ */
+public class DuplicateReferenceException extends IntrospectionException {
+    private static final long serialVersionUID = 907910648213477158L;
+
+    public DuplicateReferenceException(String message) {
+        super(message);
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DuplicateResourceException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DuplicateResourceException.java
new file mode 100644
index 0000000000..2d177b3f76
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/DuplicateResourceException.java
@@ -0,0 +1,36 @@
+/*
+ * 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.java.introspect.impl;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Thrown when an implementation has more than one resource injection site with the same name
+ *
+ * @version $Rev$ $Date$
+ */
+public class DuplicateResourceException extends IntrospectionException {
+
+    private static final long serialVersionUID = 1619276459330463299L;
+
+    public DuplicateResourceException(String message) {
+        super(message);
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/EagerInitProcessor.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/EagerInitProcessor.java
new file mode 100644
index 0000000000..5619275b82
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/EagerInitProcessor.java
@@ -0,0 +1,57 @@
+/*
+ * 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.java.introspect.impl;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.osoa.sca.annotations.EagerInit;
+
+/**
+ * Handles processing of {@link org.osoa.sca.annotations.EagerInit}
+ *
+ * @version $Rev$ $Date$
+ */
+public class EagerInitProcessor extends BaseJavaClassVisitor {
+    
+    public EagerInitProcessor(AssemblyFactory factory) {
+        super(factory);
+    }
+
+    @Override
+    public <T> void visitClass(Class<T> clazz,
+                               JavaImplementation type) throws IntrospectionException {
+        super.visitClass(clazz, type);
+        EagerInit annotation = clazz.getAnnotation(EagerInit.class);
+        if (annotation == null) {
+            Class<?> superClass = clazz.getSuperclass();
+            while (!Object.class.equals(superClass)) {
+                annotation = superClass.getAnnotation(EagerInit.class);
+                if (annotation != null) {
+                    break;
+                }
+                superClass = superClass.getSuperclass();
+            }
+            if (annotation == null) {
+                return;
+            }
+        }
+        type.setEagerInit(true);
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/HeuristicPojoProcessor.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/HeuristicPojoProcessor.java
new file mode 100644
index 0000000000..b7f6748ed2
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/HeuristicPojoProcessor.java
@@ -0,0 +1,615 @@
+/*
+ * 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.java.introspect.impl;
+
+import static org.apache.tuscany.sca.implementation.java.introspect.impl.JavaIntrospectionHelper.getAllInterfaces;
+import static org.apache.tuscany.sca.implementation.java.introspect.impl.JavaIntrospectionHelper.getAllPublicAndProtectedFields;
+import static org.apache.tuscany.sca.implementation.java.introspect.impl.JavaIntrospectionHelper.getAllUniquePublicProtectedMethods;
+import static org.apache.tuscany.sca.implementation.java.introspect.impl.JavaIntrospectionHelper.toPropertyName;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.jws.WebService;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.Contract;
+import org.apache.tuscany.sca.assembly.Multiplicity;
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.apache.tuscany.sca.implementation.java.impl.JavaConstructorImpl;
+import org.apache.tuscany.sca.implementation.java.impl.JavaElementImpl;
+import org.apache.tuscany.sca.implementation.java.impl.JavaParameterImpl;
+import org.apache.tuscany.sca.interfacedef.Interface;
+import org.apache.tuscany.sca.interfacedef.InvalidInterfaceException;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterface;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceContract;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory;
+import org.apache.tuscany.sca.interfacedef.util.JavaXMLMapper;
+import org.osoa.sca.annotations.Callback;
+import org.osoa.sca.annotations.Context;
+import org.osoa.sca.annotations.Property;
+import org.osoa.sca.annotations.Reference;
+import org.osoa.sca.annotations.Remotable;
+
+/**
+ * Heuristically evaluates an un-annotated Java implementation type to determine
+ * services, references, and properties according to the algorithm described in
+ * the SCA Java Client and Implementation Model Specification <p/> TODO
+ * Implement: <p/> When no service interface is annotated, need to calculate a
+ * single service comprising all public methods that are not reference or
+ * property injection sites. If that service can be exactly mapped to an
+ * interface implemented by the class then the service interface will be defined
+ * in terms of that interface.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class HeuristicPojoProcessor extends BaseJavaClassVisitor {
+    private JavaInterfaceFactory javaFactory;
+
+    public HeuristicPojoProcessor(AssemblyFactory assemblyFactory, JavaInterfaceFactory javaFactory) {
+        super(assemblyFactory);
+        this.javaFactory = javaFactory;
+    }
+
+    @Override
+    public <T> void visitEnd(Class<T> clazz, JavaImplementation type) throws IntrospectionException {
+        List<org.apache.tuscany.sca.assembly.Service> services = type.getServices();
+        if (services.isEmpty()) {
+            // heuristically determine the service
+            /**
+             * The following is quoted from Java Specification 1.2.1.3. Introspecting services offered by a Java implementation
+             * In the cases described below, the services offered by a Java implementation class may be determined
+             * through introspection, eliding the need to specify them using @Service. The following algorithm is used 
+             * to determine how services are introspected from an implementation class:
+             * 
+             * If the interfaces of the SCA services are not specified with the @Service annotation on the 
+             * implementation class, it is assumed that all implemented interfaces that have been annotated 
+             * as @Remotable are the service interfaces provided by the component. If none of the implemented 
+             * interfaces is remotable, then by default the implementation offers a single service whose type 
+             * is the implementation class.
+             */
+            Set<Class> interfaces = getAllInterfaces(clazz);
+            for (Class<?> i : interfaces) {
+                if (i.isAnnotationPresent(Remotable.class) || i.isAnnotationPresent(WebService.class)) {
+                    addService(type, i);
+                }
+            }
+            if (services.isEmpty()) {
+                // class is the interface
+                addService(type, clazz);
+            }
+        }
+        Set<Method> methods = getAllUniquePublicProtectedMethods(clazz, false);
+        if (!type.getReferenceMembers().isEmpty() || !type.getPropertyMembers().isEmpty()) {
+            // references and properties have been explicitly defined
+            //            if (type.getServices().isEmpty()) {
+            //                calculateServiceInterface(clazz, type, methods);
+            //                if (type.getServices().isEmpty()) {
+            //                    throw new ServiceTypeNotFoundException(clazz.getName());
+            //                }
+            //            }
+            evaluateConstructor(type, clazz);
+            return;
+        }
+        calcPropRefs(methods, services, type, clazz);
+        evaluateConstructor(type, clazz);
+    }
+
+    private void addService(JavaImplementation type, Class<?> clazz) throws IntrospectionException {
+        try {
+            org.apache.tuscany.sca.assembly.Service service = createService(clazz);
+            type.getServices().add(service);
+        } catch (InvalidInterfaceException e) {
+            throw new IntrospectionException(e);
+        }
+    }
+
+    private boolean isPublicSetter(Method method) {
+        return method.getParameterTypes().length == 1 && Modifier.isPublic(method.getModifiers())
+            && method.getName().startsWith("set")
+            && method.getReturnType() == void.class;
+    }
+
+    private boolean isProtectedSetter(Method method) {
+        return method.getParameterTypes().length == 1 && Modifier.isProtected(method.getModifiers())
+            && method.getName().startsWith("set")
+            && method.getReturnType() == void.class;
+    }
+
+    private <T> void calcPropRefs(Set<Method> methods,
+                                  List<org.apache.tuscany.sca.assembly.Service> services,
+                                  JavaImplementation type,
+                                  Class<T> clazz) throws IntrospectionException {
+        // heuristically determine the properties references
+        // make a first pass through all public methods with one param
+        Set<String> setters = new HashSet<String>();
+        Set<String> others = new HashSet<String>();
+        for (Method method : methods) {
+            if (!isPublicSetter(method)) {
+                continue;
+            }
+            if (method.isAnnotationPresent(Callback.class) || method.isAnnotationPresent(Context.class)) {
+                // Add the property name as others
+                others.add(toPropertyName(method.getName()));
+                continue;
+            }
+            if (!isInServiceInterface(method, services)) {
+                // Not part of the service interface
+                String name = toPropertyName(method.getName());
+                setters.add(name);
+                // avoid duplicate property or ref names
+                if (!type.getPropertyMembers().containsKey(name) && !type.getReferenceMembers().containsKey(name)) {
+                    Class<?> param = method.getParameterTypes()[0];
+                    Type genericType = method.getGenericParameterTypes()[0];
+                    if (isReferenceType(param, genericType)) {
+                        type.getReferences().add(createReference(name, param));
+                        type.getReferenceMembers().put(name, new JavaElementImpl(method, 0));
+                    } else {
+                        type.getProperties().add(createProperty(name, param));
+                        type.getPropertyMembers().put(name, new JavaElementImpl(method, 0));
+                    }
+                }
+            }
+        }
+        // second pass for protected methods with one param
+        for (Method method : methods) {
+            if (!isProtectedSetter(method)) {
+                continue;
+            }
+            if (method.isAnnotationPresent(Callback.class) || method.isAnnotationPresent(Context.class)) {
+                // Add the property name as others
+                others.add(toPropertyName(method.getName()));
+                continue;
+            }
+            Class<?> param = method.getParameterTypes()[0];
+            String name = toPropertyName(method.getName());
+            setters.add(name);
+            // avoid duplicate property or ref names
+            if (isReferenceType(param, method.getGenericParameterTypes()[0])) {
+                if (!type.getReferenceMembers().containsKey(name)) {
+                    type.getReferences().add(createReference(name, param));
+                    type.getReferenceMembers().put(name, new JavaElementImpl(method, 0));
+                }
+            } else {
+                if (!type.getPropertyMembers().containsKey(name)) {
+                    type.getProperties().add(createProperty(name, param));
+                    type.getPropertyMembers().put(name, new JavaElementImpl(method, 0));
+                }
+            }
+        }
+
+        // Public or protected fields unless there is a public or protected
+        // setter method
+        // for the same name
+        Set<Field> fields = getAllPublicAndProtectedFields(clazz, false);
+        for (Field field : fields) {
+            if (field.isAnnotationPresent(Callback.class) || field.isAnnotationPresent(Context.class)) {
+                continue;
+            }
+            if (setters.contains(field.getName()) || others.contains(field.getName())) {
+                continue;
+            }
+            String name = field.getName();
+            Class<?> paramType = field.getType();
+            if (isReferenceType(paramType, field.getGenericType())) {
+                if (!type.getReferenceMembers().containsKey(name)) {
+                    type.getReferences().add(createReference(name, paramType));
+                    type.getReferenceMembers().put(name, new JavaElementImpl(field));
+                }
+            } else {
+                if (!type.getPropertyMembers().containsKey(name)) {
+                    type.getProperties().add(createProperty(name, paramType));
+                    type.getPropertyMembers().put(name, new JavaElementImpl(field));
+                }
+            }
+        }
+    }
+
+    /**
+     * Determines the constructor to use based on the component type's
+     * references and properties
+     * 
+     * @param type the component type
+     * @param clazz the implementation class corresponding to the component type
+     * @throws NoConstructorException if no suitable constructor is found
+     * @throws AmbiguousConstructorException if the parameters of a constructor
+     *             cannot be unambiguously mapped to references and properties
+     */
+    @SuppressWarnings("unchecked")
+    private <T> void evaluateConstructor(JavaImplementation type, Class<T> clazz) throws IntrospectionException {
+        // determine constructor if one is not annotated
+        JavaConstructorImpl<?> definition = type.getConstructor();
+        Constructor constructor;
+        boolean explict = false;
+        if (definition != null && definition.getConstructor()
+            .isAnnotationPresent(org.osoa.sca.annotations.Constructor.class)) {
+            // the constructor was already defined explicitly
+            return;
+        } else if (definition != null) {
+            explict = true;
+            constructor = definition.getConstructor();
+        } else {
+            // no definition, heuristically determine constructor
+            Constructor[] constructors = clazz.getConstructors();
+            if (constructors.length == 0) {
+                throw new NoConstructorException("No public constructor for class");
+            } else if (constructors.length == 1) {
+                // Only one constructor, take it
+                constructor = constructors[0];
+            } else {
+                // FIXME multiple constructors, none yet done
+                Constructor<T> selected = null;
+                int sites = type.getPropertyMembers().size() + type.getReferenceMembers().size();
+                for (Constructor<T> ctor : constructors) {
+                    if (ctor.getParameterTypes().length == 0) {
+                        selected = ctor;
+                    }
+                    if (ctor.getParameterTypes().length == sites) {
+                        // TODO finish
+                        // selected = constructor;
+                        // select constructor
+                        // break;
+                    }
+                }
+                if (selected == null) {
+                    throw new NoConstructorException();
+                }
+                constructor = selected;
+                definition = type.getConstructors().get(selected);
+                type.setConstructor(definition);
+                // return;
+            }
+            definition = type.getConstructors().get(constructor);
+            type.setConstructor(definition);
+        }
+        JavaParameterImpl[] parameters = definition.getParameters();
+        if (parameters.length == 0) {
+            return;
+        }
+        Map<String, JavaElementImpl> props = type.getPropertyMembers();
+        Map<String, JavaElementImpl> refs = type.getReferenceMembers();
+        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<String, JavaElementImpl> props,
+                                Map<String, JavaElementImpl> 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<Class> set = new HashSet<Class>(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<JavaElementImpl> props, Collection<JavaElementImpl> 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<String, JavaElementImpl> props,
+                                            Map<String, JavaElementImpl> 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:
+     * <ol>
+     * <li>If its type is simple, then it is a property.
+     * <li>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.
+     *             <li>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.
+     *          </ol>
+     *          <p>
+     *          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<org.apache.tuscany.sca.assembly.Service> 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<? extends Annotation> 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<Class> set = new HashSet<Class>(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<? extends Annotation> annotType = annotation.annotationType();
+                if (annotType.equals(Property.class) || annotType.equals(Reference.class)
+                    || annotType.equals(Resource.class)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalCallbackReferenceException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalCallbackReferenceException.java
new file mode 100644
index 0000000000..9fe2fcd468
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalCallbackReferenceException.java
@@ -0,0 +1,40 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.reflect.Member;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Denotes an illegal use of {@link org.osoa.sca.annotations.Callback} on a reference
+ *
+ * @version $Rev$ $Date$
+ */
+public class IllegalCallbackReferenceException extends IntrospectionException {
+    private static final long serialVersionUID = -8932525723147700591L;
+
+    public IllegalCallbackReferenceException(String message) {
+        super(message);
+    }
+    
+    public IllegalCallbackReferenceException(String message, Member member) {
+        super(message, member);
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalContextException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalContextException.java
new file mode 100644
index 0000000000..f5696122df
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalContextException.java
@@ -0,0 +1,40 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.reflect.Member;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Denotes an illegal signature for a method decorated with {@link org.osoa.sca.annotations.Context}
+ *
+ * @version $Rev$ $Date$
+ */
+public class IllegalContextException extends IntrospectionException {
+    private static final long serialVersionUID = -6946383136750117008L;
+
+    public IllegalContextException(String message) {
+        super(message);
+    }
+
+    public IllegalContextException(String message, Member member) {
+        super(message, member);
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalDestructorException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalDestructorException.java
new file mode 100644
index 0000000000..6a0d60c92f
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalDestructorException.java
@@ -0,0 +1,40 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.reflect.Member;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Denotes an illegal signature for a method decorated with {@link org.osoa.sca.annotations.Destroy}
+ *
+ * @version $Rev$ $Date$
+ */
+public class IllegalDestructorException extends IntrospectionException {
+    private static final long serialVersionUID = 365719353107446326L;
+
+    public IllegalDestructorException(String message) {
+        super(message);
+    }
+    
+    public IllegalDestructorException(String message, Member member) {
+        super(message, member);
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalInitException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalInitException.java
new file mode 100644
index 0000000000..8f50852c2d
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalInitException.java
@@ -0,0 +1,40 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.reflect.Member;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Denotes an illegal signature for a method decorated with {@link @org.osoa.sca.annotations.Init}
+ *
+ * @version $Rev$ $Date$
+ */
+public class IllegalInitException extends IntrospectionException {
+    private static final long serialVersionUID = -3690763271986854701L;
+
+    public IllegalInitException(String message) {
+        super(message);
+    }
+
+    public IllegalInitException(String message, Member member) {
+        super(message, member);
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalPropertyException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalPropertyException.java
new file mode 100644
index 0000000000..54f7dfad1e
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalPropertyException.java
@@ -0,0 +1,40 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.reflect.Member;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Denotes an illegal property definition in a component type
+ * 
+ * @version $Rev$ $Date$
+ */
+public class IllegalPropertyException extends IntrospectionException {
+    private static final long serialVersionUID = -2836849110706758494L;
+
+    public IllegalPropertyException(String message) {
+        super(message);
+    }
+    
+    public IllegalPropertyException(String message, Member member) {
+        super(message, member);
+    }    
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalReferenceException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalReferenceException.java
new file mode 100644
index 0000000000..25196c56e5
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalReferenceException.java
@@ -0,0 +1,40 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.reflect.Member;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Denotes an illegal reference definition in a component type
+ *
+ * @version $Rev$ $Date$
+ */
+public class IllegalReferenceException extends IntrospectionException {
+    private static final long serialVersionUID = 4612984122225271395L;
+
+    public IllegalReferenceException(String message) {
+        super(message);
+    }
+    
+    public IllegalReferenceException(String message, Member member) {
+        super(message, member);
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalResourceException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalResourceException.java
new file mode 100644
index 0000000000..ccfbaf0043
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalResourceException.java
@@ -0,0 +1,40 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.reflect.Member;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Denotes an illegal resource definition in a component type
+ *
+ * @version $Rev$ $Date$
+ */
+public class IllegalResourceException extends IntrospectionException {
+    private static final long serialVersionUID = -1100936539412435579L;
+
+    public IllegalResourceException(String message) {
+        super(message);
+    }
+    
+    public IllegalResourceException(String message, Member member) {
+        super(message, member);
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalServiceDefinitionException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalServiceDefinitionException.java
new file mode 100644
index 0000000000..e130f4221d
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/IllegalServiceDefinitionException.java
@@ -0,0 +1,35 @@
+/*
+ * 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.java.introspect.impl;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Denotes an illegal use of the {@link @org.osoa.sca.annotations.Service} annotation
+ *
+ * @version $Rev$ $Date$
+ */
+public class IllegalServiceDefinitionException extends IntrospectionException {
+    private static final long serialVersionUID = -7151534258405092548L;
+
+    public IllegalServiceDefinitionException(String message) {
+        super(message);
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InitProcessor.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InitProcessor.java
new file mode 100644
index 0000000000..583ccc86cd
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InitProcessor.java
@@ -0,0 +1,61 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.osoa.sca.annotations.Init;
+
+/**
+ * Processes the {@link @Init} annotation on a component implementation and
+ * updates the component type with the decorated initializer method
+ * 
+ * @version $Rev$ $Date$
+ */
+public class InitProcessor extends BaseJavaClassVisitor {
+    
+    public InitProcessor(AssemblyFactory factory) {
+        super(factory);
+    }
+
+    @Override
+    public void visitMethod(Method method, JavaImplementation type) throws IntrospectionException {
+        Init annotation = method.getAnnotation(Init.class);
+        if (annotation == null) {
+            return;
+        }
+        if (method.getParameterTypes().length != 0) {
+            throw new IllegalInitException("Initializer must not have argments", method);
+        }
+        if(!method.getReturnType().equals(void.class)) {
+            throw new IllegalInitException("Initializer must return void.", method);
+        }
+        if (type.getInitMethod() != null) {
+            throw new DuplicateInitException("More than one initializer found on implementaton");
+        }
+        if (!Modifier.isPublic(method.getModifiers())) {
+            throw new IllegalInitException("Initializer must be a public method. Invalid annotation @Init found on "+method);
+        }
+        type.setInitMethod(method);
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InvalidConstructorException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InvalidConstructorException.java
new file mode 100644
index 0000000000..91b97b2caf
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InvalidConstructorException.java
@@ -0,0 +1,36 @@
+/*
+ * 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.java.introspect.impl;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Denotes an invalid constructor definition, e.g. when the number of injection names specified in {@link
+ * org.osoa.sca.annotations.Constructor} do not match the number of actual constructor parameters
+ *
+ * @version $Rev$ $Date$
+ */
+public class InvalidConstructorException extends IntrospectionException {
+    private static final long serialVersionUID = 1411492435210741512L;
+
+    public InvalidConstructorException(String message) {
+        super(message);
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InvalidConversationalImplementation.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InvalidConversationalImplementation.java
new file mode 100644
index 0000000000..a1e1d01ab3
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InvalidConversationalImplementation.java
@@ -0,0 +1,39 @@
+/*
+ * 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.java.introspect.impl;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Raised when an implementation specifies improper conversational metadata
+ *
+ * @version $Rev$ $Date$
+ */
+public class InvalidConversationalImplementation extends IntrospectionException {
+    private static final long serialVersionUID = -5487291552769408149L;
+
+    public InvalidConversationalImplementation(String message) {
+        super(message);
+    }
+
+    public InvalidConversationalImplementation(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InvalidPropertyException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InvalidPropertyException.java
new file mode 100644
index 0000000000..976b4da120
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InvalidPropertyException.java
@@ -0,0 +1,35 @@
+/*
+ * 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.java.introspect.impl;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Denotes an invalid usage of {@link org.osoa.sca.annotations.Property}
+ *
+ * @version $Rev$ $Date$
+ */
+public class InvalidPropertyException extends IntrospectionException {
+    private static final long serialVersionUID = -2682862652069727948L;
+
+    public InvalidPropertyException(String message) {
+        super(message);
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InvalidReferenceException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InvalidReferenceException.java
new file mode 100644
index 0000000000..e77a6beb0d
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InvalidReferenceException.java
@@ -0,0 +1,42 @@
+/*
+ * 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.java.introspect.impl;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Denotes an invalid usage of {@link org.osoa.sca.annotations.Reference}
+ *
+ * @version $Rev$ $Date$
+ */
+public class InvalidReferenceException extends IntrospectionException {
+    private static final long serialVersionUID = -3285246635989254165L;
+
+    public InvalidReferenceException(String message) {
+        super(message);
+    }
+
+    public InvalidReferenceException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public InvalidReferenceException(Throwable cause) {
+        super(cause);
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InvalidResourceException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InvalidResourceException.java
new file mode 100644
index 0000000000..debb5cbacc
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InvalidResourceException.java
@@ -0,0 +1,40 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.reflect.Member;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Denotes an invalid usage of {@link @org.apache.tuscany.api.annotation.Resource}
+ *
+ * @version $Rev$ $Date$
+ */
+public class InvalidResourceException extends IntrospectionException {
+    private static final long serialVersionUID = 511728001735534934L;
+
+    public InvalidResourceException(String message) {
+        super(message);
+    }
+    
+    public InvalidResourceException(String message, Member member) {
+        super(message, member);
+    }    
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InvalidServiceType.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InvalidServiceType.java
new file mode 100644
index 0000000000..7147da55b4
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/InvalidServiceType.java
@@ -0,0 +1,48 @@
+/*
+ * 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.java.introspect.impl;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Thrown when a service type specified by an {@link org.osoa.sca.annotations.Service} annotation is invalid, e.g. it is
+ * not an interface
+ *
+ * @version $Rev$ $Date$
+ */
+public class InvalidServiceType extends IntrospectionException {
+    private static final long serialVersionUID = -1076466639416644386L;
+    private Class<?> serviceType;
+
+    public InvalidServiceType(String message) {
+        super(message);
+    }
+    
+    public InvalidServiceType(String message, Class<?> clazz) {
+        super(message);
+        this.serviceType = clazz;
+    }
+
+    /**
+     * @return the serviceType
+     */
+    public Class<?> getServiceType() {
+        return serviceType;
+    }    
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/JavaIntrospectionHelper.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/JavaIntrospectionHelper.java
new file mode 100644
index 0000000000..6039bd91f8
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/JavaIntrospectionHelper.java
@@ -0,0 +1,577 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.beans.Introspector;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.logging.Logger;
+
+import org.osoa.sca.CallableReference;
+
+/**
+ * Implements various reflection-related operations
+ * 
+ * @version $Rev$ $Date$
+ */
+public final class JavaIntrospectionHelper {
+    private static final Logger logger = Logger.getLogger(JavaIntrospectionHelper.class.getName());
+    private static final Class[] EMPTY_CLASS_ARRY = new Class[0];
+
+    /**
+     * Hide the constructor
+     */
+    private JavaIntrospectionHelper() {
+    }
+
+    /**
+     * Returns a collection of public, and protected fields declared by a class
+     * or one of its supertypes
+     */
+    public static Set<Field> getAllPublicAndProtectedFields(Class clazz, boolean validating) {
+        return getAllPublicAndProtectedFields(clazz, new HashSet<Field>(), validating);
+    }
+
+    private static void checkInvalidAnnotations(AnnotatedElement element) {
+        for (Annotation a : element.getAnnotations()) {
+            if (a.annotationType().getName().startsWith("org.osoa.sca.annotations.")) {
+                logger.warning("Invalid annotation " + a + " is found on " + element);
+            }
+        }
+    }
+
+    /**
+     * Recursively evaluates the type hierarchy to return all fields that are
+     * public or protected
+     */
+    private static Set<Field> getAllPublicAndProtectedFields(Class clazz, Set<Field> fields, boolean validating) {
+        if (clazz == null || clazz.isArray() || Object.class.equals(clazz)) {
+            return fields;
+        }
+        fields = getAllPublicAndProtectedFields(clazz.getSuperclass(), fields, validating);
+        Field[] declaredFields = clazz.getDeclaredFields();
+        for (final Field field : declaredFields) {
+            int modifiers = field.getModifiers();
+            if ((Modifier.isPublic(modifiers) || Modifier.isProtected(modifiers)) && !Modifier.isStatic(modifiers)) {
+                // Allow privileged access to set accessibility. Requires ReflectPermission
+                // in security policy.
+                AccessController.doPrivileged(new PrivilegedAction<Object>() {
+                    public Object run() {
+                        field.setAccessible(true); // ignore Java accessibility
+                        return null;
+                    }
+                });
+                fields.add(field);
+            } else {
+                if (validating) {
+                    checkInvalidAnnotations(field);
+                }
+            }
+        }
+        return fields;
+    }
+
+    /**
+     * Returns a collection of public and protected methods declared by a class
+     * or one of its supertypes. Note that overridden methods will not be
+     * returned in the collection (i.e. only the method override will be). <p/>
+     * This method can potentially be expensive as reflection information is not
+     * cached. It is assumed that this method will be used during a
+     * configuration phase.
+     */
+    public static Set<Method> getAllUniquePublicProtectedMethods(Class clazz, boolean validating) {
+        return getAllUniqueMethods(clazz, new HashSet<Method>(), validating);
+    }
+
+    /**
+     * Recursively evaluates the type hierarchy to return all unique methods
+     */
+    private static Set<Method> getAllUniqueMethods(Class pClass, Set<Method> methods, boolean validating) {
+        if (pClass == null || pClass.isArray() || Object.class.equals(pClass)) {
+            return methods;
+        }
+        // we first evaluate methods of the subclass and then move to the parent
+        Method[] declaredMethods = pClass.getDeclaredMethods();
+        for (final Method declaredMethod : declaredMethods) {
+            int modifiers = declaredMethod.getModifiers();
+            if ((!Modifier.isPublic(modifiers) && !Modifier.isProtected(modifiers)) || Modifier.isStatic(modifiers)) {
+                if (validating) {
+                    checkInvalidAnnotations(declaredMethod);
+                }
+                continue;
+            }
+            if (methods.size() == 0) {
+                methods.add(declaredMethod);
+            } else {
+                List<Method> temp = new ArrayList<Method>();
+                boolean matched = false;
+                for (Method method : methods) {
+                    // only add if not already in the set from a superclass (i.e.
+                    // the method is not overridden)
+                    if (exactMethodMatch(declaredMethod, method)) {
+                        matched = true;
+                        break;
+                    }
+                }
+                if (!matched) {
+                    // Allow privileged access to set accessibility. Requires ReflectPermission
+                    // in security policy.
+                    AccessController.doPrivileged(new PrivilegedAction<Object>() {
+                        public Object run() {
+                            declaredMethod.setAccessible(true);
+                            return null;
+                        }
+                    });
+                    temp.add(declaredMethod);
+                }
+                methods.addAll(temp);
+                temp.clear();
+            }
+        }
+        // evaluate class hierarchy - this is done last to track inherited
+        // methods
+        methods = getAllUniqueMethods(pClass.getSuperclass(), methods, validating);
+        return methods;
+    }
+
+    /**
+     * Finds the closest matching field with the given name, that is, a field of
+     * the exact specified type or, alternately, of a supertype.
+     * 
+     * @param name the name of the field
+     * @param type the field type
+     * @param fields the collection of fields to search
+     * @return the matching field or null if not found
+     */
+    public static Field findClosestMatchingField(String name, Class type, Set<Field> fields) {
+        Field candidate = null;
+        for (Field field : fields) {
+            if (field.getName().equals(name)) {
+                if (field.getType().equals(type)) {
+                    return field; // exact match
+                } else if (field.getType().isAssignableFrom(type) || (field.getType().isPrimitive() && primitiveAssignable(field
+                                                                                                                               .getType(),
+                                                                                                                           type))) {
+                    // We could have the situation where a field parameter is a
+                    // primitive and the demarshalled value is
+                    // an object counterpart (e.g. Integer and int)
+                    // @spec issue
+                    // either an interface or super class, so keep a reference
+                    // until
+                    // we know there are no closer types
+                    candidate = field;
+                }
+            }
+        }
+        if (candidate != null) {
+            return candidate;
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Finds the closest matching method with the given name, that is, a method
+     * taking the exact parameter types or, alternately, parameter supertypes.
+     * 
+     * @param name the name of the method
+     * @param types the method parameter types
+     * @param methods the collection of methods to search
+     * @return the matching method or null if not found
+     */
+    public static Method findClosestMatchingMethod(String name, Class[] types, Set<Method> methods) {
+        if (types == null) {
+            types = EMPTY_CLASS_ARRY;
+        }
+        Method candidate = null;
+        for (Method method : methods) {
+            if (method.getName().equals(name) && method.getParameterTypes().length == types.length) {
+                Class<?>[] params = method.getParameterTypes();
+                boolean disqualify = false;
+                boolean exactMatch = true;
+                for (int i = 0; i < params.length; i++) {
+                    if (!params[i].equals(types[i]) && !params[i].isAssignableFrom(types[i])) {
+                        // no match
+                        disqualify = true;
+                        exactMatch = false;
+                        break;
+                    } else if (!params[i].equals(types[i]) && params[i].isAssignableFrom(types[i])) {
+                        // not exact match
+                        exactMatch = false;
+                    }
+                }
+                if (disqualify) {
+                    continue;
+                } else if (exactMatch) {
+                    return method;
+                } else {
+                    candidate = method;
+                }
+            }
+        }
+        if (candidate != null) {
+            return candidate;
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Determines if two methods "match" - that is, they have the same method
+     * names and exact parameter types (one is not a supertype of the other)
+     */
+    public static boolean exactMethodMatch(Method method1, Method method2) {
+        if (!method1.getName().equals(method2.getName())) {
+            return false;
+        }
+        Class<?>[] types1 = method1.getParameterTypes();
+        Class<?>[] types2 = method2.getParameterTypes();
+        if (types1.length != types2.length) {
+            return false;
+        }
+        boolean matched = true;
+        for (int i = 0; i < types1.length; i++) {
+            if (types1[i] != types2[i]) {
+                matched = false;
+                break;
+            }
+        }
+        return matched;
+    }
+
+    public static <T> Constructor<T> getDefaultConstructor(Class<T> clazz) throws NoSuchMethodException {
+        return clazz.getConstructor((Class[])null);
+    }
+
+    /**
+     * Returns the simple name of a class - i.e. the class name devoid of its
+     * package qualifier
+     * 
+     * @param implClass the implementation class
+     */
+    public static String getBaseName(Class<?> implClass) {
+        return implClass.getSimpleName();
+    }
+
+    public static boolean isImmutable(Class clazz) {
+        return String.class == clazz || clazz.isPrimitive()
+            || Number.class.isAssignableFrom(clazz)
+            || Boolean.class.isAssignableFrom(clazz)
+            || Character.class.isAssignableFrom(clazz)
+            || Byte.class.isAssignableFrom(clazz);
+    }
+
+    /**
+     * Takes a property name and converts it to a getter method name according
+     * to JavaBean conventions. For example, property
+     * <code>foo<code> is returned as <code>getFoo</code>
+     */
+    public static String toGetter(String name) {
+        return "get" + name.toUpperCase().substring(0, 1) + name.substring(1);
+    }
+
+    /**
+     * Takes a setter or getter method name and converts it to a property name
+     * according to JavaBean conventions. For example, <code>setFoo(var)</code>
+     * is returned as property <code>foo<code>
+     */
+    public static String toPropertyName(String name) {
+        if (!name.startsWith("set")) {
+            return name;
+        }
+        return Introspector.decapitalize(name.substring(3));
+    }
+
+    public static Class<?> getErasure(Type type) {
+        if (type instanceof Class) {
+            return (Class)type;
+        } else if (type instanceof GenericArrayType) {
+            // FIXME: How to deal with the []?
+            GenericArrayType arrayType = (GenericArrayType)type;
+            return getErasure(arrayType.getGenericComponentType());
+        } else if (type instanceof ParameterizedType) {
+            ParameterizedType pType = (ParameterizedType)type;
+            return getErasure(pType.getRawType());
+        } else if (type instanceof WildcardType) {
+            WildcardType wType = (WildcardType)type;
+            Type[] types = wType.getUpperBounds();
+            return getErasure(types[0]);
+        } else if (type instanceof TypeVariable) {
+            TypeVariable var = (TypeVariable)type;
+            Type[] types = var.getBounds();
+            return getErasure(types[0]);
+        }
+        return null;
+    }
+
+    public static Class<?> getBaseType(Class<?> cls, Type genericType) {
+        if (cls.isArray()) {
+            return cls.getComponentType();
+        } else if (Collection.class.isAssignableFrom(cls)) {
+            if (genericType instanceof ParameterizedType) {
+                // Collection<BaseType>
+                ParameterizedType parameterizedType = (ParameterizedType)genericType;
+                Type baseType = parameterizedType.getActualTypeArguments()[0];
+                if (baseType instanceof GenericArrayType) {
+                    // Base is array
+                    return cls;
+                } else {
+                    return getErasure(baseType);
+                }
+            } else {
+                return cls;
+            }
+        } else {
+            return cls;
+        }
+    }
+
+    public static Type getParameterType(Type type) {
+        if (type instanceof ParameterizedType) {
+            // Collection<BaseType>
+            ParameterizedType parameterizedType = (ParameterizedType)type;
+            Type baseType = parameterizedType.getActualTypeArguments()[0];
+            return baseType;
+        } else {
+            return Object.class;
+        }
+    }
+
+    public static Class<?> getBusinessInterface(Class<?> cls, Type callableReferenceType) {
+        if (CallableReference.class.isAssignableFrom(cls) && callableReferenceType instanceof ParameterizedType) {
+            // Collection<BaseType>
+            ParameterizedType parameterizedType = (ParameterizedType)callableReferenceType;
+            Type baseType = parameterizedType.getActualTypeArguments()[0];
+            if (baseType instanceof GenericArrayType) {
+                // Base is array
+                return cls;
+            } else {
+                return getErasure(baseType);
+            }
+        }
+        return Object.class;
+    }
+
+    /**
+     * Takes a property name and converts it to a setter method name according
+     * to JavaBean conventions. For example, the property
+     * <code>foo<code> is returned as <code>setFoo(var)</code>
+     */
+    public static String toSetter(String name) {
+        return "set" + name.toUpperCase().substring(0, 1) + name.substring(1);
+    }
+
+    /**
+     * Compares a two types, assuming one is a primitive, to determine if the
+     * other is its object counterpart
+     */
+    private static boolean primitiveAssignable(Class memberType, Class param) {
+        if (memberType == Integer.class) {
+            return param == Integer.TYPE;
+        } else if (memberType == Double.class) {
+            return param == Double.TYPE;
+        } else if (memberType == Float.class) {
+            return param == Float.TYPE;
+        } else if (memberType == Short.class) {
+            return param == Short.TYPE;
+        } else if (memberType == Character.class) {
+            return param == Character.TYPE;
+        } else if (memberType == Boolean.class) {
+            return param == Boolean.TYPE;
+        } else if (memberType == Byte.class) {
+            return param == Byte.TYPE;
+        } else if (param == Integer.class) {
+            return memberType == Integer.TYPE;
+        } else if (param == Double.class) {
+            return memberType == Double.TYPE;
+        } else if (param == Float.class) {
+            return memberType == Float.TYPE;
+        } else if (param == Short.class) {
+            return memberType == Short.TYPE;
+        } else if (param == Character.class) {
+            return memberType == Character.TYPE;
+        } else if (param == Boolean.class) {
+            return memberType == Boolean.TYPE;
+        } else if (param == Byte.class) {
+            return memberType == Byte.TYPE;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Returns the generic types represented in the given type. Usage as
+     * follows: <code>
+     * JavaIntrospectionHelper.getGenerics(field.getGenericType());
+     * <p/>
+     * JavaIntrospectionHelper.getGenerics(m.getGenericParameterTypes()[0];); </code>
+     * 
+     * @return the generic types in order of declaration or an empty array if
+     *         the type is not genericized
+     */
+    public static List<? extends Type> getGenerics(Type genericType) {
+        List<Type> classes = new ArrayList<Type>();
+        if (genericType instanceof ParameterizedType) {
+            ParameterizedType ptype = (ParameterizedType)genericType;
+            // get the type arguments
+            Type[] targs = ptype.getActualTypeArguments();
+            for (Type targ : targs) {
+                classes.add(targ);
+            }
+        }
+        return classes;
+    }
+
+    /**
+     * Returns the generic type specified by the class at the given position as
+     * in: <p/> <code> public class Foo<Bar,Baz>{ //.. }
+     * <p/>
+     * JavaIntrospectionHelper.introspectGeneric(Foo.class,1); <code>
+     * <p/>
+     * will return Baz.
+     */
+    public static Class introspectGeneric(Class<?> clazz, int pos) {
+        assert clazz != null : "No class specified";
+        Type type = clazz.getGenericSuperclass();
+        if (type instanceof ParameterizedType) {
+            Type[] args = ((ParameterizedType)type).getActualTypeArguments();
+            if (args.length <= pos) {
+                throw new IllegalArgumentException("Invalid index value for generic class " + clazz.getName());
+            }
+            return (Class)((ParameterizedType)type).getActualTypeArguments()[pos];
+        } else {
+            Type[] interfaces = clazz.getGenericInterfaces();
+            for (Type itype : interfaces) {
+                if (!(itype instanceof ParameterizedType)) {
+                    continue;
+                }
+                ParameterizedType interfaceType = (ParameterizedType)itype;
+                return (Class)interfaceType.getActualTypeArguments()[0];
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Returns the set of interfaces implemented by the given class and its
+     * ancestors or a blank set if none
+     */
+    public static Set<Class> getAllInterfaces(Class clazz) {
+        Set<Class> implemented = new HashSet<Class>();
+        getAllInterfaces(clazz, implemented);
+        return implemented;
+    }
+
+    private static void getAllInterfaces(Class clazz, Set<Class> implemented) {
+        Class[] interfaces = clazz.getInterfaces();
+        for (Class interfaze : interfaces) {
+            implemented.add(interfaze);
+        }
+        Class<?> superClass = clazz.getSuperclass();
+        // Object has no superclass so check for null
+        if (superClass != null && !superClass.equals(Object.class)) {
+            getAllInterfaces(superClass, implemented);
+        }
+    }
+
+    public static boolean isSetter(Method method) {
+        return (void.class == method.getReturnType() && method.getParameterTypes().length == 1 && method.getName()
+            .startsWith("set"));
+    }
+
+    public static boolean isGetter(Method method) {
+        return (void.class != method.getReturnType() && method.getParameterTypes().length == 0 && method.getName()
+            .startsWith("get"));
+    }
+
+    private final static Map<Class, String> signatures = new HashMap<Class, String>();
+    static {
+        signatures.put(boolean.class, "Z");
+        signatures.put(byte.class, "B");
+        signatures.put(char.class, "C");
+        signatures.put(short.class, "S");
+        signatures.put(int.class, "I");
+        signatures.put(long.class, "J");
+        signatures.put(float.class, "F");
+        signatures.put(double.class, "D");
+    };
+
+    public static String getSignature(Class<?> cls) {
+        if (cls.isPrimitive()) {
+            return signatures.get(cls);
+        }
+        if (cls.isArray()) {
+            return "[" + getSignature(cls.getComponentType());
+        }
+        return "L" + cls.getName().replace('.', '/') + ";";
+    }
+
+    public static Class<?> getArrayType(Class<?> componentType, int dims) throws ClassNotFoundException {
+        StringBuffer buf = new StringBuffer();
+        for (int i = 0; i < dims; i++) {
+            buf.append('[');
+        }
+        buf.append(getSignature(componentType));
+        return Class.forName(buf.toString(), false, componentType.getClassLoader());
+    }
+
+    public static Set<Method> getPrivateMethods(Class clazz) {
+        Set<Method> methods = new HashSet<Method>();
+        Method[] declaredMethods = clazz.getDeclaredMethods();
+        for (final Method declaredMethod : declaredMethods) {
+            int modifiers = declaredMethod.getModifiers();
+            if(Modifier.isPrivate(modifiers)) {
+                methods.add(declaredMethod);
+            }
+        }
+        
+        return methods;
+    }
+
+    public static Set<Field> getPrivateFields(Class clazz) {
+        Set<Field> fields = new HashSet<Field>();
+        Field[] declaredFields = clazz.getDeclaredFields();
+        for (final Field declaredField : declaredFields) {
+            int modifiers = declaredField.getModifiers();
+            if(Modifier.isPrivate(modifiers)) {
+                fields.add(declaredField);
+            }
+        }
+        
+        return fields;
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/NoConstructorException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/NoConstructorException.java
new file mode 100644
index 0000000000..453cfa35fe
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/NoConstructorException.java
@@ -0,0 +1,37 @@
+/*
+ * 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.java.introspect.impl;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Thrown when a suitable constructor for a component implementation cannot be found
+ *
+ * @version $Rev$ $Date$
+ */
+public class NoConstructorException extends IntrospectionException {
+    private static final long serialVersionUID = 3086706387280694424L;
+    
+    public NoConstructorException() {
+    }
+    
+    public NoConstructorException(String message) {
+       super(message);
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/PolicyProcessor.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/PolicyProcessor.java
new file mode 100644
index 0000000000..954a3abbc8
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/PolicyProcessor.java
@@ -0,0 +1,292 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.List;
+
+import javax.xml.namespace.QName;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.Callback;
+import org.apache.tuscany.sca.assembly.ConfiguredOperation;
+import org.apache.tuscany.sca.assembly.OperationsConfigurator;
+import org.apache.tuscany.sca.assembly.Reference;
+import org.apache.tuscany.sca.assembly.Service;
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.apache.tuscany.sca.interfacedef.InterfaceContract;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterface;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceContract;
+import org.apache.tuscany.sca.policy.Intent;
+import org.apache.tuscany.sca.policy.PolicyFactory;
+import org.apache.tuscany.sca.policy.PolicySet;
+import org.apache.tuscany.sca.policy.PolicySetAttachPoint;
+import org.osoa.sca.annotations.PolicySets;
+import org.osoa.sca.annotations.Requires;
+
+/**
+ * Processes an {@link org.osoa.sca.annotations.Requires} annotation
+ *
+ * @version $Rev$ $Date$
+ */
+public class PolicyProcessor extends BaseJavaClassVisitor {
+    
+    private PolicyFactory policyFactory;
+
+    public PolicyProcessor(AssemblyFactory assemblyFactory, PolicyFactory policyFactory) {
+        super(assemblyFactory);
+        this.policyFactory = policyFactory;
+    }
+
+    private QName getQName(String intentName) {
+        QName qname;
+        if (intentName.startsWith("{")) {
+            int i = intentName.indexOf('}');
+            if (i != -1) {
+                qname = new QName(intentName.substring(1, i), intentName.substring(i + 1));
+            } else {
+                qname = new QName("", intentName);
+            }
+        } else {
+            qname = new QName("", intentName);
+        }
+        return qname;
+    }
+
+    /**
+     * Read policy intents on the given interface or class 
+     * @param clazz
+     * @param requiredIntents
+     */
+    private void readIntentsAndPolicySets(Class<?> clazz, 
+                                          List<Intent> requiredIntents, 
+                                          List<PolicySet> policySets) {
+        Requires intentAnnotation = clazz.getAnnotation(Requires.class);
+        if (intentAnnotation != null) {
+            String[] intentNames = intentAnnotation.value();
+            if (intentNames.length != 0) {
+                for (String intentName : intentNames) {
+
+                    // Add each intent to the list
+                    Intent intent = policyFactory.createIntent();
+                    intent.setName(getQName(intentName));
+                    requiredIntents.add(intent);
+                }
+            }
+        }
+        
+        PolicySets policySetAnnotation = clazz.getAnnotation(PolicySets.class);
+        if (policySetAnnotation != null) {
+            String[] policySetNames = policySetAnnotation.value();
+            if (policySetNames.length != 0) {
+                for (String policySetName : policySetNames) {
+
+                    // Add each intent to the list
+                    PolicySet policySet = policyFactory.createPolicySet();
+                    policySet.setName(getQName(policySetName));
+                    policySets.add(policySet);
+                }
+            }
+        }
+    }
+    
+    private void readIntents(Requires intentAnnotation, List<Intent> requiredIntents) {
+        //Requires intentAnnotation = method.getAnnotation(Requires.class);
+        if (intentAnnotation != null) {
+            String[] intentNames = intentAnnotation.value();
+            if (intentNames.length != 0) {
+                //Operation operation = assemblyFactory.createOperation();
+                //operation.setName(method.getName());
+                //operation.setUnresolved(true);
+                for (String intentName : intentNames) {
+
+                    // Add each intent to the list, associated with the
+                    // operation corresponding to the annotated method
+                    Intent intent = policyFactory.createIntent();
+                    intent.setName(getQName(intentName));
+                    //intent.getOperations().add(operation);
+                    requiredIntents.add(intent);
+                }
+            }
+        }
+    }
+    
+    private void readPolicySets(PolicySets policySetAnnotation, List<PolicySet> policySets) {
+        if (policySetAnnotation != null) {
+            String[] policySetNames = policySetAnnotation.value();
+            if (policySetNames.length != 0) {
+                //Operation operation = assemblyFactory.createOperation();
+                //operation.setName(method.getName());
+                //operation.setUnresolved(true);
+                for (String policySetName : policySetNames) {
+                    // Add each intent to the list, associated with the
+                    // operation corresponding to the annotated method
+                    PolicySet policySet = policyFactory.createPolicySet();
+                    policySet.setName(getQName(policySetName));
+                    //intent.getOperations().add(operation);
+                    policySets.add(policySet);
+                }
+            }
+        }
+    }
+
+    @Override
+    public <T> void visitClass(Class<T> clazz, JavaImplementation type) throws IntrospectionException {
+        
+        // Read intents on the Java implementation class
+        if ( type instanceof PolicySetAttachPoint ) {
+            readIntentsAndPolicySets(clazz, 
+                                     ((PolicySetAttachPoint)type).getRequiredIntents(),
+                                     ((PolicySetAttachPoint)type).getPolicySets());
+        }
+        
+        // Process annotations on the service interfaces
+        //TODO This will have to move to a JavaInterface introspector later
+        for (Service service: type.getServices()) {
+            InterfaceContract interfaceContract = service.getInterfaceContract();
+            if (interfaceContract instanceof JavaInterfaceContract) {
+                JavaInterfaceContract javaInterfaceContract = (JavaInterfaceContract)interfaceContract;
+
+                // Read intents on the service interface
+                if (javaInterfaceContract.getInterface() != null) {
+                    JavaInterface javaInterface = (JavaInterface)javaInterfaceContract.getInterface();
+                    if (javaInterface.getJavaClass() != null) {
+                        readIntentsAndPolicySets(javaInterface.getJavaClass(), 
+                                                 service.getRequiredIntents(),
+                                                 service.getPolicySets());
+
+                        // Read intents on the service interface methods 
+                        Method[] methods = javaInterface.getJavaClass().getMethods();
+                        ConfiguredOperation confOp = null;
+                        for (Method method: methods) {
+                            if ( method.getAnnotation(Requires.class) != null  ||    
+                                method.getAnnotation(PolicySets.class) != null ) {
+                                confOp = assemblyFactory.createConfiguredOperation();
+                                confOp.setName(method.getName());
+                                confOp.setContractName(service.getName());
+                            
+                                service.getConfiguredOperations().add(confOp);
+                                readIntents(method.getAnnotation(Requires.class), confOp.getRequiredIntents());
+                                readPolicySets(method.getAnnotation(PolicySets.class), confOp.getPolicySets());
+                            }
+                        }
+                    }
+                    
+                }
+                
+                // Read intents on the callback interface 
+                if (javaInterfaceContract.getCallbackInterface() != null) {
+                    JavaInterface javaCallbackInterface = (JavaInterface)javaInterfaceContract.getCallbackInterface();
+                    if (javaCallbackInterface.getJavaClass() != null) {
+                        Callback callback = service.getCallback();
+                        if (callback == null) {
+                            callback = assemblyFactory.createCallback();
+                            service.setCallback(callback);
+                        }
+                        readIntentsAndPolicySets(javaCallbackInterface.getJavaClass(), 
+                                                 callback.getRequiredIntents(),
+                                                 callback.getPolicySets());
+
+                        // Read intents on the callback interface methods 
+                        Method[] methods = javaCallbackInterface.getJavaClass().getMethods();
+                        ConfiguredOperation confOp = null;
+                        for (Method method: methods) {
+                            confOp = assemblyFactory.createConfiguredOperation();
+                            confOp.setName(method.getName());
+                            callback.getConfiguredOperations().add(confOp);
+                            readIntents(method.getAnnotation(Requires.class), confOp.getRequiredIntents());
+                            readPolicySets(method.getAnnotation(PolicySets.class), confOp.getPolicySets());
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private Reference getReference(Method method, JavaImplementation type) {
+        //since the ReferenceProcessor is called ahead of the PolicyProcessor the type should have
+        //picked up the reference setter method
+        org.osoa.sca.annotations.Reference annotation = 
+                                        method.getAnnotation(org.osoa.sca.annotations.Reference.class);
+        if (annotation != null) {
+            if (JavaIntrospectionHelper.isSetter(method)) {
+                String name = annotation.name();
+                if ("".equals(name)) {
+                    name = JavaIntrospectionHelper.toPropertyName(method.getName());
+                }
+                return getReferenceByName(name, type);
+            }
+        }
+        return null;
+    }
+    
+    private Reference getReferenceByName(String name, JavaImplementation type) {
+        for ( Reference reference : type.getReferences() ) {
+            if ( reference.getName().equals(name) ) {
+                return reference;
+            }
+        }
+        return null;
+    }
+    
+    @Override
+    public void visitField(Field field, JavaImplementation type) throws IntrospectionException {
+        org.osoa.sca.annotations.Reference annotation = 
+            field.getAnnotation( org.osoa.sca.annotations.Reference.class);
+        if (annotation == null) {
+            return;
+        }
+        String name = annotation.name();
+        if ("".equals(name)) {
+            name = field.getName();
+        }
+        
+        Reference reference = null;
+        if ( (reference = getReferenceByName(name, type)) != null ) {
+            readIntents(field.getAnnotation(Requires.class), reference.getRequiredIntents());
+            readPolicySets(field.getAnnotation(PolicySets.class), reference.getPolicySets());
+        }
+    }
+
+    @Override
+    public void visitMethod(Method method, JavaImplementation type) throws IntrospectionException {
+        Reference reference = null;
+        if ( (reference = getReference(method, type)) != null ) {
+            readIntents(method.getAnnotation(Requires.class), reference.getRequiredIntents());
+            readPolicySets(method.getAnnotation(PolicySets.class), reference.getPolicySets());
+        } else {
+            if ( type instanceof OperationsConfigurator ) {
+                //Read the intents specified on the given implementation method
+                if ( (method.getAnnotation(Requires.class) != null || 
+                        method.getAnnotation(PolicySets.class) != null ) && 
+                            (type instanceof PolicySetAttachPoint )) {
+                    ConfiguredOperation confOp = assemblyFactory.createConfiguredOperation();
+                    confOp.setName(method.getName());
+                    ((OperationsConfigurator)type).getConfiguredOperations().add(confOp);
+            
+                
+                    readIntents(method.getAnnotation(Requires.class), confOp.getRequiredIntents());
+                    readPolicySets(method.getAnnotation(PolicySets.class), confOp.getPolicySets());
+                }
+            }
+        }
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/PropertyProcessor.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/PropertyProcessor.java
new file mode 100644
index 0000000000..cf1b4a9830
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/PropertyProcessor.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.sca.implementation.java.introspect.impl;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.osoa.sca.annotations.Property;
+
+/**
+ * Processes an {@link @Property} annotation, updating the component type with
+ * corresponding {@link JavaMappedProperty}
+ * 
+ * @version $Rev$ $Date$
+ */
+public class PropertyProcessor extends AbstractPropertyProcessor<Property> {
+
+    public PropertyProcessor(AssemblyFactory assemblyFactory) {
+        super(assemblyFactory, Property.class);
+    }
+
+    @Override
+    protected String getName(Property annotation) {
+        return annotation.name();
+    }
+
+    @Override
+    protected void initProperty(org.apache.tuscany.sca.assembly.Property property, Property annotation) {
+        property.setMustSupply(annotation.required());
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ReferenceProcessor.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ReferenceProcessor.java
new file mode 100644
index 0000000000..a1f8a766ae
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ReferenceProcessor.java
@@ -0,0 +1,208 @@
+/*
+ * 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.java.introspect.impl;
+
+import static org.apache.tuscany.sca.implementation.java.introspect.impl.JavaIntrospectionHelper.getBaseType;
+
+import java.lang.annotation.ElementType;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.util.Collection;
+import java.util.List;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.Multiplicity;
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.apache.tuscany.sca.implementation.java.impl.JavaElementImpl;
+import org.apache.tuscany.sca.implementation.java.impl.JavaParameterImpl;
+import org.apache.tuscany.sca.interfacedef.InvalidInterfaceException;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterface;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceContract;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory;
+import org.osoa.sca.CallableReference;
+import org.osoa.sca.annotations.Reference;
+
+/**
+ * Processes an {@link @Reference} annotation, updating the component type with
+ * corresponding {@link
+ * org.apache.tuscany.spi.implementation.java.JavaMappedReference}
+ * 
+ * @version $Rev$ $Date$
+ */
+public class ReferenceProcessor extends BaseJavaClassVisitor {
+    private JavaInterfaceFactory javaFactory;
+
+    public ReferenceProcessor(AssemblyFactory assemblyFactory, JavaInterfaceFactory javaFactory) {
+        super(assemblyFactory);
+        this.javaFactory = javaFactory;
+    }
+
+    @Override
+    public void visitMethod(Method method, JavaImplementation type) throws IntrospectionException {
+        Reference annotation = method.getAnnotation(Reference.class);
+        if (annotation == null) {
+            return; // Not a reference annotation.
+        }
+        if (!JavaIntrospectionHelper.isSetter(method)) {
+            throw new IllegalReferenceException("Annotated method is not a setter: " + method, method);
+        }
+        String name = annotation.name();
+        if ("".equals(name)) {
+            name = JavaIntrospectionHelper.toPropertyName(method.getName());
+        }
+        JavaElementImpl ref = type.getReferenceMembers().get(name);
+        // Setter override field
+        if (ref != null && ref.getElementType() != ElementType.FIELD) {
+            throw new DuplicateReferenceException(name);
+        }
+        removeReference(ref, type);
+
+        JavaElementImpl element = new JavaElementImpl(method, 0);
+        org.apache.tuscany.sca.assembly.Reference reference = createReference(element, name);
+        type.getReferences().add(reference);
+        type.getReferenceMembers().put(name, element);
+    }
+
+    private boolean removeReference(JavaElementImpl ref, JavaImplementation type) {
+        if (ref == null) {
+            return false;
+        }
+        List<org.apache.tuscany.sca.assembly.Reference> refs = type.getReferences();
+        for (int i = 0; i < refs.size(); i++) {
+            if (refs.get(i).getName().equals(ref.getName())) {
+                refs.remove(i);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void visitField(Field field, JavaImplementation type) throws IntrospectionException {
+        Reference annotation = field.getAnnotation(Reference.class);
+        if (annotation == null) {
+            return;
+        }
+        String name = annotation.name();
+        if ("".equals(name)) {
+            name = field.getName();
+        }
+        JavaElementImpl ref = type.getReferenceMembers().get(name);
+        if (ref != null && ref.getElementType() == ElementType.FIELD) {
+            throw new DuplicateReferenceException(name);
+        }
+
+        // Setter method override field
+        if (ref == null) {
+            JavaElementImpl element = new JavaElementImpl(field);
+            org.apache.tuscany.sca.assembly.Reference reference = createReference(element, name);
+            type.getReferences().add(reference);
+            type.getReferenceMembers().put(name, element);
+        }
+    }
+
+    @Override
+    public void visitConstructorParameter(JavaParameterImpl parameter, JavaImplementation type)
+        throws IntrospectionException {
+        Reference refAnnotation = parameter.getAnnotation(Reference.class);
+        if (refAnnotation == null) {
+            return;
+        }
+        String paramName = parameter.getName();
+        String name = getReferenceName(paramName, parameter.getIndex(), refAnnotation.name());
+        JavaElementImpl ref = type.getReferenceMembers().get(name);
+
+        // Setter override field
+        if (ref != null && ref.getElementType() != ElementType.FIELD) {
+            throw new DuplicateReferenceException(name);
+        }
+
+        removeReference(ref, type);
+        org.apache.tuscany.sca.assembly.Reference reference = createReference(parameter, name);
+        type.getReferences().add(reference);
+        type.getReferenceMembers().put(name, parameter);
+        parameter.setClassifer(Reference.class);
+        parameter.setName(name);
+    }
+
+    private String getReferenceName(String paramName, int pos, String name) throws InvalidConstructorException {
+        if ("".equals(name)) {
+            name = paramName;
+        }
+        if ("".equals(name)) {
+            return "_ref" + pos;
+        }
+        if (!"".equals(paramName) && !name.equals(paramName)) {
+            throw new InvalidConstructorException("Mismatching names specified for reference parameter " + pos);
+        } else {
+            return name;
+        }
+    }
+
+    private org.apache.tuscany.sca.assembly.Reference createReference(JavaElementImpl element, String name)
+        throws IntrospectionException {
+        org.apache.tuscany.sca.assembly.Reference reference = assemblyFactory.createReference();
+        JavaInterfaceContract interfaceContract = javaFactory.createJavaInterfaceContract();
+        reference.setInterfaceContract(interfaceContract);
+
+        // reference.setMember((Member)element.getAnchor());
+        boolean required = true;
+        Reference ref = element.getAnnotation(Reference.class);
+        if (ref != null) {
+            required = ref.required();
+        }
+        // reference.setRequired(required);
+        reference.setName(name);
+        Class<?> rawType = element.getType();
+        if (rawType.isArray() || Collection.class.isAssignableFrom(rawType)) {
+            if (required) {
+                reference.setMultiplicity(Multiplicity.ONE_N);
+            } else {
+                reference.setMultiplicity(Multiplicity.ZERO_N);
+            }
+        } else {
+            if (required) {
+                reference.setMultiplicity(Multiplicity.ONE_ONE);
+            } else {
+                reference.setMultiplicity(Multiplicity.ZERO_ONE);
+            }
+        }
+        Type genericType = element.getGenericType();
+        Class<?> baseType = getBaseType(rawType, genericType);
+        if (CallableReference.class.isAssignableFrom(baseType)) {
+            if (Collection.class.isAssignableFrom(rawType)) {
+                genericType = JavaIntrospectionHelper.getParameterType(genericType);
+            }
+            baseType = JavaIntrospectionHelper.getBusinessInterface(baseType, genericType);
+        }
+        try {
+            JavaInterface callInterface = javaFactory.createJavaInterface(baseType);
+            reference.getInterfaceContract().setInterface(callInterface);
+            if (callInterface.getCallbackClass() != null) {
+                JavaInterface callbackInterface = javaFactory.createJavaInterface(callInterface.getCallbackClass());
+                reference.getInterfaceContract().setCallbackInterface(callbackInterface);
+            }
+        } catch (InvalidInterfaceException e) {
+            throw new IntrospectionException(e);
+        }
+        return reference;
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/Resource.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/Resource.java
new file mode 100644
index 0000000000..3d43e39ce8
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/Resource.java
@@ -0,0 +1,49 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation used to indicate a resource should be provided to an implementation by the runtime.
+ *
+ * @version $Rev$ $Date$
+ */
+@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Resource {
+
+    /**
+     * Denotes the name of the resource declared by the implementation.
+     */
+    String name() default "";
+
+    /**
+     * Denotes if the resource is optional
+     */
+    boolean optional() default false;
+
+    /**
+     * Denotes the default name of the resource provided by the runtime environment.
+     */
+    String mappedName() default "";
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ResourceProcessor.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ResourceProcessor.java
new file mode 100644
index 0000000000..e15f9a0d6a
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ResourceProcessor.java
@@ -0,0 +1,137 @@
+/*
+ * 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.java.introspect.impl;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.apache.tuscany.sca.implementation.java.impl.JavaElementImpl;
+import org.apache.tuscany.sca.implementation.java.impl.JavaParameterImpl;
+import org.apache.tuscany.sca.implementation.java.impl.JavaResourceImpl;
+
+/**
+ * Processes an {@link @Resource} annotation, updating the component type with
+ * corresponding {@link org.apache.tuscany.spi.implementation.java.JavaResourceImpl}
+ * 
+ * @version $Rev$ $Date$
+ */
+public class ResourceProcessor extends BaseJavaClassVisitor {
+    
+    public ResourceProcessor(AssemblyFactory factory) {
+        super(factory);
+    }
+
+    @Override
+    public void visitMethod(Method method, JavaImplementation type) throws IntrospectionException {
+        org.apache.tuscany.sca.implementation.java.introspect.impl.Resource annotation = method
+            .getAnnotation(org.apache.tuscany.sca.implementation.java.introspect.impl.Resource.class);
+        if (annotation == null) {
+            return;
+        }
+        if (method.getParameterTypes().length != 1) {
+            throw new IllegalResourceException("Resource setter must have one parameter", method);
+        }
+        String name = annotation.name();
+        if (name.length() < 1) {
+            name = JavaIntrospectionHelper.toPropertyName(method.getName());
+        }
+        if (type.getResources().get(name) != null) {
+            throw new DuplicateResourceException(name);
+        }
+
+        String mappedName = annotation.mappedName();
+        JavaResourceImpl resource = createResource(name, new JavaElementImpl(method, 0));
+        resource.setOptional(annotation.optional());
+        if (mappedName.length() > 0) {
+            resource.setMappedName(mappedName);
+        }
+        type.getResources().put(resource.getName(), resource);
+    }
+
+    @Override
+    public void visitField(Field field, JavaImplementation type) throws IntrospectionException {
+
+        org.apache.tuscany.sca.implementation.java.introspect.impl.Resource annotation = field
+            .getAnnotation(org.apache.tuscany.sca.implementation.java.introspect.impl.Resource.class);
+        if (annotation == null) {
+            return;
+        }
+        String name = annotation.name();
+        if (name.length() < 1) {
+            name = field.getName();
+        }
+        if (type.getResources().get(name) != null) {
+            throw new DuplicateResourceException(name);
+        }
+
+        String mappedName = annotation.mappedName();
+
+        JavaResourceImpl resource = createResource(name, new JavaElementImpl(field));
+        resource.setOptional(annotation.optional());
+        if (mappedName.length() > 0) {
+            resource.setMappedName(mappedName);
+        }
+        type.getResources().put(resource.getName(), resource);
+    }
+
+    @SuppressWarnings("unchecked")
+    public JavaResourceImpl createResource(String name, JavaElementImpl element) {
+        element.setClassifer(org.apache.tuscany.sca.implementation.java.introspect.impl.Resource.class);
+        element.setName(name);
+        return new JavaResourceImpl(element);
+    }
+
+    @Override
+    public void visitConstructorParameter(JavaParameterImpl parameter, JavaImplementation type)
+        throws IntrospectionException {
+        org.apache.tuscany.sca.implementation.java.introspect.impl.Resource resourceAnnotation = parameter
+            .getAnnotation(org.apache.tuscany.sca.implementation.java.introspect.impl.Resource.class);
+        if (resourceAnnotation != null) {
+            String name = resourceAnnotation.name();
+            if ("".equals(name)) {
+                name = parameter.getName();
+            }
+            if ("".equals(name)) {
+                throw new InvalidResourceException("Missing resource name", (Member)parameter.getAnchor());
+            }
+
+            if (!"".equals(parameter.getName()) && !name.equals(parameter.getName())) {
+                throw new InvalidConstructorException("Mismatched resource name: " + parameter);
+            }
+
+            if (type.getResources().get(name) != null) {
+                throw new DuplicateResourceException(name);
+            }
+
+            String mappedName = resourceAnnotation.mappedName();
+
+            JavaResourceImpl resource = createResource(name, parameter);
+            resource.setOptional(resourceAnnotation.optional());
+            if (mappedName.length() > 0) {
+                resource.setMappedName(mappedName);
+            }
+            type.getResources().put(resource.getName(), resource);
+        }
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ScopeProcessor.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ScopeProcessor.java
new file mode 100644
index 0000000000..a3d3889d30
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ScopeProcessor.java
@@ -0,0 +1,61 @@
+/*
+ * 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.java.introspect.impl;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.apache.tuscany.sca.implementation.java.impl.JavaScopeImpl;
+
+/**
+ * Processes the {@link JavaScopeImpl} annotation and updates the component type with the corresponding implmentation scope
+ *
+ * @version $Rev$ $Date$
+ */
+public class ScopeProcessor extends BaseJavaClassVisitor {
+    
+    public ScopeProcessor(AssemblyFactory factory) {
+        super(factory);
+    }
+
+    @Override
+    public <T> void visitClass(Class<T> clazz,
+                               JavaImplementation type)
+        throws IntrospectionException {
+        org.osoa.sca.annotations.Scope annotation = clazz.getAnnotation(org.osoa.sca.annotations.Scope.class);
+        if (annotation == null) {
+            type.setJavaScope(JavaScopeImpl.STATELESS);
+            return;
+        }
+        String name = annotation.value();
+        JavaScopeImpl scope;
+        if ("COMPOSITE".equals(name)) {
+            scope = JavaScopeImpl.COMPOSITE;
+        } else if ("SESSION".equals(name)) {
+            scope = JavaScopeImpl.SESSION;
+        } else if ("CONVERSATION".equals(name)) {
+            scope = JavaScopeImpl.CONVERSATION;
+        } else if ("REQUEST".equals(name)) {
+            scope = JavaScopeImpl.REQUEST;
+        } else {
+            scope = new JavaScopeImpl(name);
+        }
+        type.setJavaScope(scope);
+    }
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ServiceProcessor.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ServiceProcessor.java
new file mode 100644
index 0000000000..6854acdc2a
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ServiceProcessor.java
@@ -0,0 +1,184 @@
+/*
+ * 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.java.introspect.impl;
+
+import static org.apache.tuscany.sca.implementation.java.introspect.impl.JavaIntrospectionHelper.getAllInterfaces;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Set;
+import java.util.logging.Logger;
+
+import javax.jws.WebService;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.Service;
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+import org.apache.tuscany.sca.implementation.java.JavaImplementation;
+import org.apache.tuscany.sca.implementation.java.impl.JavaElementImpl;
+import org.apache.tuscany.sca.interfacedef.InvalidInterfaceException;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterface;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceContract;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory;
+import org.osoa.sca.CallableReference;
+import org.osoa.sca.annotations.Callback;
+import org.osoa.sca.annotations.Remotable;
+
+/**
+ * Processes an {@link org.osoa.sca.annotations.Service} annotation and updates
+ * the component type with corresponding {@link Service}s. Also processes
+ * related {@link org.osoa.sca.annotations.Callback} annotations.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class ServiceProcessor extends BaseJavaClassVisitor {
+    private static final Logger logger = Logger.getLogger(ServiceProcessor.class.getName());
+    private JavaInterfaceFactory javaFactory;
+    
+    public ServiceProcessor(AssemblyFactory assemblyFactory, JavaInterfaceFactory javaFactory) {
+        super(assemblyFactory);
+        this.javaFactory = javaFactory;
+    }
+
+    @Override
+    public <T> void visitClass(Class<T> clazz, JavaImplementation type) throws IntrospectionException {
+        org.osoa.sca.annotations.Service annotation = clazz.getAnnotation(org.osoa.sca.annotations.Service.class);
+        if (annotation == null) {
+            // scan interfaces for remotable
+            Set<Class> interfaces = getAllInterfaces(clazz);
+            for (Class<?> interfaze : interfaces) {
+                if (interfaze.isAnnotationPresent(Remotable.class) 
+                    || interfaze.isAnnotationPresent(WebService.class)
+                    || interfaze.isAnnotationPresent(Callback.class)
+                    ) {
+                    Service service;
+                    try {
+                        service = createService(interfaze);
+                    } catch (InvalidInterfaceException e) {
+                        throw new IntrospectionException(e);
+                    }
+                    type.getServices().add(service);
+                }
+            }
+            return;
+        }
+        Class<?>[] interfaces = annotation.interfaces();
+        if (interfaces.length == 0) {
+            Class<?> interfaze = annotation.value();
+            if (Void.class.equals(interfaze)) {
+                //throw new IllegalServiceDefinitionException("No interfaces specified");
+                logger.warning("Ignoring @Service annotation.  No interfaces specified. class = "+clazz.getName());
+            } else {
+                interfaces = new Class<?>[1];
+                interfaces[0] = interfaze;
+            }
+        }
+        for (Class<?> interfaze : interfaces) {
+            try {
+                Service service = createService(interfaze);
+                type.getServices().add(service);
+            } catch (InvalidInterfaceException e) {
+                throw new IntrospectionException(e);
+            }
+        }
+    }
+
+    @Override
+    public void visitMethod(Method method, JavaImplementation type) throws IntrospectionException {
+
+        Callback annotation = method.getAnnotation(Callback.class);
+        if (annotation == null) {
+            return;
+        }
+        if(Modifier.isPrivate(method.getModifiers())) {
+            throw new IllegalCallbackReferenceException("Illegal annotation @Callback found on "+method, method);
+        }
+        if (method.getParameterTypes().length != 1) {
+            throw new IllegalCallbackReferenceException("Setter must have one parameter", method);
+        }
+        JavaElementImpl element = new JavaElementImpl(method, 0);
+        createCallback(type, element);
+    }
+
+    @Override
+    public void visitField(Field field, JavaImplementation type) throws IntrospectionException {
+
+        Callback annotation = field.getAnnotation(Callback.class);
+        if (annotation == null) {
+            return;
+        }
+        if(Modifier.isPrivate(field.getModifiers())) {
+            throw new IllegalCallbackReferenceException("Illegal annotation @Callback found on "+field, field);
+        }
+        JavaElementImpl element = new JavaElementImpl(field);
+        createCallback(type, element);
+    }
+
+    /**
+     * @param type
+     * @param element
+     * @throws IllegalCallbackReferenceException
+     */
+    private void createCallback(JavaImplementation type, JavaElementImpl element)
+        throws IllegalCallbackReferenceException {
+        Service callbackService = null;
+        Class<?> callbackClass = element.getType();
+        Type genericType = element.getGenericType();
+        Class<?> baseType = callbackClass;
+        if(CallableReference.class.isAssignableFrom(baseType)) {
+            // @Callback protected CallableReference<MyCallback> callback;
+            // The base type will be MyCallback
+            baseType = JavaIntrospectionHelper.getBusinessInterface(baseType, genericType);
+        }        
+        for (Service service : type.getServices()) {
+            JavaInterface javaInterface = (JavaInterface)service.getInterfaceContract().getCallbackInterface();
+            if (javaInterface != null && baseType == javaInterface.getJavaClass()) {
+                callbackService = service;
+            }
+        }
+        if (callbackService == null) {
+            throw new IllegalCallbackReferenceException("Callback type does not match a service callback interface: " + type.getName() );
+        }
+        if(type.getCallbackMembers().get(baseType.getName()) == null) {
+            type.getCallbackMembers().put(baseType.getName(), new ArrayList<JavaElementImpl>());
+        }
+        type.getCallbackMembers().get(baseType.getName()).add(element);
+    }
+
+    public Service createService(Class<?> interfaze) throws InvalidInterfaceException {
+        Service service = assemblyFactory.createService();
+        JavaInterfaceContract interfaceContract = javaFactory.createJavaInterfaceContract();
+        service.setInterfaceContract(interfaceContract);
+
+        // create a relative URI
+        service.setName(interfaze.getSimpleName());
+
+        JavaInterface callInterface = javaFactory.createJavaInterface(interfaze);
+        service.getInterfaceContract().setInterface(callInterface);
+        if (callInterface.getCallbackClass() != null) {
+            JavaInterface callbackInterface = javaFactory.createJavaInterface(callInterface.getCallbackClass());
+            service.getInterfaceContract().setCallbackInterface(callbackInterface);
+        }
+        return service;
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ServiceTypeNotFoundException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ServiceTypeNotFoundException.java
new file mode 100644
index 0000000000..e1ca3ea565
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/ServiceTypeNotFoundException.java
@@ -0,0 +1,35 @@
+/*
+ * 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.java.introspect.impl;
+
+import org.apache.tuscany.sca.implementation.java.IntrospectionException;
+
+/**
+ * Thrown when a service interface cannot be determined based on a heuristic evaluation of an implementation
+ *
+ * @version $Rev$ $Date$
+ */
+public class ServiceTypeNotFoundException extends IntrospectionException {
+    private static final long serialVersionUID = -5124437274726947007L;
+
+    public ServiceTypeNotFoundException(String message) {
+        super(message);
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/UnknownContextTypeException.java b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/UnknownContextTypeException.java
new file mode 100644
index 0000000000..57d224b2bf
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/java/org/apache/tuscany/sca/implementation/java/introspect/impl/UnknownContextTypeException.java
@@ -0,0 +1,33 @@
+/*
+ * 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.java.introspect.impl;
+
+/**
+ * Thrown when a method or field marked with {@link org.osoa.sca.annotations.Context} takes an unknown type
+ *
+ * @version $Rev$ $Date$
+ */
+public class UnknownContextTypeException extends IllegalContextException {
+    private static final long serialVersionUID = 8125863714365422419L;
+
+    public UnknownContextTypeException(String message) {
+        super(message);
+    }
+
+}
diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/resources/META-INF/services/org.apache.tuscany.sca.core.ModuleActivator b/branches/sca-java-1.4/modules/implementation-java/src/main/resources/META-INF/services/org.apache.tuscany.sca.core.ModuleActivator
new file mode 100644
index 0000000000..df60d57cf9
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/resources/META-INF/services/org.apache.tuscany.sca.core.ModuleActivator
@@ -0,0 +1,18 @@
+# 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.

+

+org.apache.tuscany.sca.implementation.java.impl.JavaImplementationActivator

diff --git a/branches/sca-java-1.4/modules/implementation-java/src/main/resources/META-INF/services/org.apache.tuscany.sca.implementation.java.JavaImplementationFactory b/branches/sca-java-1.4/modules/implementation-java/src/main/resources/META-INF/services/org.apache.tuscany.sca.implementation.java.JavaImplementationFactory
new file mode 100644
index 0000000000..dc9de12632
--- /dev/null
+++ b/branches/sca-java-1.4/modules/implementation-java/src/main/resources/META-INF/services/org.apache.tuscany.sca.implementation.java.JavaImplementationFactory
@@ -0,0 +1,18 @@
+# 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.

+

+org.apache.tuscany.sca.implementation.java.DefaultJavaImplementationFactory