dispatcher.java

电子地图服务器,搭建自己的地图服务

                            XmlRequestReader r2 = (XmlRequestReader) o2;

                            Version v1 = r1.getVersion();
                            Version v2 = r2.getVersion();

                            if ((v1 == null) && (v2 == null)) {
                                return 0;
                            }

                            if ((v1 != null) && (v2 == null)) {
                                return 1;
                            }

                            if ((v1 == null) && (v2 != null)) {
                                return -1;
                            }

                            int versionCompare = v1.compareTo(v2);

                            if (versionCompare != 0) {
                                return versionCompare;
                            }

                            String sid1 = r1.getServiceId();
                            String sid2 = r2.getServiceId();

                            if ((sid1 == null) && (sid2 == null)) {
                                return 0;
                            }

                            if ((sid1 != null) && (sid2 == null)) {
                                return 1;
                            }

                            if ((sid1 == null) && (sid2 != null)) {
                                return -1;
                            }

                            return sid1.compareTo(sid2);
                        }
                    };

                Collections.sort(vmatches, comparator);
            }

            xmlReader = (XmlRequestReader) vmatches.get(vmatches.size() - 1);
        } else {
            //only a single match, that was easy
            xmlReader = (XmlRequestReader) matches.get(0);
        }

        return xmlReader;
    }

    ServiceStrategy findOutputStrategy(HttpServletResponse response) {
        OutputStrategyFactory factory = null;
        try {
            factory = (OutputStrategyFactory) GeoServerExtensions.bean("serviceStrategyFactory");
        } catch(NoSuchBeanDefinitionException e) {
            return null;
        }
        return factory.createOutputStrategy(response);
    }

    BufferedInputStream input(File cache) throws IOException {
        return (cache == null) ? null : new BufferedInputStream(new FileInputStream(cache));
    }

    void parseKVP(Request req) throws ServiceException {
        HttpServletRequest request = req.httpRequest;

        //unparsed kvp set
        Map kvp = request.getParameterMap();

        if (kvp == null || kvp.isEmpty()) {
            //req.kvp = Collections.EMPTY_MAP;
            req.kvp = null;
            return;
        }

        //look up parser objects
        Collection parsers = GeoServerExtensions.extensions(KvpParser.class);
        Map parsedKvp = new KvpMap();
        Map rawKvp = new KvpMap();
        
        for (Iterator itr = kvp.entrySet().iterator(); itr.hasNext();) {
            Map.Entry entry = (Map.Entry) itr.next();
            String key = (String) entry.getKey();
            String value = null;

            if (entry.getValue() instanceof String) {
                value = (String) entry.getValue();
            } else if (entry.getValue() instanceof String[]) {
                //TODO: perhaps handle multiple values for a key
                value = (String) ((String[]) entry.getValue())[0];
            }

            //trim the string
            if ( value != null ) {
                value = value.trim(); 
            }
            
            //find the parser for this key value pair
            Object parsed = null;

            for (Iterator pitr = parsers.iterator(); pitr.hasNext();) {
                KvpParser parser = (KvpParser) pitr.next();

                if (key.equalsIgnoreCase(parser.getKey())) {
                    try {
                        parsed = parser.parse(value);
                    } catch (Throwable t) {
                        //dont throw any exceptions yet, befor the service is
                        // known
                        req.error = t;
                    }
                }
            }

            //if noone could parse, just set to string value
            if (parsed == null) {
                parsed = value;
            }

            //convert key to lowercase 
            parsedKvp.put(key.toLowerCase(), parsed);
            rawKvp.put(key.toLowerCase(), value );
        }

        req.kvp = parsedKvp;
        req.rawKvp = rawKvp;
    }

    Object parseRequestKVP(Class type, Request request)
        throws Exception {
        KvpRequestReader kvpReader = findKvpRequestReader(type);

        if (kvpReader != null) {
            //check for http request awareness
            if (kvpReader instanceof HttpServletRequestAware) {
                ((HttpServletRequestAware) kvpReader).setHttpRequest(request.httpRequest);
            }

            Object requestBean = kvpReader.createRequest();

            if (requestBean != null) {
                requestBean = kvpReader.read(requestBean, request.kvp, request.rawKvp);
            }

            return requestBean;
        }

        return null;
    }

    Object parseRequestXML(Object requestBean, BufferedReader input, Request request)
        throws Exception {
        //check for an empty input stream
        //if (input.available() == 0) {
        if (!input.ready()) {
            return null;
        }

        //create stream parser
        XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
        factory.setNamespaceAware(true);
        factory.setValidating(false);

        //parse root element
        XmlPullParser parser = factory.newPullParser();
        //parser.setInput(input, "UTF-8");
        parser.setInput(input);
        parser.nextTag();

        String namespace = (parser.getNamespace() != null) ? parser.getNamespace() : "";
        String element = parser.getName();
        String version = null;

        for (int i = 0; i < parser.getAttributeCount(); i++) {
            if ("version".equals(parser.getAttributeName(i))) {
                version = parser.getAttributeValue(i);

                break;
            }
        }

        parser.setInput(null);

        //reset input stream
        input.reset();

        XmlRequestReader xmlReader = findXmlReader(namespace, element, version);
        if (xmlReader == null ) {
            //no xml reader, just return object passed in
            return requestBean;
        }

        if (xmlReader instanceof HttpServletRequestAware) {
            ((HttpServletRequestAware) xmlReader).setHttpRequest(request.httpRequest);
        }

        //return xmlReader.read(input);
        return xmlReader.read( requestBean, input );
    }

    Map readOpContext(HttpServletRequest request) {
        //try to get from request url
        String ctxPath = request.getContextPath();
        String reqPath = request.getRequestURI();
        reqPath = reqPath.substring(ctxPath.length());

        if (reqPath.startsWith("/")) {
            reqPath = reqPath.substring(1, reqPath.length());
        }

        if (reqPath.endsWith("/")) {
            reqPath = reqPath.substring(0, reqPath.length() - 1);
        }

        Map map = new HashMap();
        int index = reqPath.indexOf('/');

        if (index != -1) {
            map.put("service", reqPath.substring(0, index));
            map.put("request", reqPath.substring(index + 1));
        } else {
            map.put("service", reqPath);
        }

        return map;
    }

    Map readOpPost(BufferedReader input) throws Exception {
        //create stream parser
        XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
        factory.setNamespaceAware(true);
        factory.setValidating(false);

        //parse root element
        XmlPullParser parser = factory.newPullParser();
        parser.setInput(input);
        parser.nextTag();

        Map map = new HashMap();
        map.put("request", parser.getName());

        for (int i = 0; i < parser.getAttributeCount(); i++) {
            String attName = parser.getAttributeName(i);

            if ("service".equals(attName)) {
                map.put("service", parser.getAttributeValue(i));
            }

            if ("version".equals(parser.getAttributeName(i))) {
                map.put("version", parser.getAttributeValue(i));
            }

            if ("outputFormat".equals(attName)) {
                map.put("outputFormat", parser.getAttributeValue(i));
            }
        }

        //close parser + release resources
        parser.setInput(null);

        //reset the input stream
        input.reset();

        return map;
    }

    void exception(Throwable t, Service service, Request request) {
        logger.log(Level.WARNING, "", t);

        //wrap in service exception if necessary
        ServiceException se = null;

        if (t instanceof ServiceException) {
            se = (ServiceException) t;
        } else {
            //unwind the exception stack, look for a service exception
            Throwable cause = t.getCause();

            while (cause != null) {
                if (cause instanceof ServiceException) {
                    ServiceException cse = (ServiceException) cause;
                    se = new ServiceException(cse.getMessage(), t, cse.getCode(), cse.getLocator());

                    break;
                }

                cause = cause.getCause();
            }
        }

        if (se == null) {
            //couldn't find one, just wrap in one
            se = new ServiceException(t);
        }

        //find an exception handler
        ServiceExceptionHandler handler = null;

        if (service != null) {
            //look up the service exception handler
            Collection handlers = GeoServerExtensions.extensions(ServiceExceptionHandler.class);
            for (Iterator h = handlers.iterator(); h.hasNext();) {
                ServiceExceptionHandler seh = (ServiceExceptionHandler) h.next();

                if (seh.getServices().contains(service)) {
                    //found one,
                    handler = seh;

                    break;
                }
            }
        }

        if (handler == null) {
            //none found, fall back on default
            handler = new DefaultServiceExceptionHandler();
        }

        handler.handleServiceException(se, service, request.httpRequest, request.httpResponse);
    }

    /**
     * Map which makes keys case insensitive.
     *
     * @author Justin Deoliveira, The Open Planning Project
     *
     */
    private static class KvpMap extends HashMap {
        private static final long serialVersionUID = 1L;

        public boolean containsKey(Object key) {
            return super.containsKey(upper(key));
        }

        public Object get(Object key) {
            return super.get(upper(key));
        }

        public Object put(Object key, Object value) {
            return super.put(upper(key), value);
        }

        Object upper(Object key) {
            if ((key != null) && key instanceof String) {
                return ((String) key).toUpperCase();
            }

            return key;
        }
    }

    /**
     * Helper class to hold attributes of hte request
     *
     */
    static class Request {
        /**
         * Http request / response
         */
        HttpServletRequest httpRequest;
        HttpServletResponse httpResponse;

        /**
         * flag indicating if the request is get
         */
        boolean get;

        /**
         * Kvp parameters, only non-null if get = true
         */
        Map kvp;

        /**
         * raw kvp parameters, unparsed
         */
        Map rawKvp;
        /**
         * buffered input stream, only non-null if get = false
         */
        BufferedReader input;

        /**
         * The ows service,request,version
         */
        String service;
        String request;
        String version;

        /**
         * The output format of hte request
         */
        String outputFormat;

        /**
         * Any errors that occur tryinng to determine the service
         */
        Throwable error;

        public String toString() {
            return service + " " + version + " " + request;
        }
    }

    /**
     * Allows setting up a security interceptor that will allow security checks around
     * service invocations
     * @return
     */
    public OperationInterceptor getSecurityInterceptor() {
        return securityInterceptor;
    }

    public void setSecurityInterceptor(OperationInterceptor interceptor) {
        this.securityInterceptor = interceptor;
    }
}