* JBoss, Home of Professional Open Source

*

* Distributable under LGPL license.

* See terms of license at gnu.org.

*/

* Metamodel class for component classes.

*

* A Seam component is any class with a @Name annotation.

*

* @author Thomas Heute

* @author Gavin King

*

*/

   public static final String PROPERTIES = "org.jboss.seam.properties";

   private static final LogProvider log = Logging.getLogProvider(Component.class);

  

   private ComponentType type;

   private String name;

   private ScopeType scope;

   private String jndiName;

   private boolean interceptionEnabled;

   private boolean startup;

   private String[] dependencies;

   private boolean synchronize;

   private long timeout;

   private Set<Class> businessInterfaces;

   private Method destroyMethod;

   private Method createMethod;

   private Method unwrapMethod;

   private Method defaultRemoveMethod;

  

   //TODO: check the EJB3 spec, I think you

   //      are allowed to have multiple

   //      lifecycle methods on a bean!

   private Method preDestroyMethod;

   private Method postConstructMethod;

   private Method prePassivateMethod;

   private Method postActivateMethod;

  

   private Map<String, Method> removeMethods = new HashMap<String, Method>();

   private Set<Method> lifecycleMethods = new HashSet<Method>();

   private Set<Method> conversationManagementMethods = new HashSet<Method>();

  

   private List<BijectedAttribute<In>> inAttributes = new ArrayList<BijectedAttribute<In>>();

   private List<BijectedAttribute<Out>> outAttributes = new ArrayList<BijectedAttribute<Out>>();

   private List<BijectedAttribute> parameterSetters = new ArrayList<BijectedAttribute>();

   private List<BijectedAttribute> dataModelGetters = new ArrayList<BijectedAttribute>();

   private List<BijectedAttribute> pcAttributes = new ArrayList<BijectedAttribute>();

   private Map<String, BijectedAttribute> dataModelSelectionSetters = new HashMap<String, BijectedAttribute>();

  

   private List<Interceptor> interceptors = new ArrayList<Interceptor>();

   private List<Interceptor> clientSideInterceptors = new ArrayList<Interceptor>();

   private Map<Method, InitialValue> initializerSetters = new HashMap<Method, InitialValue>();

   private Map<Field, InitialValue> initializerFields = new HashMap<Field, InitialValue>();

   private List<Field> logFields = new ArrayList<Field>();

   private List<org.jboss.seam.log.Log> logInstances = new ArrayList<org.jboss.seam.log.Log>();

  

   private Collection<Namespace> imports = new ArrayList<Namespace>();

   private Namespace namespace;

  

   private boolean perNestedConversation;

   private Class<ProxyObject> factory;

   //only used for tests

   public Component(Class<?> clazz)

   {

      this( clazz, getComponentName(clazz) );

   }

   // only used for tests

   public Component(Class<?> clazz, String componentName)

   {

      this(clazz, componentName, Seam.getComponentScope(clazz), false, null);

   }

   // only used for tests

   public Component(Class<?> clazz, Context applicationContext)

   {

      this( clazz, getComponentName(clazz), Seam.getComponentScope(clazz), false, null, applicationContext );

   }

   public Component(Class<?> clazz, String componentName, ScopeType componentScope, boolean startup, String jndiName)

   {

      this(clazz, componentName, componentScope, startup, jndiName, Contexts.getApplicationContext());

   }

   private Component(Class<?> beanClass, String componentName, ScopeType componentScope, boolean startup, String componentJndiName, Context applicationContext)

   {

      super(beanClass);

     

      name = componentName;

      scope = componentScope;

      this.startup = startup;

      type = Seam.getComponentType( getBeanClass() );

      interceptionEnabled = Seam.isInterceptionEnabled( getBeanClass() );

      perNestedConversation = hasAnnotation(getBeanClass(), PerNestedConversation.class);

     

      checkName(); 

      checkNonabstract();

     

      initNamespace(componentName, applicationContext);

      initImports(applicationContext);

      initSynchronize();

      initStartup();

      checkScopeForComponentType();

      checkSynchronizedForComponentType();

      checkSerializableForComponentType();

      jndiName = componentJndiName == null ?

            getJndiName(applicationContext) : componentJndiName;

      log.info(

            "Component: " + getName() +

            ", scope: " + getScope() +

            ", type: " + getType() +

            ", class: " + getBeanClass().getName() +

            ( jndiName==null ? "" : ", JNDI: " + jndiName )

         );

      initMembers( getBeanClass(), applicationContext );

      checkDefaultRemoveMethod();

      businessInterfaces = getBusinessInterfaces( getBeanClass() );

      if ( interceptionEnabled )

      {

         initInterceptors();

      }

      initInitializers(applicationContext);

     

      registerConverterOrValidator(applicationContext);

   }

   private void checkName()

   {

      for ( char c: name.toCharArray() )

      {

         if ( !Character.isJavaIdentifierPart(c) && c!='.' )

         {

            throw new IllegalStateException("not a valid Seam component name: " + name);

         }

      }

   }

   private void checkNonabstract()

   {

      if ( getBeanClass().isInterface() )

      {

         throw new IllegalArgumentException("component class is an interface: " + name);

      }

      if ( Modifier.isAbstract( getBeanClass().getModifiers() ) )

      {

         throw new IllegalArgumentException("component class is abstract: " + name);

      }

   }

   private void initStartup()

   {

      if (startup)

      {

         if (scope!=SESSION && scope!=APPLICATION)

         {

            throw new IllegalArgumentException("@Startup only supported for SESSION or APPLICATION scoped components: " + name);

         }

         Startup annotation = getBeanClass().getAnnotation(Startup.class);

         dependencies = annotation==null ? new String[0] : annotation.depends();

      }

   }

   private void initSynchronize()

   {

      synchronize = ( scope==SESSION /*&& ! beanClass.isAnnotationPresent(ReadOnly.class)*/ ) ||

            getBeanClass().isAnnotationPresent(Synchronized.class);

      if (synchronize)

      {

         timeout = getBeanClass().isAnnotationPresent(Synchronized.class) ?

               getBeanClass().getAnnotation(Synchronized.class).timeout() :

               Synchronized.DEFAULT_TIMEOUT;

      }

   }

  

   private void registerConverterOrValidator(Context applicationContext)

   {

      if (applicationContext!=null) //for unit tests!

      {

         Init init = (Init) applicationContext.get( Seam.getComponentName(Init.class) );

         if (init!=null)

         {

            if ( getBeanClass().isAnnotationPresent(Converter.class) )

            {

               Converter converter = getBeanClass().getAnnotation(Converter.class);

               if ( converter.forClass()!=void.class )

               {

                  init.getConvertersByClass().put( converter.forClass(), getName() );

               }

               String id = converter.id().equals("") ? getName() : converter.id();

               init.getConverters().put( id, getName() );

            }

            if ( getBeanClass().isAnnotationPresent(Validator.class) )

            {

               Validator validator = getBeanClass().getAnnotation(Validator.class);

               String id = validator.id().equals("") ? getName() : validator.id();

               init.getValidators().put( id, getName() );

            }

         }

      }

   }

   private void initNamespace(String componentName, Context applicationContext)

   { 

      if (applicationContext!=null) { //for unit tests!

         Init init = (Init) applicationContext.get(Seam.getComponentName(Init.class));

         if (init!=null) {

            this.namespace = init.initNamespaceForName(componentName, true);

         }

      }

   }

  

   private void initImports(Context applicationContext)

   {

      if (applicationContext!=null) //for unit tests!

      {

         Init init = (Init) applicationContext.get( Seam.getComponentName(Init.class) );

         if (init!=null)

         {

            if ( getBeanClass().isAnnotationPresent(Import.class) )

            {

               addImport( init, getBeanClass().getAnnotation(Import.class) );

            }

           

            Package pkg = getBeanClass().getPackage();

            if ( pkg!=null && pkg.isAnnotationPresent(Import.class) )

            {

               addImport( init, getBeanClass().getPackage().getAnnotation(Import.class) );

            }

         }

      }

   }

   private void addImport(Init init, Import imp)

   {

       for (String ns: imp.value()) {

           imports.add(init.initNamespaceForName(ns, false));

       }

   }

   private void checkScopeForComponentType()

   {

      if ( scope==STATELESS && (type==STATEFUL_SESSION_BEAN || type==ENTITY_BEAN) )

      {

         throw new IllegalArgumentException("Only stateless session beans and Java beans may be bound to the STATELESS context: " + name);

      }

      if ( scope==PAGE && type==STATEFUL_SESSION_BEAN )

      {

         throw new IllegalArgumentException("Stateful session beans may not be bound to the PAGE context: " + name);

      }

      if ( scope==APPLICATION && type==STATEFUL_SESSION_BEAN )

      {

         log.warn("Stateful session beans was bound to the APPLICATION context - note that it is not safe to make concurrent calls to the bean: " + name);

      }

      if ( scope!=STATELESS && type==MESSAGE_DRIVEN_BEAN )

      {

         throw new IllegalArgumentException("Message-driven beans must be bound to STATELESS context: " + name);

      }     

   }

  

   protected void checkSynchronizedForComponentType()

   {

      if (scope==STATELESS && synchronize)

      {

         throw new IllegalArgumentException("@Synchronized not meaningful for stateless components: " + name);

      }

   }

  

   private void checkSerializableForComponentType()

   {

      boolean serializableScope = scope==PAGE || scope==SESSION || scope==CONVERSATION;

      boolean serializableType = type==JAVA_BEAN || type==ENTITY_BEAN;

      if ( serializableType && serializableScope && !Serializable.class.isAssignableFrom( getBeanClass() ) )

      {

         log.warn("Component class should be serializable: " + name);

      }

   }

   private String getJndiName(Context applicationContext)

   {

      if ( getBeanClass().isAnnotationPresent(JndiName.class) )

      {

         return getBeanClass().getAnnotation(JndiName.class).value();

      }

      else

      {

         switch (type) {

            case ENTITY_BEAN:

            case JAVA_BEAN:

               return null;

            default:

               if (applicationContext==null) return null; //TODO: Yew!!!

               String jndiPattern = Init.instance().getJndiPattern();

               if (jndiPattern==null)

               {

                  throw new IllegalArgumentException("You must specify org.jboss.seam.core.init.jndiPattern or use @JndiName: " + name);

               }

               return jndiPattern.replace( "#{ejbName}", Seam.getEjbName(getBeanClass()) );

         }

      }

   }

   private void initInitializers(Context applicationContext)

   {

      if (applicationContext==null) return; //TODO: yew!!!!!

      Map<String, Conversions.PropertyValue> properties = (Map<String, Conversions.PropertyValue>) applicationContext.get(PROPERTIES);

      if (properties==null) return; //TODO: yew!!!!!

      for ( Map.Entry<String, Conversions.PropertyValue> me: properties.entrySet() )

      {

         String key = me.getKey();

         Conversions.PropertyValue propertyValue = me.getValue();

         if ( key.startsWith(name) && key.charAt( name.length() )=='.' )

         {

            if ( log.isDebugEnabled() ) log.debug( key + "=" + propertyValue );

            /*if ( type==ENTITY_BEAN )

            {

               throw new IllegalArgumentException("can not configure entity beans: " + name);

            }*/

            String propertyName = key.substring( name.length()+1, key.length() );

            Method setterMethod = Reflections.getSetterMethod(getBeanClass(), propertyName);

            if (setterMethod!=null)

            {

               if ( !setterMethod.isAccessible() ) setterMethod.setAccessible(true);

               Class parameterClass = setterMethod.getParameterTypes()[0];

               Type parameterType = setterMethod.getGenericParameterTypes()[0];

               initializerSetters.put( setterMethod, getTopInitialValue(propertyValue, parameterClass, parameterType) );

            }

            else

            {

               Field field = Reflections.getField(getBeanClass(), propertyName);

               if ( !field.isAccessible() ) field.setAccessible(true);

               initializerFields.put( field, getInitialValue(propertyValue, field.getType(), field.getGenericType()) );

            }

        }

      }

   }

   private InitialValue getTopInitialValue(Conversions.PropertyValue propertyValue, Class parameterClass, Type parameterType)

   {

      //note that org.jboss.seam.core.init.jndiPattern looks like an EL expression but is not one!

      if ( propertyValue.isExpression() && getBeanClass().equals(Init.class) )

      {

         return new ConstantInitialValue(propertyValue, parameterClass, parameterType);

      }

      else

      {

         return getInitialValue(propertyValue, parameterClass, parameterType);

      }

   }

   private static InitialValue getInitialValue(Conversions.PropertyValue propertyValue, Class parameterClass, Type parameterType)

   {

      if ( propertyValue.isExpression() )

      {

         return new ELInitialValue(propertyValue, parameterClass, parameterType);

      }

      else if ( propertyValue.isMultiValued() )

      {

         return new ListInitialValue(propertyValue, parameterClass, parameterType);

      }

      else if ( propertyValue.isAssociativeValued() )

      {

         return new MapInitialValue(propertyValue, parameterClass, parameterType);

      }

      else

      {

         return new ConstantInitialValue(propertyValue, parameterClass, parameterType);

      }

   }

   private void initMembers(Class<?> clazz, Context applicationContext)

   {

      Map<Method, Annotation> selectionSetters = new HashMap<Method, Annotation>();

      Map<Field, Annotation> selectionFields = new HashMap<Field, Annotation>();

      Set<String> dataModelNames = new HashSet<String>();

      for ( ; clazz!=Object.class; clazz = clazz.getSuperclass() )

      {

         for ( Method method: clazz.getDeclaredMethods() )

         {

            scanMethod(applicationContext, selectionSetters, dataModelNames, method);

         }

         for ( Field field: clazz.getDeclaredFields() )

         {

            scanField(selectionFields, dataModelNames, field);

         }

      }

     

      final boolean hasMultipleDataModels = dataModelGetters.size() > 1;

      String defaultDataModelName = null;

      if ( !hasMultipleDataModels )

      {

         if ( !dataModelGetters.isEmpty() )

         {

            defaultDataModelName = dataModelGetters.get(0).getName();

         }

      }

      for ( Map.Entry<Method, Annotation> annotatedMethod: selectionSetters.entrySet() )

      {

         Method method = annotatedMethod.getKey();

         Annotation ann = annotatedMethod.getValue();

         String name = getDataModelSelectionName(dataModelNames, hasMultipleDataModels, defaultDataModelName, ann);

         Object existing = dataModelSelectionSetters.put( name, new BijectedMethod(name, method, ann) );

         if (existing!=null)

         {

            throw new IllegalStateException("Multiple @DataModelSelection setters for: " + name);

         }

      }

      for ( Map.Entry<Field, Annotation> annotatedField: selectionFields.entrySet() )

      {

         Field field = annotatedField.getKey();

         Annotation ann = annotatedField.getValue();

         String name = getDataModelSelectionName(dataModelNames, hasMultipleDataModels, defaultDataModelName, ann);

         Object existing = dataModelSelectionSetters.put( name, new BijectedField(name, field, ann) );

         if (existing!=null)

         {

            throw new IllegalStateException("Multiple @DataModelSelection fields for: " + name);

         }

      }

   }

   private void checkDefaultRemoveMethod()

   {

      if (type==STATEFUL_SESSION_BEAN)

      {

         if ( destroyMethod!=null && destroyMethod.isAnnotationPresent(REMOVE) ) //TODO: @Remove is not declared @Inherited, but does the EJB container emulate that?

         {

            //we don't need to worry about default remove methods

            defaultRemoveMethod = null;

         }

         else

         {

            //check that we have a default remove method

            if ( defaultRemoveMethod==null )

            {

               throw new IllegalArgumentException("Stateful session bean component must have a method with no parameters marked @Remove: " + name);

            }

           

            //check that it is unique

            boolean found = false;

            for ( Method remove: removeMethods.values() )

            {

               if ( remove.getParameterTypes().length==0 )

               {

                  if (found)

                  {

                     throw new IllegalStateException("Duplicate default @Remove method for component:" + name);

                  }

                  found = true;

               }

            }

         }

      }

   }

   private void scanMethod(Context applicationContext, Map<Method, Annotation> selectionSetters, Set<String> dataModelNames, Method method)

   {

      if ( method.isAnnotationPresent(Destroy.class) )

      {

         /*if ( method.getParameterTypes().length>0 ) and it doesn't take a Component parameter

         {

            throw new IllegalStateException("@Destroy methods may not have parameters: " + name);

         }*/

         if (type!=JAVA_BEAN && type!=STATEFUL_SESSION_BEAN)

         {

            throw new IllegalArgumentException("Only JavaBeans and stateful session beans support @Destroy methods: " + name);

         }

         if ( destroyMethod!=null && !destroyMethod.getName().equals( method.getName() ) )

         {

            throw new IllegalStateException("component has two @Destroy methods: " + name);

         }

        

         if ( destroyMethod==null ) //ie. ignore the one on the superclass

         {

            destroyMethod = method;

            lifecycleMethods.add(method);

         }

      }

     

      if ( method.isAnnotationPresent(REMOVE) )

      {

         removeMethods.put( method.getName(), method );

         if ( method.getParameterTypes().length==0 )

         {

            defaultRemoveMethod = method;

            lifecycleMethods.add(method);

         }

      }

     

      if ( method.isAnnotationPresent(Create.class) )

      {

         /*if ( method.getParameterTypes().length>0 ) and it doesn't take a Component parameter

         {

            throw new IllegalStateException("@Create methods may not have parameters: " + name);

         }*/

         if (type!=JAVA_BEAN && type!=STATEFUL_SESSION_BEAN)

         {

            throw new IllegalArgumentException("Only JavaBeans and stateful session beans support @Create methods: " + name);

         }

         if ( createMethod!=null && !createMethod.getName().equals( method.getName() ) )

         {

            throw new IllegalStateException("component has two @Create methods: " + name);

         }

         if (createMethod==null)

         {

            createMethod = method;

            lifecycleMethods.add(method);

         }

      }

     

      if ( method.isAnnotationPresent(In.class) )

      {

         In in = method.getAnnotation(In.class);

         String name = toName( in.value(), method );

         inAttributes.add( new BijectedMethod(name, method, in) );

      }

     

      if ( method.isAnnotationPresent(Out.class) )

      {

         Out out = method.getAnnotation(Out.class);

         String name = toName( out.value(), method );

         outAttributes.add( new BijectedMethod(name, method, out) );

        

         //can't use Init.instance() here because of unit tests

         Init init = (Init) applicationContext.get(Seam.getComponentName(Init.class));

         init.initNamespaceForName(name, true);

      }

     

      if ( method.isAnnotationPresent(Unwrap.class) )

      {

         if ( unwrapMethod!=null && !unwrapMethod.getName().equals( method.getName() )  )

         {

            throw new IllegalStateException("component has two @Unwrap methods: " + name);

         }

         if (unwrapMethod==null )

         {

            unwrapMethod = method;

         }

      }

     

      if ( method.isAnnotationPresent(DataModel.class) ) //TODO: generalize

      {

         checkDataModelScope( method.getAnnotation(DataModel.class) );

      }

     

      if ( method.isAnnotationPresent(org.jboss.seam.annotations.Factory.class) )

      {

         //can't use Init.instance() here because of unit tests

         Init init = (Init) applicationContext.get(Seam.getComponentName(Init.class));

         String contextVariable = toName( method.getAnnotation(org.jboss.seam.annotations.Factory.class).value(), method );

         init.addFactoryMethod(contextVariable, method, this);

         if ( method.getAnnotation(org.jboss.seam.annotations.Factory.class).autoCreate() )

         {

            init.addAutocreateVariable(contextVariable);

         }

      }

     

      if ( method.isAnnotationPresent(Observer.class) )

      {

         //can't use Init.instance() here because of unit tests

         Init init = (Init) applicationContext.get(Seam.getComponentName(Init.class));

         

         Observer observer = method.getAnnotation(Observer.class);

         for ( String eventType : observer.value() )

         {

            if ( eventType.length()==0 ) eventType = method.getName(); //TODO: new defaulting rule to map @Observer onFooEvent() -> event type "fooEvent"

            init.addObserverMethod( eventType, method, this, observer.create() );