Java HttpURL类代码示例

import org.apache.commons.httpclient.HttpURL; //导入依赖的package包/类
protected WebdavContentNode getChildNode(String name)
        throws ContentRepositoryException
{
    // make sure this isn't a path
    if (name.contains("/")) {
        throw new ContentRepositoryException("Paths not allowed: " + name);
    }

    try {
        HttpURL url = getChildURL(getResource().getHttpURL(), name);
        
        logger.fine("[WebdavContentCollection] Get child " + name +
                    " returns " + url + " from " + this);

        AuthenticatedWebdavResource resource =
                new AuthenticatedWebdavResource(getResource(), url);
        if (resource.getExistence()) {
            return getContentNode(resource);
        }

        return null;
    } catch (IOException ioe) {
        throw new ContentRepositoryException(ioe);
    }
}
 

import org.apache.commons.httpclient.HttpURL; //导入依赖的package包/类
public WebdavContentNode removeChild(String name)
        throws ContentRepositoryException
{
    // make sure this isn't a path
    if (name.contains("/")) {
        throw new ContentRepositoryException("Paths not allowed: " + name);
    }

    try {
        HttpURL removeURL = getChildURL(getResource().getHttpURL(), name);
        AuthenticatedWebdavResource removeResource =
                new AuthenticatedWebdavResource(getResource(), removeURL);
        if (removeResource.exists()) {
            removeResource.deleteMethod();
        }
        
        return getContentNode(removeResource);
    } catch (IOException ioe) {
        throw new ContentRepositoryException(ioe);
    }
}
 

import org.apache.commons.httpclient.HttpURL; //导入依赖的package包/类
@Override
public boolean execute()
    throws Exception {
  String stateValue = _state.toLowerCase();
  if ( ! stateValue.equals("enable") &&
       ! stateValue.equals("disable") &&
       ! stateValue.equals("drop")) {
    throw new IllegalArgumentException("Invalid value for state: " + _state
    + "\n Value must be one of enable|disable|drop");
  }
  HttpClient httpClient = new HttpClient();
  HttpURL url = new HttpURL(_controllerHost,
      Integer.parseInt(_controllerPort),
      URI_TABLES_PATH + _tableName);
  url.setQuery("state", stateValue);
  GetMethod httpGet = new GetMethod(url.getEscapedURI());
  int status = httpClient.executeMethod(httpGet);
  if (status != 200) {
    throw new RuntimeException(
        "Failed to change table state, error: " + httpGet.getResponseBodyAsString());
  }
  return true;
}
 

import org.apache.commons.httpclient.HttpURL; //导入依赖的package包/类
@Override
public boolean execute() throws Exception {
  if (_controllerHost == null) {
    _controllerHost = NetUtil.getHostAddress();
  }

  String stateValue = _state.toLowerCase();
  if (!stateValue.equals("enable")
      && !stateValue.equals("disable")
      && !stateValue.equals("drop")) {
    throw new IllegalArgumentException("Invalid value for state: " + _state
        + "\n Value must be one of enable|disable|drop");
  }
  HttpClient httpClient = new HttpClient();
  HttpURL url = new HttpURL(_controllerHost,
      Integer.parseInt(_controllerPort),
      URI_TABLES_PATH + _tableName);
  url.setQuery("state", stateValue);
  GetMethod httpGet = new GetMethod(url.getEscapedURI());
  int status = httpClient.executeMethod(httpGet);
  if (status != 200) {
    throw new RuntimeException(
        "Failed to change table state, error: " + httpGet.getResponseBodyAsString());
  }
  return true;
}
 

import org.apache.commons.httpclient.HttpURL; //导入依赖的package包/类
protected void downloadFile(HttpURL url, 
                            String relativePath, 
                            CollectionScanner scanner) 
   throws IOException
{
   File target = new File(this.toDir, relativePath);
   
   long lastMod = scanner.getProperties().getLastModified(url.toString());
   
   if (shallWeGetIt(target, lastMod)) {
      getAndStoreResource(url, target, lastMod, relativePath);
   } else {
      log("Omitted: " + relativePath + " (uptodate)", ifVerbose());
      this.countOmittedFiles++;
   }
}
 

import org.apache.commons.httpclient.HttpURL; //导入依赖的package包/类
/**
 * Retrieves the data of a resource and stores it in a file.
 * 
 * Creates required directories and sets the last modified time of the file.
 * 
 * @param url path of the resource to be retrieved
 * @param target file where the resource data ist stored
 * @param lastMod last modified date of the resource, used to set 
 *        the last modified date of the target file
 * @param relative path og the resource for logging purposes.
 * @throws IOException
 * @throws HttpException
 * @throws FileNotFoundException
 */
private void getAndStoreResource(HttpURL url, File target, long lastMod, String relative) 
   throws IOException, HttpException, FileNotFoundException 
{
   log("downloading: " + relative, ifVerbose());
   File directory = target.getParentFile();
   if (!directory.exists()) {
      directory.mkdirs();
   }
   
   InputStream in = Utils.getFile(getHttpClient(), url);
   
   if (!target.exists()) {
      target.createNewFile();
   }
   FileOutputStream out = new FileOutputStream(target);
   
   copyStream(in, out, this.filterSets, this.encoding);
   
   out.close();
   target.setLastModified(lastMod);
   this.countWrittenFiles++;
}
 

import org.apache.commons.httpclient.HttpURL; //导入依赖的package包/类
/**
 * Returns <code>true</code> if the resource given as URL does exist.
 * @param client
 * @param httpURL
 * @return <code>true</code>if the resource exists
 * @throws IOException
 * @throws HttpException
 */
public static boolean resourceExists(HttpClient client, HttpURL httpURL)
   throws IOException, HttpException
{
   HeadMethod head = new HeadMethod(httpURL.getURI());
   head.setFollowRedirects(true);
   int status = client.executeMethod(head);
   
   switch (status) {
      case WebdavStatus.SC_OK:
         return true;
      case WebdavStatus.SC_NOT_FOUND:
         return false;
      default:
         HttpException ex = new HttpException();
         ex.setReasonCode(status);
         ex.setReason(head.getStatusText());
         throw ex;
   }
}
 

import org.apache.commons.httpclient.HttpURL; //导入依赖的package包/类
public static void putFile(HttpClient client, 
                           HttpURL url, 
                           InputStream is,
                           String contentType,
                           String lockToken)
   throws IOException, HttpException
{
   PutMethod put = new PutMethod(url.getURI());
   generateIfHeader(put, lockToken);
   put.setRequestHeader("Content-Type", contentType);
   put.setRequestBody(is);
   put.setFollowRedirects(true);
   int status = client.executeMethod(put);
   switch (status) {
      case WebdavStatus.SC_OK:
      case WebdavStatus.SC_CREATED:
      case WebdavStatus.SC_NO_CONTENT:
         return;
      default:
         HttpException ex = new HttpException();
         ex.setReason(put.getStatusText());
         ex.setReasonCode(status);
         throw ex;
   }
}
 

import org.apache.commons.httpclient.HttpURL; //导入依赖的package包/类
public static InputStream getFile(HttpClient client, HttpURL url)
   throws IOException, HttpException
{
   GetMethod get = new GetMethod(url.toString());
   get.setFollowRedirects(true);
   int status = client.executeMethod(get);
   
   switch (status) {
      case WebdavStatus.SC_OK:
         return get.getResponseBodyAsStream();
      default:
         HttpException ex = new HttpException();
         ex.setReason(get.getStatusText());
         ex.setReasonCode(status);
         throw ex;
   }
   
}
 

import org.apache.commons.httpclient.HttpURL; //导入依赖的package包/类
public static void unlockResource(HttpClient client, HttpURL url, 
                                  String lockToken)
   throws IOException, HttpException
{
   UnlockMethod unlock = new UnlockMethod(url.getURI(), lockToken);
   unlock.setFollowRedirects(true);
   int status = client.executeMethod(unlock);
   
   switch (status) {
      case WebdavStatus.SC_OK:
      case WebdavStatus.SC_NO_CONTENT:
         return;
      
      default:
         HttpException ex = new HttpException();
         ex.setReasonCode(status);
         ex.setReason(unlock.getStatusText());
         throw ex;
   }
}
 

import org.apache.commons.httpclient.HttpURL; //导入依赖的package包/类
public static void copyResource(HttpClient client, HttpURL url, 
                                String destination, int depth, boolean overwrite)
   throws IOException, HttpException 
{
   CopyMethod copy = new CopyMethod(
           url.getURI(), 
           destination, 
           overwrite, 
           depth);
   copy.setFollowRedirects(true);
   int status = client.executeMethod(copy);
   switch (status) {
      case WebdavStatus.SC_OK:
      case WebdavStatus.SC_CREATED:
      case WebdavStatus.SC_NO_CONTENT:
          return;
      
      default:
          HttpException ex = new HttpException();
          ex.setReasonCode(status);
          ex.setReason(copy.getStatusText());
          throw ex;
   }
}
 

import org.apache.commons.httpclient.HttpURL; //导入依赖的package包/类
public static void moveResource(HttpClient client, HttpURL url, 
                                   String destination, boolean overwrite)
      throws IOException, HttpException 
   {
      MoveMethod move = new MoveMethod(url.getURI(), destination, overwrite);
      move.setFollowRedirects(true);
      int status = client.executeMethod(move);
      switch (status) {
         case WebdavStatus.SC_OK:
         case WebdavStatus.SC_CREATED:
         case WebdavStatus.SC_NO_CONTENT:
             return;

         default:
             HttpException ex = new HttpException();
             ex.setReasonCode(status);
             ex.setReason(move.getStatusText());
             throw ex;
   }
}
 

import org.apache.commons.httpclient.HttpURL; //导入依赖的package包/类
public File getParentFile() {
    try {
        HttpURL httpURL = null;
        String parent = null;
        parent = this.getParent();
        if (parent == null) {
            //System.out.println("getParentFile : at root so return null");
            return null;
        } else {
            httpURL = this.rootUrl;
            httpURL.setPath(parent);
            //System.out.println("getParentFile : set path to " + parent);
            return new WebdavFile(httpURL, this.rootUrl);
        }
    } catch (Exception e) {
        System.err.println(e.toString());
        e.printStackTrace();
        return null;
    }

}
 

import org.apache.commons.httpclient.HttpURL; //导入依赖的package包/类
public RootWebdavResource(HttpURL url, String authCookieName,
                          String authCookieValue)
         throws HttpException, IOException
{
    super (url, authCookieName, authCookieValue);
    connectionManager = new MultiThreadedHttpConnectionManager();
}
 

import org.apache.commons.httpclient.HttpURL; //导入依赖的package包/类
public AuthenticatedWebdavResource(AuthenticatedWebdavResource parent,
                                   HttpURL url)
        throws HttpException, IOException
{
    super (parent.connectionManager);
    setupResource(this, url, parent.getAuthCookieName(),
                  parent.getAuthCookieValue());
}