下面列出了java.net.URLConnection#getContentLengthLong ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Override
public long contentLength() throws IOException {
URL url = getURL();
if (ResourceUtils.isFileURL(url)) {
// Proceed with file system resolution
File file = getFile();
long length = file.length();
if (length == 0L && !file.exists()) {
throw new FileNotFoundException(getDescription() +
" cannot be resolved in the file system for checking its content length");
}
return length;
}
else {
// Try a URL connection content-length header
URLConnection con = url.openConnection();
customizeConnection(con);
return con.getContentLengthLong();
}
}
/**
* Downloads a file from specified url.
*
* @param url the url to download
* @param output the output location
* @param progress the progress tracker to show download progress
* @throws IOException when IO operation fails in downloading
*/
public static void download(URL url, Path output, Progress progress) throws IOException {
if (Files.exists(output)) {
return;
}
Path dir = output.toAbsolutePath().getParent();
if (dir != null) {
Files.createDirectories(dir);
}
URLConnection conn = url.openConnection();
if (progress != null) {
long contentLength = conn.getContentLengthLong();
if (contentLength > 0) {
progress.reset("Downloading", contentLength, output.toFile().getName());
}
}
try (InputStream is = conn.getInputStream()) {
ProgressInputStream pis = new ProgressInputStream(is, progress);
String fileName = url.getFile();
if (fileName.endsWith(".gz")) {
Files.copy(new GZIPInputStream(pis), output);
} else {
Files.copy(pis, output);
}
}
}
Resource download(URL url, ProgressListener progressListener) throws IOException {
URLConnection connection = connect(url);
try (InputStream is = connection.getInputStream()) {
long totalSize = connection.getContentLengthLong();
Path tempFile = createTempFile(url);
progressListener.start();
try (OutputStream os = Files.newOutputStream(tempFile)) {
byte[] buffer = new byte[8192];
long readBytes = 0;
int read;
while ((read = is.read(buffer)) != -1) {
os.write(buffer, 0, read);
readBytes += read;
if (totalSize > 0 && readBytes > 0) {
progressListener.update(readBytes, totalSize);
}
}
}
if (Thread.interrupted()) {
throw new ClosedByInterruptException();
}
progressListener.finish();
return new FileSystemResource(tempFile);
}
}
public void download() throws IOException {
FileOutputStream fos = new FileOutputStream(destFilename);
URLConnection connection = new URL(url).openConnection();
long fileSize = connection.getContentLengthLong();
InputStream inputStream = connection.getInputStream();
byte[] buffer = new byte[10 * 1024 * 1024];
int numberOfBytesRead;
long totalNumberOfBytesRead = 0;
ConsoleProgressBar bar = new ConsoleProgressBar();
while ((numberOfBytesRead = inputStream.read(buffer)) != -1) {
fos.write(buffer, 0, numberOfBytesRead);
totalNumberOfBytesRead += numberOfBytesRead;
bar.show(totalNumberOfBytesRead * 100 / fileSize);
}
fos.close();
inputStream.close();
}
@Override
protected Void call() throws Exception {
String ext = url.substring(url.lastIndexOf("."), url.length());
URLConnection connection = new URL(url).openConnection();
long fileLength = connection.getContentLengthLong();
try (InputStream is = connection.getInputStream();
OutputStream os = Files.newOutputStream(Paths.get("downloadedfile" + ext))) {
long nread = 0L;
byte[] buf = new byte[8192];
int n;
while ((n = is.read(buf)) > 0) {
os.write(buf, 0, n);
nread += n;
updateProgress(nread, fileLength);
}
}
return null;
}
@Override
public long size()
{
ClassLoader loader = _loader;
URL url = loader.getResource(_path);
if (url == null) {
return -1;
}
else {
try {
URLConnection conn = url.openConnection();
return conn.getContentLengthLong();
/*
Path path = Paths.get(url.toURI());
return Files.size(path);
*/
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
@Override
public long getFileSize(String path, boolean virtual) throws IOException {
long fileSize = -1;
try {
URLConnection urlConnection = getURLConnection(path, virtual);
fileSize = urlConnection.getContentLengthLong();
} catch (IOException e) {
// Ignore this. It will always fail for non-file based includes
}
return fileSize;
}
@Override
public boolean isReadable() {
try {
URL url = getURL();
if (ResourceUtils.isFileURL(url)) {
// Proceed with file system resolution
File file = getFile();
return (file.canRead() && !file.isDirectory());
}
else {
// Try InputStream resolution for jar resources
URLConnection con = url.openConnection();
customizeConnection(con);
if (con instanceof HttpURLConnection) {
HttpURLConnection httpCon = (HttpURLConnection) con;
int code = httpCon.getResponseCode();
if (code != HttpURLConnection.HTTP_OK) {
httpCon.disconnect();
return false;
}
}
long contentLength = con.getContentLengthLong();
if (contentLength > 0) {
return true;
}
else if (contentLength == 0) {
// Empty file or directory -> not considered readable...
return false;
}
else {
// Fall back to stream existence: can we open the stream?
getInputStream().close();
return true;
}
}
}
catch (IOException ex) {
return false;
}
}
@Override
public boolean isReadable() {
try {
URL url = getURL();
if (ResourceUtils.isFileURL(url)) {
// Proceed with file system resolution
File file = getFile();
return (file.canRead() && !file.isDirectory());
}
else {
// Try InputStream resolution for jar resources
URLConnection con = url.openConnection();
customizeConnection(con);
if (con instanceof HttpURLConnection) {
HttpURLConnection httpCon = (HttpURLConnection) con;
int code = httpCon.getResponseCode();
if (code != HttpURLConnection.HTTP_OK) {
httpCon.disconnect();
return false;
}
}
long contentLength = con.getContentLengthLong();
if (contentLength > 0) {
return true;
}
else if (contentLength == 0) {
// Empty file or directory -> not considered readable...
return false;
}
else {
// Fall back to stream existence: can we open the stream?
getInputStream().close();
return true;
}
}
}
catch (IOException ex) {
return false;
}
}
public static Long getContentLength(URL url, boolean isChipsterServer) throws IOException {
URLConnection connection = null;
try {
connection = url.openConnection();
if (isChipsterServer) {
KeyAndTrustManager.configureForChipsterCertificate(connection);
} else {
KeyAndTrustManager.configureForCACertificates(connection);
}
if (connection instanceof HttpURLConnection) {
HttpURLConnection httpConnection = (HttpURLConnection) connection;
// check the response code first because the content length may be the length of the error message
if (httpConnection.getResponseCode() >= 200 && httpConnection.getResponseCode() < 300) {
long contentLength = connection.getContentLengthLong();
if (contentLength >= 0) {
return contentLength;
} else {
throw new IOException("content length not available: " + connection.getContent());
}
} else {
throw new IOException("content length not available: " + httpConnection.getResponseCode() + " " + httpConnection.getResponseMessage());
}
} else {
throw new IOException("the remote content location isn't using http or https protocol: " + url);
}
} finally {
IOUtils.disconnectIfPossible(connection);
}
}
@Override
public String getETag() throws IOException {
URLConnection openConnection = url.openConnection();
openConnection.connect();
String eTag = openConnection.getHeaderField("ETag");
if (eTag != null) {
return eTag;
}
long lastModified = openConnection.getLastModified();
long length = openConnection.getContentLengthLong();
eTag = getSimpleWeakETag(url.toString(), length, lastModified);
return eTag == null ? null : eTag.substring(2);
}
private static void downloadFromServer(@NotNull URL url, long maxFileSize, @NotNull OutputStream outputStream,
@NotNull Function<Double, Double> progressUpdate) throws IOException, NotEnoughFreeSpaceException {
BufferedInputStream in = null;
URLConnection urlConnection = null;
double workDone = 0;
try {
urlConnection = url.openConnection();
in = new BufferedInputStream(urlConnection.getInputStream());
long downloadSize = urlConnection.getContentLengthLong();
if (maxFileSize < downloadSize) {
in.close();
outputStream.close();
urlConnection.getInputStream().close();
throw new NotEnoughFreeSpaceException(ADCUpdater.bundle.getString("Updater.not_enough_free_space"));
}
final byte data[] = new byte[1024];
int count;
while ((count = in.read(data, 0, 1024)) != -1) {
outputStream.write(data, 0, count);
workDone += count;
progressUpdate.apply(workDone / downloadSize);
}
} finally {
if (in != null) {
in.close();
}
if (urlConnection != null) {
urlConnection.getInputStream().close();
}
outputStream.close();
}
}
/**
* Try to obtain the content length from the given URI. Returns -1
* if the content length can not be determined.
*
* @param uri The URI
* @return The content length
*/
public static long getContentLength(URI uri)
{
try
{
URLConnection connection = uri.toURL().openConnection();
return connection.getContentLengthLong();
}
catch (IOException e)
{
return -1;
}
}
public UrlWebResource(final URL url, final String path, final String contentType, final boolean cacheable) {
this.url = checkNotNull(url);
this.path = checkNotNull(path);
this.cacheable = cacheable;
// open connection to get details about the resource
try {
final URLConnection connection = this.url.openConnection();
try (final InputStream ignore = connection.getInputStream()) {
if (Strings.isNullOrEmpty(contentType)) {
this.contentType = connection.getContentType();
}
else {
this.contentType = contentType;
}
// support for legacy int and modern long content-length
long detectedSize = connection.getContentLengthLong();
if (detectedSize == -1) {
detectedSize = connection.getContentLength();
}
this.size = detectedSize;
this.lastModified = connection.getLastModified();
}
}
catch (IOException e) {
throw new IllegalArgumentException("Resource inaccessible: " + url, e);
}
}
@Override
public boolean exists() {
try {
URL url = getURL();
if (ResourceUtils.isFileURL(url)) {
// Proceed with file system resolution
return getFile().exists();
}
else {
// Try a URL connection content-length header
URLConnection con = url.openConnection();
customizeConnection(con);
HttpURLConnection httpCon =
(con instanceof HttpURLConnection ? (HttpURLConnection) con : null);
if (httpCon != null) {
int code = httpCon.getResponseCode();
if (code == HttpURLConnection.HTTP_OK) {
return true;
}
else if (code == HttpURLConnection.HTTP_NOT_FOUND) {
return false;
}
}
if (con.getContentLengthLong() > 0) {
return true;
}
if (httpCon != null) {
// No HTTP OK status, and no content-length header: give up
httpCon.disconnect();
return false;
}
else {
// Fall back to stream existence: can we open the stream?
getInputStream().close();
return true;
}
}
}
catch (IOException ex) {
return false;
}
}
@Override
public boolean exists() {
try {
URL url = getURL();
if (ResourceUtils.isFileURL(url)) {
// Proceed with file system resolution
return getFile().exists();
}
else {
// Try a URL connection content-length header
URLConnection con = url.openConnection();
customizeConnection(con);
HttpURLConnection httpCon =
(con instanceof HttpURLConnection ? (HttpURLConnection) con : null);
if (httpCon != null) {
int code = httpCon.getResponseCode();
if (code == HttpURLConnection.HTTP_OK) {
return true;
}
else if (code == HttpURLConnection.HTTP_NOT_FOUND) {
return false;
}
}
if (con.getContentLengthLong() > 0) {
return true;
}
if (httpCon != null) {
// No HTTP OK status, and no content-length header: give up
httpCon.disconnect();
return false;
}
else {
// Fall back to stream existence: can we open the stream?
getInputStream().close();
return true;
}
}
}
catch (IOException ex) {
return false;
}
}
private void downloadInternal(URL url, File destination) throws IOException {
OutputStream out = null;
URLConnection conn;
InputStream in = null;
try {
//URL url = address.toURL();
conn = url.openConnection();
//user agent
final String userAgentValue = calculateUserAgent();
conn.setRequestProperty("User-Agent", userAgentValue);
//do not set gzip header if download zip file
if (useGzip) {
conn.setRequestProperty("Accept-Encoding", "gzip");
}
if (!useCache) {
conn.setRequestProperty("Pragma", "no-cache");
}
in = conn.getInputStream();
out = new BufferedOutputStream(new FileOutputStream(destination));
copy(in, out);
if(checkContentLength) {
long contentLength = conn.getContentLengthLong();
if (contentLength > 0 && contentLength != destination.length()) {
throw new IllegalArgumentException("File length mismatch. expected: "
+ contentLength + ", actual: " + destination.length());
}
}
if(keepLastModified) {
long lastModified = conn.getLastModified();
if (lastModified > 0) {
destination.setLastModified(lastModified);
}
}
} finally {
logMessage("");
if (in != null) {
in.close();
}
if (out != null) {
out.close();
}
}
}
/** Download an archive, this will NOT overwrite a previously existing file. */
public void download() throws IOException, InterruptedException {
if (!Files.exists(destinationFile.getParent())) {
Files.createDirectories(destinationFile.getParent());
}
if (Files.exists(destinationFile)) {
throw new FileAlreadyExistsException(destinationFile.toString());
}
URLConnection connection = address.openConnection();
connection.setRequestProperty("User-Agent", userAgentString);
try (InputStream in = connection.getInputStream()) {
// note : contentLength can potentially be -1 if it is unknown.
long contentLength = connection.getContentLengthLong();
logger.info("Downloading " + address + " to " + destinationFile);
try (BufferedOutputStream out =
new BufferedOutputStream(
Files.newOutputStream(destinationFile, StandardOpenOption.CREATE_NEW))) {
progressListener.start(
getDownloadStatus(contentLength, Locale.getDefault()), contentLength);
int bytesRead;
byte[] buffer = new byte[BUFFER_SIZE];
while ((bytesRead = in.read(buffer)) != -1) {
if (Thread.currentThread().isInterrupted()) {
logger.warning("Download was interrupted\n");
cleanUp();
throw new InterruptedException("Download was interrupted");
}
out.write(buffer, 0, bytesRead);
progressListener.update(bytesRead);
}
}
}
progressListener.done();
}
@Override
public void runImport ( final ImportContext context, final String configuration ) throws Exception
{
final Configuration cfg = this.gson.fromJson ( configuration, Configuration.class );
logger.debug ( "Get URL: {}", cfg.getUrl () );
final URL url = new URL ( cfg.getUrl () );
final Path file = Files.createTempFile ( "import", null );
final URLConnection con = url.openConnection ();
con.setRequestProperty ( "User-Agent", VersionInformation.USER_AGENT );
String name;
final Context job = context.getJobContext ();
try ( final InputStream in = con.getInputStream ();
OutputStream out = new BufferedOutputStream ( new FileOutputStream ( file.toFile () ) ) )
{
final long length = con.getContentLengthLong ();
if ( length > 0 )
{
job.beginWork ( String.format ( "Downloading %s", Strings.bytes ( length ) ), length );
}
// manual copy
final byte[] buffer = new byte[COPY_BUFFER_SIZE];
int rc;
while ( ( rc = in.read ( buffer ) ) > 0 )
{
out.write ( buffer, 0, rc );
job.worked ( rc );
}
job.complete ();
// get the name inside here, since this will properly clean up if something fails
name = makeName ( cfg, url, con );
if ( name == null )
{
throw new IllegalStateException ( String.format ( "Unable to determine name for %s", cfg.getUrl () ) );
}
}
catch ( final Exception e )
{
logger.debug ( "Failed to download", e );
Files.deleteIfExists ( file );
throw e;
}
context.scheduleImport ( file, name );
}
@Override
protected Mod call() throws Exception {
try {
updateMessage("Preparing");
updateProgress(-1, 100);
updateMessage("Connecting to server");
if (expectedName != null) {
updateTitle("Download " + expectedName + (expectedVersion != null ? "#" + expectedVersion.toString() : ""));
} else {
updateTitle("Download: " + url.toString());
}
URLConnection conn = url.openConnection();
conn.setConnectTimeout(CONNECT_TIMEOUT);
conn.setReadTimeout(READ_TIMEOUT);
conn.connect();
InputStream stream = conn.getInputStream();
long contentLength = conn.getContentLengthLong();
updateProgress(0, contentLength);
downloadingFile = Datastore.getInstance().getFMMDir().resolve("downloads").resolve("Download-tmp-" + random.nextLong() + ".part");
Files.createDirectories(downloadingFile.getParent());
FileOutputStream writer = new FileOutputStream(downloadingFile.toFile());
byte buf[] = new byte[DOWNLOAD_BUFFER_SIZE];
int read = 0;
long totalRead = 0;
updateMessage("Downloading");
started = System.currentTimeMillis();
int currentReadingSpeed = 32;
do {
if (isCancelled()) {
updateMessage("Cancelled");
failed();
return null;
}
read = stream.read(buf, 0, currentReadingSpeed);
if (currentReadingSpeed < DOWNLOAD_BUFFER_SIZE) {
currentReadingSpeed *= 2;
}
if (read > 0) {
totalRead += read;
writer.write(buf, 0, read);
if (System.currentTimeMillis() - lastUpdate > 200) {
updateMessage("Downloading: " + Util.formatBytes(totalRead) + " / " + Util.formatBytes(contentLength));
updateProgress(totalRead, contentLength);
lastUpdate = System.currentTimeMillis();
}
}
} while (read > 0);
ended = System.currentTimeMillis();
updateMessage("Took " + (ended - started) + " ms to download");
updateProgress(totalRead, contentLength);
updateMessage("Installing");
Mod mod = ModpackDetectorVisitor.parseMod(downloadingFile);
if (mod == null) {
updateMessage("File was not a mod");
failed();
} else {
if (expectedName != null) {
if (!expectedName.equals(mod.getName())) {
updateMessage("This file does not contain the expected mod");
failed();
}
}
if (expectedVersion != null) {
if (!expectedVersion.equals(mod.getVersion())) {
updateMessage("This file does not contain the expected version of the mod");
failed();
}
}
mod.setPath(Datastore.getInstance().getFMMDir().resolve("mods").resolve(mod.getName() + "_" + mod.getVersion().toString() + ".zip"));
updateMessage("Done");
succeeded();
return mod;
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}