* 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 boolean secure;

   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, new String[0], null);

   }

   // only used for tests

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

   {

      this( clazz, getComponentName(clazz), Seam.getComponentScope(clazz), false, new String[0], null, applicationContext );

   }

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

   {

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

   }

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

   {

      super(beanClass);

     

      name = componentName;

      scope = componentScope;

      this.startup = startup;

      this.dependencies = dependencies;

      type = Seam.getComponentType( getBeanClass() );

      interceptionEnabled = Seam.isInterceptionEnabled( getBeanClass() );

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

     

      checkName(); 

      checkNonabstract();

     

      initNamespace(componentName, applicationContext);

      initImports(applicationContext);

      initSynchronize();

      initStartup();

      initSecurity();

      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);

         if (dependencies.length == 0 && annotation != null)

         {

            dependencies = annotation.depends();

         }

      }

   }

   private void initSynchronize()

   {

      boolean hasAnnotation = getBeanClass().isAnnotationPresent(Synchronized.class);

     

      // Technically, we don't need to synchronize page-scoped components if StateManager#isSavingStateInClient(FacesContext) is true

      synchronize = ( scope==SESSION || scope==PAGE || hasAnnotation );

           

      if (synchronize)

      {

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

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

               Synchronized.DEFAULT_TIMEOUT;

      }

     

      if (hasAnnotation && !interceptionEnabled)

      {

         log.warn("Interceptors are disabled for @Synchronized component - synchronization will be disabled for: " + name);

      }

   }

  

   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) )

            {

               if(!getBeanClass().isAnnotationPresent(BypassInterceptors.class))

                  throw new IllegalStateException("Converter " + getBeanClass().getName()

                        + " must be annotated with @BypassInterceptors");

              

               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) )

            {

               if(!getBeanClass().isAnnotationPresent(BypassInterceptors.class))

                  throw new IllegalStateException("Validator " + getBeanClass().getName()

                        + " must be annotated with @BypassInterceptors");

               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 = null;

            try {

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

            } catch (IllegalArgumentException e) {}

            if (setterMethod!=null)

            {

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

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

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

               initializerSetters.put( setterMethod, getInitialValueHonoringExceptions(propertyName, 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 getInitialValueHonoringExceptions(String propertyName, Conversions.PropertyValue propertyValue, Class parameterClass, Type parameterType)

   {

      // the org.jboss.seam.core.init component cannot accomodate EL expressions because of startup order

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

      if ("org.jboss.seam.core.init".equals(getName()))

      {

         return new ConstantInitialValue(propertyValue, parameterClass, parameterType);

      }

      else

      {

         return getInitialValue(propertyValue, parameterClass, parameterType);

      }

   }

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

   {

      if ( parameterClass.equals(ValueExpression.class) ||

           parameterClass.equals(MethodExpression.class) ||

            propertyValue.isExpression() )

      {

         return new ELInitialValue(propertyValue, parameterClass, parameterType);

      }

      else if ( propertyValue.isMultiValued() )

      {

          if (Set.class.isAssignableFrom(parameterClass)) {

             return new SetInitialValue(propertyValue, parameterClass, parameterType);

          } else {

             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() )