View Javadoc

    1   /*
    2    * Licensed to the Apache Software Foundation (ASF) under one
    3    * or more contributor license agreements. See the NOTICE file
    4    * distributed with this work for additional information
    5    * regarding copyright ownership. The ASF licenses this file
    6    * to you under the Apache License, Version 2.0 (the
    7    * "License"); you may not use this file except in compliance
    8    * with the License. You may obtain a copy of the License at
    9    *
    10   * http://www.apache.org/licenses/LICENSE-2.0
    11   *
    12   * Unless required by applicable law or agreed to in writing,
    13   * software distributed under the License is distributed on an
    14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    15   * KIND, either express or implied. See the License for the
    16   * specific language governing permissions and limitations
    17   * under the License.
    18   */
    19  package org.apache.ws.commons.schema.resolver;
    20
    21  import java.io.File;
    22  import java.io.IOException;
    23  import java.net.MalformedURLException;
    24  import java.net.URI;
    25  import java.net.URISyntaxException;
    26  import java.net.URL;
    27
    28  import org.xml.sax.InputSource;
    29
    30
    31  /**
    32   * This resolver provides the means of resolving the imports and includes of a
    33   * given schema document. The system will call this default resolver if there
    34   * is no other resolver present in the system.
    35   */
    36  public class DefaultURIResolver implements CollectionURIResolver {
    37
    38  	private String collectionBaseURI;
    39
    40
    41      /**
    42       * Try to resolve a schema location to some data.
    43       * @param namespace targt namespace.
    44       * @param schemaLocation system ID.
    45       * @param baseUri base URI for the schema.
    46       */
    47      public InputSource resolveEntity(String namespace,
    48                                       String schemaLocation,
    49                                       String baseUri) {
    50
    51          if (baseUri!=null)
    52          {
    53              try
    54              {
    55                  File baseFile = new File(baseUri);
    56                  if (baseFile.exists()) {
    57                  	baseUri = baseFile.toURI().toString();
    58                  } else if(collectionBaseURI != null) {
    59                  	baseFile = new File(collectionBaseURI);
    60                      if (baseFile.exists()) {
    61                      	baseUri = baseFile.toURI().toString();
    62                      }
    63                  }
    64
    65                  String ref = new URI(baseUri).resolve(new URI(schemaLocation)).toString();
    66
    67                  return new InputSource(ref);
    68              }
    69              catch (URISyntaxException e1)
    70              {
    71                  throw new RuntimeException(e1);
    72              }
    73
    74          }
    75          return new InputSource(schemaLocation);
    76
    77
    78
    79      }
    80
    81      /**
    82       * Find whether a given uri is relative or not
    83       *
    84       * @param uri
    85       * @return boolean
    86       */
    87      protected boolean isAbsolute(String uri) {
    88          return uri.startsWith("http://");
    89      }
    90
    91      /**
    92       * This is essentially a call to "new URL(contextURL, spec)"
    93       * with extra handling in case spec is
    94       * a file.
    95       *
    96       * @param contextURL
    97       * @param spec
    98       * @throws java.io.IOException
    99       */
    100     protected URL getURL(URL contextURL, String spec) throws IOException {
    101
    102         // First, fix the slashes as windows filenames may have backslashes
    103         // in them, but the URL class wont do the right thing when we later
    104         // process this URL as the contextURL.
    105         String path = spec.replace('\\', '/');
    106
    107         // See if we have a good URL.
    108         URL url;
    109
    110         try {
    111
    112             // first, try to treat spec as a full URL
    113             url = new URL(contextURL, path);
    114
    115             // if we are deail with files in both cases, create a url
    116             // by using the directory of the context URL.
    117             if ((contextURL != null) && url.getProtocol().equals("file")
    118                     && contextURL.getProtocol().equals("file")) {
    119                 url = getFileURL(contextURL, path);
    120             }
    121         } catch (MalformedURLException me) {
    122
    123             // try treating is as a file pathname
    124             url = getFileURL(contextURL, path);
    125         }
    126
    127         // Everything is OK with this URL, although a file url constructed
    128         // above may not exist.  This will be caught later when the URL is
    129         // accessed.
    130         return url;
    131     }    // getURL
    132
    133     /**
    134      * Method getFileURL
    135      *
    136      * @param contextURL
    137      * @param path
    138      * @throws IOException
    139      */
    140     protected URL getFileURL(URL contextURL, String path)
    141             throws IOException {
    142
    143         if (contextURL != null) {
    144
    145             // get the parent directory of the contextURL, and append
    146             // the spec string to the end.
    147             String contextFileName = contextURL.getFile();
    148             URL parent = null;
    149             //the logic for finding the parent file is this.
    150             //1.if the contextURI represents a file then take the parent file
    151             //of it
    152             //2. If the contextURI represents a directory, then take that as
    153             //the parent
    154             File parentFile;
    155             File contextFile = new File(contextFileName);
    156             if (contextFile.isDirectory()){
    157                 parentFile = contextFile;
    158             }else{
    159                 parentFile = contextFile.getParentFile();
    160             }
    161
    162             if (parentFile != null) {
    163                 parent = parentFile.toURL();
    164             }
    165             if (parent != null) {
    166                 return new URL(parent, path);
    167             }
    168         }
    169
    170         return new URL("file", "", path);
    171     }    // getFileURL
    172
    173     /**
    174      * Get the base URI derived from a schema collection. It serves as a fallback from the specified base.
    175      * @return URI
    176      */
    177 	public String getCollectionBaseURI() {
    178 		return collectionBaseURI;
    179 	}
    180
    181 	/**
    182 	 * set the collection base URI, which serves as a fallback from the base of the immediate schema.
    183 	 * @param collectionBaseURI the URI.
    184 	 */
    185 	public void setCollectionBaseURI(String collectionBaseURI) {
    186 		this.collectionBaseURI = collectionBaseURI;
    187 	}
    188 }