public static void main(String[] args) throws IOException {
Closer closer = Closer.create();
// copy a file
File origin = new File("join_temp");
File copy = new File("target_temp");
try {
BufferedReader reader = new BufferedReader(new FileReader("join_temp"));
BufferedWriter writer = new BufferedWriter(new FileWriter("target_temp"));
closer.register(reader);
closer.register(writer);
String line;
while ((line = reader.readLine()) != null) {
writer.write(line);
}
} catch (IOException e) {
throw closer.rethrow(e);
} finally {
closer.close();
}
Files.copy(origin, copy);
File moved = new File("moved");
// moving renaming
Files.move(copy, moved);
// working files as string
List<String> lines = Files.readLines(origin, Charsets.UTF_8);
HashCode hashCode = Files.hash(origin, Hashing.md5());
System.out.println(hashCode);
// file write and append
String hamlet = "To be, or not to be it is a question\n";
File write_and_append = new File("write_and_append");
Files.write(hamlet, write_and_append, Charsets.UTF_8);
Files.append(hamlet, write_and_append, Charsets.UTF_8);
// write_and_append.deleteOnExit();
Files.write("OverWrite the file", write_and_append, Charsets.UTF_8);
// ByteSource ByteSink
ByteSource fileBytes = Files.asByteSource(write_and_append);
byte[] readBytes = fileBytes.read();
// equals to pre line -> Files.toByteArray(write_and_append) == readBytes
ByteSink fileByteSink = Files.asByteSink(write_and_append);
fileByteSink.write(Files.toByteArray(write_and_append));
BaseEncoding base64 = BaseEncoding.base64();
System.out.println(base64.encode("123456".getBytes()));
}
@Test
public void createByteSourceFromFileTest() throws Exception {
File f1 = new File("src/main/resources/sample.pdf");
ByteSource byteSource = Files.asByteSource(f1);
byte[] readBytes = byteSource.read();
assertThat(readBytes, is(Files.toByteArray(f1)));
}
/**
* Read the contents of the source into a byte array.
*
* @param source the byte array source
* @return the byte[] read from the source or null
*/
private byte[] consumeByteSourceOrNull(final ByteSource source) {
try {
if (source == null || source.isEmpty()) {
return null;
}
return source.read();
} catch (final IOException e) {
logger.warn("Could not consume the byte array source", e);
return null;
}
}
@Override
public void run() {
for (Map.Entry<String, ConfigFileInfo> entry : watchedFileMap.entrySet()) {
String filePath = entry.getKey();
ConfigFileInfo configFileInfo = entry.getValue();
try {
File file = new File(filePath);
long lastModified = file.lastModified();
Preconditions.checkArgument(lastModified > 0L);
if (lastModified != configFileInfo.lastModifiedTimestampMillis) {
configFileInfo.lastModifiedTimestampMillis = lastModified;
ByteSource byteSource = Files.asByteSource(file);
HashCode newContentHash = byteSource.hash(HASH_FUNCTION);
if (!newContentHash.equals(configFileInfo.contentHash)) {
configFileInfo.contentHash = newContentHash;
LOG.info("File {} was modified at {}, notifying watchers.", filePath, lastModified);
byte[] newContents = byteSource.read();
for (Function<byte[], Void> watchers : configFileInfo.changeWatchers) {
try {
watchers.apply(newContents);
} catch (Exception e) {
LOG.error(
"Exception in watcher callback for {}, ignoring. New file contents were: {}",
filePath,
new String(newContents, Charsets.UTF_8),
e);
}
}
} else {
LOG.info(
"File {} was modified at {} but content hash is unchanged.",
filePath,
lastModified);
}
} else {
LOG.debug("File {} not modified since {}", filePath, lastModified);
}
} catch (Exception e) {
// We catch and log exceptions related to the update of any specific file, but
// move on so others aren't affected. Issues can happen for example if the watcher
// races with an external file replace operation; in that case, the next run should
// pick up the update.
// TODO: Consider adding a metric to track this so we can alert on failures.
LOG.error("Config update check failed for {}", filePath, e);
}
}
}
/**
* Adds a watch on the specified file. The file must exist, otherwise a FileNotFoundException is
* returned. If the file is deleted after a watch is established, the watcher will log errors but
* continue to monitor it, and resume watching if it is recreated.
*
* @param filePath path to the file to watch.
* @param onUpdate function to call when a change is detected to the file. The entire contents of
* the file will be passed in to the function. Note that onUpdate will be called once before
* this call completes, which facilities initial load of data. This callback is executed
* synchronously on the watcher thread - it is important that the function be non-blocking.
*/
public synchronized void addWatch(String filePath, Function<byte[], Void> onUpdate)
throws IOException {
MorePreconditions.checkNotBlank(filePath);
Preconditions.checkNotNull(onUpdate);
// Read the file and make the initial onUpdate call.
File file = new File(filePath);
ByteSource byteSource = Files.asByteSource(file);
onUpdate.apply(byteSource.read());
// Add the file to our map if it isn't already there, and register the new change watcher.
ConfigFileInfo configFileInfo = watchedFileMap.get(filePath);
if (configFileInfo == null) {
configFileInfo = new ConfigFileInfo(file.lastModified(), byteSource.hash(HASH_FUNCTION));
watchedFileMap.put(filePath, configFileInfo);
}
configFileInfo.changeWatchers.add(onUpdate);
}