Java Closer类代码示例

import com.google.common.io.Closer; //导入依赖的package包/类
/**
 * Write the dex program resources to @code{archive} and the proguard resource as its sibling.
 */
public void writeToZip(Path archive, OutputMode outputMode) throws IOException {
  OpenOption[] options =
      new OpenOption[] {StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING};
  try (Closer closer = Closer.create()) {
    try (ZipOutputStream out = new ZipOutputStream(Files.newOutputStream(archive, options))) {
      List<Resource> dexProgramSources = getDexProgramResources();
      for (int i = 0; i < dexProgramSources.size(); i++) {
        ZipEntry zipEntry = new ZipEntry(outputMode.getOutputPath(dexProgramSources.get(i), i));
        byte[] bytes =
            ByteStreams.toByteArray(closer.register(dexProgramSources.get(i).getStream()));
        zipEntry.setSize(bytes.length);
        out.putNextEntry(zipEntry);
        out.write(bytes);
        out.closeEntry();
      }
    }
  }
}
 

import com.google.common.io.Closer; //导入依赖的package包/类
/**
 * Zips an entire directory specified by the path.
 *
 * @param sourceDirectory the directory to read from. This directory and all
 *     subdirectories will be added to the zip-file. The path within the zip
 *     file is relative to the directory given as parameter, not absolute.
 * @param zipFile the zip-file to write to.
 * @throws IOException the zipping failed, e.g. because the input was not
 *     readable.
 */
static void zipDirectory(
    File sourceDirectory,
    File zipFile) throws IOException {
  checkNotNull(sourceDirectory);
  checkNotNull(zipFile);
  checkArgument(
      sourceDirectory.isDirectory(),
      "%s is not a valid directory",
      sourceDirectory.getAbsolutePath());
  checkArgument(
      !zipFile.exists(),
      "%s does already exist, files are not being overwritten",
      zipFile.getAbsolutePath());
  Closer closer = Closer.create();
  try {
    OutputStream outputStream = closer.register(new BufferedOutputStream(
        new FileOutputStream(zipFile)));
    zipDirectory(sourceDirectory, outputStream);
  } catch (Throwable t) {
    throw closer.rethrow(t);
  } finally {
    closer.close();
  }
}
 

import com.google.common.io.Closer; //导入依赖的package包/类
@Override
public boolean load(final BuildCacheKey key, final BuildCacheEntryReader reader) throws BuildCacheException {
    return persistentCache.useCache("load build cache entry", new Factory<Boolean>() {
        @Override
        public Boolean create() {
            File file = getFile(key.getHashCode());
            if (file.isFile()) {
                try {
                    Closer closer = Closer.create();
                    FileInputStream stream = closer.register(new FileInputStream(file));
                    try {
                        reader.readFrom(stream);
                        return true;
                    } finally {
                        closer.close();
                    }
                } catch (IOException ex) {
                    throw new UncheckedIOException(ex);
                }
            }
            return false;
        }
    });
}
 

import com.google.common.io.Closer; //导入依赖的package包/类
@Override
public void store(final BuildCacheKey key, final BuildCacheEntryWriter result) throws BuildCacheException {
    persistentCache.useCache("store build cache entry", new Runnable() {
        @Override
        public void run() {
            File file = getFile(key.getHashCode());
            try {
                Closer closer = Closer.create();
                OutputStream output = closer.register(new FileOutputStream(file));
                try {
                    result.writeTo(output);
                } finally {
                    closer.close();
                }
            } catch (IOException ex) {
                throw new UncheckedIOException(ex);
            }
        }
    });
}
 

import com.google.common.io.Closer; //导入依赖的package包/类
public static void main(String[] args)
    throws IOException, ProguardRuleParserException, CompilationException, ExecutionException {
  Command.Builder builder = Command.parse(args);
  Command command = builder.build();
  if (command.isPrintHelp()) {
    System.out.println(Command.USAGE_MESSAGE);
    return;
  }
  AndroidApp app = command.getInputApp();
  Map<String, Integer> result = new HashMap<>();
  try (Closer closer = Closer.create()) {
    for (Resource resource : app.getDexProgramResources()) {
      for (Segment segment: DexFileReader.parseMapFrom(closer.register(resource.getStream()))) {
        int value = result.computeIfAbsent(segment.typeName(), (key) -> 0);
        result.put(segment.typeName(), value + segment.size());
      }
    }
  }
  System.out.println("Segments in dex application (name: size):");
  result.forEach( (key, value) -> System.out.println(" - " + key + ": " + value));
}
 

import com.google.common.io.Closer; //导入依赖的package包/类
@Test
public void buildAndTreeShakeFromDeployJar()
    throws ExecutionException, IOException, ProguardRuleParserException, CompilationException {
  int maxSize = 20000000;
  AndroidApp app = runAndCheckVerification(
      CompilerUnderTest.R8,
      CompilationMode.RELEASE,
      BASE + APK,
      null,
      BASE + PG_CONF,
      null,
      // Don't pass any inputs. The input will be read from the -injars in the Proguard
      // configuration file.
      ImmutableList.of());
  int bytes = 0;
  try (Closer closer = Closer.create()) {
    for (Resource dex : app.getDexProgramResources()) {
      bytes += ByteStreams.toByteArray(closer.register(dex.getStream())).length;
    }
  }
  assertTrue("Expected max size of " + maxSize + ", got " + bytes, bytes < maxSize);
}
 

import com.google.common.io.Closer; //导入依赖的package包/类
public void assertIdenticalApplications(AndroidApp app1, AndroidApp app2, boolean write)
    throws IOException {
  try (Closer closer = Closer.create()) {
    if (write) {
      app1.writeToDirectory(temp.newFolder("app1").toPath(), OutputMode.Indexed);
      app2.writeToDirectory(temp.newFolder("app2").toPath(), OutputMode.Indexed);
    }
    List<Resource> files1 = app1.getDexProgramResources();
    List<Resource> files2 = app2.getDexProgramResources();
    assertEquals(files1.size(), files2.size());
    for (int index = 0; index < files1.size(); index++) {
      InputStream file1 = closer.register(files1.get(index).getStream());
      InputStream file2 = closer.register(files2.get(index).getStream());
      byte[] bytes1 = ByteStreams.toByteArray(file1);
      byte[] bytes2 = ByteStreams.toByteArray(file2);
      assertArrayEquals("File index " + index, bytes1, bytes2);
    }
  }
}
 

import com.google.common.io.Closer; //导入依赖的package包/类
private static void writeSelfReferencingJarFile(File jarFile, String... entries)
    throws IOException {
  Manifest manifest = new Manifest();
  // Without version, the manifest is silently ignored. Ugh!
  manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");
  manifest.getMainAttributes().put(Attributes.Name.CLASS_PATH, jarFile.getName());

  Closer closer = Closer.create();
  try {
    FileOutputStream fileOut = closer.register(new FileOutputStream(jarFile));
    JarOutputStream jarOut = closer.register(new JarOutputStream(fileOut));
    for (String entry : entries) {
      jarOut.putNextEntry(new ZipEntry(entry));
      Resources.copy(ClassPathTest.class.getResource(entry), jarOut);
      jarOut.closeEntry();
    }
  } catch (Throwable e) {
    throw closer.rethrow(e);
  } finally {
    closer.close();
  }
}
 

import com.google.common.io.Closer; //导入依赖的package包/类
@Override
@NonNull
public Properties loadProperties(@NonNull File file) {
    Properties props = new Properties();
    Closer closer = Closer.create();
    try {
        FileInputStream fis = closer.register(new FileInputStream(file));
        props.load(fis);
    } catch (IOException ignore) {
    } finally {
        try {
            closer.close();
        } catch (IOException e) {
        }
    }
    return props;
}
 

import com.google.common.io.Closer; //导入依赖的package包/类
@Before
public void setUp() {
  executor = createMock(DelayExecutor.class);
  clock = new FakeClock();
  stateManager = createMock(StateManager.class);
  storageUtil = new StorageTestUtil(this);
  storageUtil.expectOperations();
  shutdownCommand = createMock(Command.class);
  pruner = new TaskHistoryPruner(
      executor,
      stateManager,
      clock,
      new HistoryPrunnerSettings(ONE_DAY, ONE_MINUTE, PER_JOB_HISTORY),
      storageUtil.storage,
      new Lifecycle(shutdownCommand));
  closer = Closer.create();
}
 

import com.google.common.io.Closer; //导入依赖的package包/类
private static DockerRunner createDockerRunner(
    String id,
    Environment environment,
    StateManager stateManager,
    ScheduledExecutorService scheduler,
    Stats stats,
    Debug debug) {
  final Config config = environment.config();
  final Closer closer = environment.closer();

  if (isDevMode(config)) {
    LOG.info("Creating LocalDockerRunner");
    return closer.register(DockerRunner.local(scheduler, stateManager));
  } else {
    final NamespacedKubernetesClient kubernetes = closer.register(getKubernetesClient(
        config, id, createGkeClient(), DefaultKubernetesClient::new));
    final ServiceAccountKeyManager serviceAccountKeyManager = createServiceAccountKeyManager();
    return closer.register(DockerRunner.kubernetes(kubernetes, stateManager, stats,
        serviceAccountKeyManager, debug));
  }
}
 

import com.google.common.io.Closer; //导入依赖的package包/类
/**
 * Creates a session and ensures schema if configured. Closes the cluster and session if any
 * exception occurred.
 */
@Override public Session create(Cassandra3Storage cassandra) {
  Closer closer = Closer.create();
  try {
    Cluster cluster = closer.register(buildCluster(cassandra));
    cluster.register(new QueryLogger.Builder().build());
    Session session;
    if (cassandra.ensureSchema) {
      session = closer.register(cluster.connect());
      Schema.ensureExists(cassandra.keyspace, session);
      session.execute("USE " + cassandra.keyspace);
    } else {
      session = cluster.connect(cassandra.keyspace);
    }

    initializeUDTs(session);

    return session;
  } catch (RuntimeException e) {
    try {
      closer.close();
    } catch (IOException ignored) {
    }
    throw e;
  }
}
 

import com.google.common.io.Closer; //导入依赖的package包/类
/**
 * Creates a session and ensures schema if configured. Closes the cluster and session if any
 * exception occurred.
 */
@Override public Session create(CassandraStorage cassandra) {
  Closer closer = Closer.create();
  try {
    Cluster cluster = closer.register(buildCluster(cassandra));
    cluster.register(new QueryLogger.Builder().build());
    if (cassandra.ensureSchema) {
      Session session = closer.register(cluster.connect());
      Schema.ensureExists(cassandra.keyspace, session);
      session.execute("USE " + cassandra.keyspace);
      return session;
    } else {
      return cluster.connect(cassandra.keyspace);
    }
  } catch (RuntimeException e) {
    try {
      closer.close();
    } catch (IOException ignored) {
    }
    throw e;
  }
}
 

import com.google.common.io.Closer; //导入依赖的package包/类
/**
 * Deflater 压缩
 *
 * @param content
 * @return
 */
public static byte[] compress(String content) {
    Closer closer = Closer.create();
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    Deflater deflater = new Deflater(Deflater.BEST_COMPRESSION, true);
    try {
        DeflaterOutputStream out = closer.register(new DeflaterOutputStream(byteArrayOutputStream, deflater));
        out.write(content.getBytes(Charsets.UTF_8.name()));
    } catch (Exception e) {
        logger.error(String.format("compress error:"), e);
    } finally {
        if (closer != null)
            try {
                closer.close();
            } catch (Exception ex) {
                logger.info(String.format("compress error,close the stream error:"), ex);
            }
    }
    deflater.end();
    return byteArrayOutputStream.toByteArray();
}
 

import com.google.common.io.Closer; //导入依赖的package包/类
/**
     * inflater 解压
     *
     * @param inputStream
     * @return
     */
    public static byte[] decompress(InputStream inputStream) {
        Closer closer = Closer.create();
        try {
            BufferedInputStream bufferInputStream = closer.register(new BufferedInputStream(new InflaterInputStream(inputStream, new Inflater(true))));
//			bufferInputStream = closer.register(new BufferedInputStream(new GZIPInputStream(inputStream)));
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            ByteStreams.copy(bufferInputStream, byteArrayOutputStream);
            return byteArrayOutputStream.toByteArray();
        } catch (Exception e) {
            logger.error(String.format("decompress error:"), e);
        } finally {
            try {
                if (closer != null) {
                    closer.close();
                }
            } catch (Exception e1) {
                logger.error(String.format("decompress error,close the stream error"), e1);
            }
        }
        return null;
    }