applicationimpl.java

来自「RESIN 3.2 最新源码」· Java 代码 · 共 1,774 行 · 第 1/4 页

    ELResolver elResolver = getELResolver();
    FacesContext facesContext = FacesContext.getCurrentInstance();
    ELContext elContext = new FacesELContext(facesContext, elResolver);

    if (param == null)
      param = new Class[0];

    if (!ref.startsWith("#{") && !ref.endsWith("}"))
      throw new ReferenceSyntaxException(L.l(
	"'{0}' is an illegal MethodBinding.  MethodBindings require #{...} syntax.",
	ref));

    try {
      MethodExpression expr
	= factory.createMethodExpression(elContext, ref, Object.class, param);

      return new MethodBindingAdapter(expr, param);
    }
    catch (ELException e) {
      throw new ReferenceSyntaxException(e);
    }
  }

  public Iterator<Locale> getSupportedLocales()
  {
    if (_locales != null)
      return _locales.iterator();
    else
      return new ArrayList<Locale>().iterator();
  }

  public void setSupportedLocales(Collection<Locale> locales)
  {
    _locales = new ArrayList<Locale>(locales);
  }

  public void addValidator(String validatorId, String validatorClass)
  {
    if (validatorId == null || validatorClass == null)
      throw new NullPointerException();

    _validatorClassMap.put(validatorId, validatorClass);
  }

  public Validator createValidator(String validatorId)
    throws FacesException
  {
    if (validatorId == null)
      throw new NullPointerException();

    try {
      String validatorClass = _validatorClassMap.get(validatorId);

      if (validatorClass == null)
	throw new FacesException(L.l("'{0}' is not a known validator.",
				     validatorId));

      Thread thread = Thread.currentThread();
      ClassLoader loader = thread.getContextClassLoader();

      Class cl = Class.forName(validatorClass, false, loader);

      return (Validator) cl.newInstance();
    }
    catch (FacesException e) {
      throw e;
    }
    catch (Exception e) {
      throw new FacesException(e);
    }
  }

  public Iterator<String> getValidatorIds()
  {
    return _validatorClassMap.keySet().iterator();
  }

  @Override
  public ValueBinding createValueBinding(String ref)
    throws ReferenceSyntaxException
  {
    ExpressionFactory factory = getExpressionFactory();

    FacesContext facesContext = FacesContext.getCurrentInstance();
    ELContext elContext = new FacesELContext(facesContext, getELResolver());

    try {
      ValueExpression expr
	= factory.createValueExpression(elContext, ref, Object.class);

      ValueBinding binding = new ValueBindingAdapter(expr);

      return binding;
    }
    catch (ELException e) {
      throw new ReferenceSyntaxException(e);
    }
  }

  @Override
  public Object evaluateExpressionGet(FacesContext context,
				      String expression,
				      Class expectedType)
  {
    ExpressionFactory factory = getExpressionFactory();

    ELContext elContext = context.getELContext();

    ValueExpression expr
      = factory.createValueExpression(elContext, expression, expectedType);

    return expr.getValue(elContext);
  }

  @Override
  public ProjectStage getProjectStage()
  {
    if (_projectStage == null) {
      String stage = null;

      try {
       stage
         = (String) new InitialContext().lookup(ProjectStage.PROJECT_STAGE_JNDI_NAME);
      }
      catch (NamingException e) {
      }

      if (stage == null) {
        stage = FacesContext.getCurrentInstance()
          .getExternalContext()
          .getInitParameter(ProjectStage.PROJECT_STAGE_PARAM_NAME);
      }

      if (stage != null) {
        try {
          _projectStage = ProjectStage.valueOf(ProjectStage.class, stage);
        }
        catch (IllegalArgumentException e) {
          log.fine(L.l("Can't convert '{0}' to ProjectStage", stage));
        }
      }

      if (_projectStage == null)
        _projectStage = ProjectStage.Production;
    }

    return _projectStage;
  }

  @Override
  public void subscribeToEvent(Class<? extends SystemEvent> systemEventClass,
                               SystemEventListener listener)
  {
    subscribeToEvent(systemEventClass, null, listener);
  }

  @Override
  public void subscribeToEvent(final Class<? extends SystemEvent> systemEventClass,
                               final Class sourceClass,
                               final SystemEventListener listener)
  {

    if (systemEventClass == null)
      throw new NullPointerException();

    if (listener == null)
      throw new NullPointerException();

    HashMap<Class, SystemEventListener[]> listenerMap;

    synchronized (_systemEventListenerMap) {
      listenerMap = _systemEventListenerMap.get(systemEventClass);

      if (listenerMap == null) {
        listenerMap = new HashMap<Class, SystemEventListener[]>();

        _systemEventListenerMap.put(systemEventClass, listenerMap);
      }
    }

    synchronized (listenerMap) {
      SystemEventListener[] listeners = listenerMap.get(sourceClass);

      if (listeners == null) {
        listeners = new SystemEventListener[]{listener};
      }
      else {
        SystemEventListener[] temp = listeners;

        listeners = new SystemEventListener[temp.length + 1];

        System.arraycopy(temp, 0, listeners, 0, temp.length);

        listeners[listeners.length - 1] = listener;
      }

      listenerMap.put(sourceClass, listeners);
    }
  }

  @Override
  public void unsubscribeFromEvent(Class<? extends SystemEvent> systemEventClass,
                                   SystemEventListener listener)
  {
    unsubscribeFromEvent(systemEventClass, null, listener);
  }

  @Override
  public void unsubscribeFromEvent(Class<? extends SystemEvent> systemEventClass,
                                   Class sourceClass,
                                   SystemEventListener listener)
  {
    if (systemEventClass == null)
      throw new NullPointerException();

    if (listener == null)
      throw new NullPointerException();


    HashMap<Class, SystemEventListener[]> listenerMap;

    synchronized (_systemEventListenerMap) {
      listenerMap
      = _systemEventListenerMap.get(systemEventClass);

    }

    if (listenerMap == null) return;

    synchronized (listenerMap) {
      SystemEventListener[] temp = listenerMap.get(sourceClass);
      
      for (int i = 0; i < temp.length; i++) {
        if (listener.equals(temp [i])) {
          SystemEventListener[] listeners = new SystemEventListener[temp.length - 1];

          System.arraycopy(temp, 0, listeners, 0, i);
          System.arraycopy(temp, i + 1, listeners, i, temp.length - (i + 1));

          listenerMap.put(sourceClass, listeners);
          
          break;
        }
      }
    }
  }

  /**
   * XXX: exception handling -> review with final 2.0 spec
   */
  @Override
  public void publishEvent(Class<? extends SystemEvent> systemEventClass,
                           SystemEventListenerHolder source)
  {
    if (systemEventClass == null)
      throw new NullPointerException();

    if (source == null)
      throw new NullPointerException();
    
    List<SystemEventListener> sourceListeners
      = source.getListenersForEventClass(systemEventClass);

    SystemEventListener []appListenersForSourceClass = null;

    HashMap<Class, SystemEventListener []> map
      = _systemEventListenerMap.get(systemEventClass);

    if (map != null)
      appListenersForSourceClass = map.get(source.getClass());

    SystemEventListener []appListeners = null;

    map = _systemEventListenerMap.get(systemEventClass);

    if (map != null)
      appListeners = map.get(null);

    if ((sourceListeners != null && sourceListeners.size() > 0)
        ||
        (appListenersForSourceClass != null && appListenersForSourceClass.length > 0)
        ||
        (appListeners != null && appListeners.length > 0)) {

      LruCache<Class<? extends SystemEventListenerHolder>, Constructor> constructorMap
        = _systemEventConstructorMap.get(systemEventClass);

      if (constructorMap == null) {
        constructorMap
          = new LruCache<Class<? extends SystemEventListenerHolder>, Constructor>(64);

        _systemEventConstructorMap.put(systemEventClass, constructorMap);
      }

      final Class sourceClass = source.getClass();

      Constructor ctor = constructorMap.get(sourceClass);

      if (ctor == null) {
        Constructor []constructors = systemEventClass.getConstructors();

        for (Constructor constructor : constructors) {
          Class []params = constructor.getParameterTypes();

          if (params.length == 1) {
            if (sourceClass.equals(params[0])) {
              ctor = constructor;
              break;
            }
          }
        }

        if (ctor == null) {
          constructors = systemEventClass.getConstructors();

          for (Constructor constructor : constructors) {
            Class []params = constructor.getParameterTypes();

            if (params.length == 1) {
              if (params[0].isAssignableFrom(sourceClass)) {
                ctor = constructor;
                break;
              }
            }
          }
        }
      }

      if (ctor == null) {
        log.fine(L.l(
          "Class '{0}' must have constructor accepting single argument of type assignable from '{1}'",
          systemEventClass.getName(),
          sourceClass));

        return;
      }

      SystemEvent event;
      try {
        event = (SystemEvent) ctor.newInstance(source);
      }
      catch (Exception e) {
        log.log(Level.FINER,
                L.l(
                  "Can not create an instance of class '{0}' using constructor '{1}'",
                  systemEventClass,
                  ctor),
                e);

        return;
      }

      SystemEventListener listener = null;

      try {
        if (sourceListeners != null)
          for (int i = 0; i < sourceListeners.size(); i++) {
            listener = sourceListeners.get(i);

            if (listener.isListenerForSource(source))
              if (event.isAppropriateListener(listener))
                event.processListener(listener);
          }

        if (appListenersForSourceClass != null)
          for (int i = 0; i < appListenersForSourceClass.length; i++) {
            listener = appListenersForSourceClass[i];

            if (listener.isListenerForSource(source))
              if (event.isAppropriateListener(listener))
                event.processListener(listener);
          }

        if (appListeners != null)
          for (int i = 0; i < appListeners.length; i++) {
            listener = appListeners[i];

            if (listener.isListenerForSource(source))
              if (event.isAppropriateListener(listener))
                event.processListener(listener);
          }
      }
      catch (AbortProcessingException e) {
        log.log(Level.FINER,
                L.l("Listener '{0}' aborted event publishing", listener),
                e);
      }
    }
  }

  public void initRequest()
  {
    _isInit = true;

    if (_viewHandler == null)
      _viewHandler = new JspViewHandler();

    if (_stateManager == null) {
      _stateManager = new SessionStateManager();

      JsfPropertyGroup jsfPropertyGroup = WebApp.getLocal().getJsf();

      if (jsfPropertyGroup != null)
        ((SessionStateManager) _stateManager).setStateSerializationMethod(
          jsfPropertyGroup.getStateSerializationMethod());
    }
  }

  public String toString()
  {
    return "ApplicationImpl[]";
  }

  static class PropertyResolverAdapter
    extends PropertyResolver
  {
    private ELResolver _elResolver;

    PropertyResolverAdapter(ELResolver elResolver)
    {
      _elResolver = elResolver;
    }

    public Class getType(Object base, int index)
      throws javax.faces.el.PropertyNotFoundException
    {
      if (base == null)
	throw new javax.faces.el.PropertyNotFoundException(
	  "getType() has null base object");

      try {
	FacesContext context = FacesContext.getCurrentInstance();

	return _elResolver.getType(context.getELContext(), base, index);
      }
      catch (javax.el.PropertyNotFoundException e) {
	throw new javax.faces.el.PropertyNotFoundException(e);
      }
    }

    public Class getType(Object base, Object property)
      throws javax.faces.el.PropertyNotFoundException
    {
      if (base == null)