containerimpl.java

Rapla是一个灵活的多用户资源管理系统。它提供的一些功能有：日历GUI

        for ( int i=0;i<roles.length;i++) {
            addHandler( roles[i], hint, handler);
        }
    }

    public Collection getAllServicesFor(String role) {
        List list = new ArrayList( getAllServicesForThisContainer( role));
        if ( m_parent != null) {
            list.addAll( m_parent.getAllServicesFor( role ));
        }
        return list;
    }

    protected Collection getAllServicesForThisContainer(String role) {
        RoleEntry entry = (RoleEntry)m_roleMap.get( role );
        if ( entry == null)
            return Collections.EMPTY_LIST;
        return entry.getHintSet();
    }

    public Map lookupServicesFor(String role) throws RaplaContextException {
        Map map = new HashMap();
        for (Iterator it = getAllServicesFor(role).iterator();it.hasNext();) {
            String hint = (String) it.next();
            map.put(hint, getContext().lookup( role  + "/" + hint));
        }
        return map;
    }


    /**
     * @param roleName
     * @param hint
     * @param handler
     */
    private void addHandler(String roleName, Object hint, ComponentHandler handler) {
        m_componentHandler.add(  handler);
        RoleEntry entry = (RoleEntry)m_roleMap.get( roleName );
        if ( entry == null)
            entry = new RoleEntry();
        entry.put( hint , handler);
        m_roleMap.put( roleName, entry);
    }


    synchronized ComponentHandler getHandler( String role,Object hint) {
        RoleEntry entry = (RoleEntry)m_roleMap.get( role );
        if ( entry == null)
        {
            return null;
        }

        ComponentHandler handler = entry.getHandler( hint );
        if ( handler != null)
        {
            return handler;
        }
        if ( hint == null || hint.equals("*" ) )
            return entry.getFirstHandler();
        // Try the first accessible handler
        return null;
    }





    class RoleEntry {
        Map componentMap = new HashMap();
        ComponentHandler firstEntry;

        RoleEntry() {

        }

        void put( Object hint, ComponentHandler handler ){
            componentMap.put( hint, handler);
            if (firstEntry == null)
                firstEntry = handler;
        }

        Set getHintSet() {
            return componentMap.keySet();
        }

        ComponentHandler getHandler(Object hint) {
            return  (ComponentHandler) componentMap.get( hint );
        }

        ComponentHandler getFirstHandler() {
            return firstEntry;
        }

    }

    public RaplaContext getContext() {
        return m_context;
    }

    /**
     * @see org.apache.avalon.framework.activity.Disposable#dispose()
     */
    public void dispose() {
        removeAllComponents();
    }

    protected void removeAllComponents() {
        Iterator it = m_componentHandler.iterator();
        while ( it.hasNext() ) {
            ((ComponentHandler)it.next()).dispose();
        }
        m_componentHandler.clear();
        m_roleMap.clear();

    }

    static Constructor findDependantConstructor(Class componentClass) {
        Constructor[] construct= componentClass.getConstructors();
        for (int i=0;i< construct.length;i++) {
            Class[] types = construct[i].getParameterTypes();
            for (int j=0; j< types.length; j++ ) {
                Class type = types[j];
                if ( type.isAssignableFrom( RaplaContext.class) || type.isAssignableFrom( Configuration.class) ||
                        type.isAssignableFrom(Logger.class)) {

                    return construct[i];
                }

            }
        }
        return null;
    }


    /** instanciates a class and passes the config, logger and the parent context to the object if needed by the constructor.
     * This concept is taken form pico container.*/
    protected Object instanciate( String componentClassName, Configuration config, Logger logger ) throws RaplaContextException
    {
        Class componentClass;
        try {
            componentClass = Class.forName( componentClassName );
        } catch (ClassNotFoundException e1) {
            throw new RaplaContextException(componentClassName,e1.getMessage() , e1);
        }
        Constructor c = findDependantConstructor( componentClass );
        Object[] params = null;
        if ( c != null) {
            Class[] types = c.getParameterTypes();
            params = new Object[ types.length ];
            Class unknownParameter = null;
            for (int i=0; i< types.length; i++ ) {
                Class type = types[i];
                if ( type.isAssignableFrom( RaplaContext.class)) {
                    params[i] = m_context;
                } else  if ( type.isAssignableFrom( Configuration.class)) {
                    params[i] = config;
                } else if ( type.isAssignableFrom( Logger.class)) {
                    params[i] = logger;
                } else {
                    String guessedRole = type.getClass().getName();
                    if ( m_context.has( guessedRole )) {
                        params[i] = m_context.lookup( guessedRole );
                    } else {
                        unknownParameter = type;
                        break;
                    }
                }
            }
            if ( unknownParameter != null) {
                throw new RaplaContextException(componentClassName, "Can't statisfy constructor dependency " + unknownParameter.getName() + " for class " + componentClassName);
            }
        }
        try {
            Object component;
            if ( c!= null) {
                component = c.newInstance( params);
            } else {
                component = componentClass.newInstance();
            }
            ContainerUtil.start(component);
            return component;
        } catch (Exception ex) {
            throw new RaplaContextException(componentClassName, ex.getMessage(), ex);
        }
    }

    class ComponentHandler implements Disposable {
        Configuration config;
        Logger logger;
        Object component;
        String componentClassName;
        boolean dispose = true;
        ComponentHandler( Object component) {
            this.component = component;
            this.dispose = false;
        }

        ComponentHandler( Configuration config, String componentClass, Logger logger) {
            this.config = config;
            this.componentClassName = componentClass;
            this.logger = logger;
        }


        Object get() throws RaplaContextException {
            if ( component == null)
                component = instanciate( componentClassName, config, logger );

            return component;
        }



        public void dispose() {
            if ( !dispose)
                return;
            try {
                ContainerUtil.stop(  component );
            } catch ( Exception ex) {
                getLogger().error("Error stopping component ", ex );
            }
            ContainerUtil.dispose(  component );
        }

    }

 }