webxmlconfiguration.java

jetty SERVER連接資料庫用的軟體

    /* ------------------------------------------------------------ */
    /**
     * Handle web.xml element. This method is called for each top level element within the web.xml
     * file. It may be specialized by derived WebAppHandlers to provide additional
     * configuration and handling.
     *
     * @param element The element name
     * @param node The node containing the element.
     */
    protected void initWebXmlElement(String element,XmlParser.Node node) throws Exception
    {
        if("display-name".equals(element))
            initDisplayName(node);
        else if("description".equals(element))
        {}
        else if("context-param".equals(element))
            initContextParam(node);
        else if("servlet".equals(element))
            initServlet(node);
        else if("servlet-mapping".equals(element))
            initServletMapping(node);
        else if("session-config".equals(element))
            initSessionConfig(node);
        else if("mime-mapping".equals(element))
            initMimeConfig(node);
        else if("welcome-file-list".equals(element))
            initWelcomeFileList(node);
        else if("locale-encoding-mapping-list".equals(element))
            initLocaleEncodingList(node);
        else if("error-page".equals(element))
            initErrorPage(node);
        else if("taglib".equals(element))
            initTagLib(node);
        else if("jsp-config".equals(element))
            initJspConfig(node);
        else if("resource-ref".equals(element))
        {
            if(Log.isDebugEnabled())
                Log.debug("No implementation: "+node);
        }
        else if("security-constraint".equals(element))
            initSecurityConstraint(node);
        else if("login-config".equals(element))
            initLoginConfig(node);
        else if("security-role".equals(element))
            initSecurityRole(node);
        else if("filter".equals(element))
            initFilter(node);
        else if("filter-mapping".equals(element))
            initFilterMapping(node);
        else if("listener".equals(element))
            initListener(node);
        else if("distributable".equals(element))
            initDistributable(node);
        else
        {
            if(Log.isDebugEnabled())
            {
                Log.debug("Element {} not handled in {}",element,this);
                Log.debug(node.toString());
            }
        }
    }

    /* ------------------------------------------------------------ */
    protected void initDisplayName(XmlParser.Node node)
    {
        getWebAppContext().setDisplayName(node.toString(false,true));
    }

    /* ------------------------------------------------------------ */
    protected void initContextParam(XmlParser.Node node)
    {
        String name=node.getString("param-name",false,true);
        String value=node.getString("param-value",false,true);
        if(Log.isDebugEnabled())
            Log.debug("ContextParam: "+name+"="+value);
        getWebAppContext().getInitParams().put(name, value);
    }

    /* ------------------------------------------------------------ */
    protected void initFilter(XmlParser.Node node)
    {
        String name=node.getString("filter-name",false,true);
        FilterHolder holder= _servletHandler.getFilter(name);
        if (holder==null)
        {
            holder=_servletHandler.newFilterHolder();
            holder.setName(name);
            _filters=LazyList.add(_filters,holder);
        }
        
        String filter_class=node.getString("filter-class",false,true);
        if (filter_class!=null)
            holder.setClassName(filter_class);

        Iterator iter=node.iterator("init-param");
        while(iter.hasNext())
        {
            XmlParser.Node paramNode=(XmlParser.Node)iter.next();
            String pname=paramNode.getString("param-name",false,true);
            String pvalue=paramNode.getString("param-value",false,true);
            holder.setInitParameter(pname, pvalue);
        }
        
    }

    /* ------------------------------------------------------------ */
    protected void initFilterMapping(XmlParser.Node node)
    {
        String filter_name=node.getString("filter-name",false,true);



        FilterMapping mapping = new FilterMapping();

        mapping.setFilterName(filter_name);

        ArrayList paths = new ArrayList();
        Iterator iter=node.iterator("url-pattern");
        while(iter.hasNext())
        {
            String p=((XmlParser.Node)iter.next()).toString(false,true);
            p=normalizePattern(p);
            paths.add(p);
        }
        mapping.setPathSpecs((String[])paths.toArray(new String[paths.size()]));


        ArrayList names = new ArrayList();
        iter=node.iterator("servlet-name");
        while(iter.hasNext())
        {
            String n=((XmlParser.Node)iter.next()).toString(false,true);
            names.add(n);
        }
        mapping.setServletNames((String[])names.toArray(new String[names.size()]));


        int dispatcher=Handler.DEFAULT;
        iter=node.iterator("dispatcher");
        while(iter.hasNext())
        {
            String d=((XmlParser.Node)iter.next()).toString(false,true);
            dispatcher|=Dispatcher.type(d);
        }
        mapping.setDispatches(dispatcher);

        _filterMappings=LazyList.add(_filterMappings,mapping);
    }

    /* ------------------------------------------------------------ */
    protected String normalizePattern(String p)
    {
        if (p!=null && p.length()>0 && !p.startsWith("/") && !p.startsWith("*"))
            return "/"+p;
        return p;
    }

    /* ------------------------------------------------------------ */
    protected void initServlet(XmlParser.Node node) 
    {
        String id=node.getAttribute("id");

        // initialize holder
        String servlet_name=node.getString("servlet-name",false,true);
        ServletHolder holder = _servletHandler.getServlet(servlet_name);
        if (holder==null)
        {
            holder=_servletHandler.newServletHolder();
            holder.setName(servlet_name);
            _servlets=LazyList.add(_servlets,holder);
        }
        
        // init params
        Iterator iParamsIter=node.iterator("init-param");
        while(iParamsIter.hasNext())
        {
            XmlParser.Node paramNode=(XmlParser.Node)iParamsIter.next();
            String pname=paramNode.getString("param-name",false,true);
            String pvalue=paramNode.getString("param-value",false,true);
            holder.setInitParameter(pname,pvalue);
        }
        
        String servlet_class=node.getString("servlet-class",false,true);
        
        // Handle JSP
        if (id!=null && id.equals("jsp"))
        {
            _jspServletName=servlet_name;
            _jspServletClass=servlet_class;
            try
            {
                Loader.loadClass(this.getClass(), servlet_class);
                _hasJSP=true;
            }
            catch(ClassNotFoundException e)
            {
                Log.info("NO JSP Support for {}, did not find {}",_context.getContextPath(),servlet_class);
                _hasJSP=false;
                _jspServletClass=servlet_class="org.mortbay.servlet.NoJspServlet";
            }
            if (holder.getInitParameter("scratchdir")==null)
            {
                File tmp=getWebAppContext().getTempDirectory();
                File scratch=new File(tmp,"jsp");
                if (!scratch.exists())
                    scratch.mkdir();
                holder.setInitParameter("scratchdir",scratch.getAbsolutePath());
                
                if ("?".equals(holder.getInitParameter("classpath")))
                {
                    String classpath=getWebAppContext().getClassPath();
                    Log.debug("classpath="+classpath);
                    if (classpath!=null)
                        holder.setInitParameter("classpath",classpath);
                }
            }
        }
        if (servlet_class!=null)
            holder.setClassName(servlet_class);
        
        
        // Handler JSP file
        String jsp_file=node.getString("jsp-file",false,true);
        if (jsp_file!=null)
        {
            holder.setForcedPath(jsp_file);
            holder.setClassName(_jspServletClass);
        }

        // handle startup
        XmlParser.Node startup=node.get("load-on-startup");
        if(startup!=null)
        {
            String s=startup.toString(false,true).toLowerCase();
            if(s.startsWith("t"))
            {
                Log.warn("Deprecated boolean load-on-startup.  Please use integer");
                holder.setInitOrder(1);
            }
            else
            {
                int order=0;
                try
                {
                    if(s!=null&&s.trim().length()>0)
                        order=Integer.parseInt(s);
                }
                catch(Exception e)
                {
                    Log.warn("Cannot parse load-on-startup "+s+". Please use integer");
                    Log.ignore(e);
                }
                holder.setInitOrder(order);
            }
        }
        
        Iterator sRefsIter=node.iterator("security-role-ref");
        while(sRefsIter.hasNext())
        {
            XmlParser.Node securityRef=(XmlParser.Node)sRefsIter.next();
            String roleName=securityRef.getString("role-name",false,true);
            String roleLink=securityRef.getString("role-link",false,true);
            if(roleName!=null&&roleName.length()>0&&roleLink!=null&&roleLink.length()>0)
            {
                if(Log.isDebugEnabled())
                    Log.debug("link role "+roleName+" to "+roleLink+" for "+this);
                holder.setUserRoleLink(roleName,roleLink);
            }
            else
            {
                Log.warn("Ignored invalid security-role-ref element: "+"servlet-name="+holder.getName()+", "+securityRef);
            }
        }
        
        XmlParser.Node run_as=node.get("run-as");
        if(run_as!=null)
        {
            String roleName=run_as.getString("role-name",false,true);
            if(roleName!=null)
                holder.setRunAs(roleName);
        }
        
    }

    /* ------------------------------------------------------------ */
    protected void initServletMapping(XmlParser.Node node)
    {
        String servlet_name = node.getString("servlet-name",false,true);
        ServletMapping mapping = new ServletMapping();
        mapping.setServletName(servlet_name);

        ArrayList paths = new ArrayList();
        Iterator iter=node.iterator("url-pattern");
        while(iter.hasNext())
        {
            String p=((XmlParser.Node)iter.next()).toString(false,true);
            p=normalizePattern(p);
            paths.add(p);
        }
        mapping.setPathSpecs((String[])paths.toArray(new String[paths.size()]));

        _servletMappings=LazyList.add(_servletMappings,mapping);
    }

    /* ------------------------------------------------------------ */
    protected void initListener(XmlParser.Node node)
    {
        String className=node.getString("listener-class",false,true);
        Object listener=null;
        try
        {
            Class listenerClass=getWebAppContext().loadClass(className);
            listener=newListenerInstance(listenerClass);