guava快速入门（三）

Guava工程包含了若干被Google的 Java项目广泛依赖 的核心库，例如：集合 [collections] 、缓存 [caching] 、原生类型支持 [primitives support] 、并发库 [concurrency libraries] 、通用注解 [common annotations] 、字符串处理 [string processing] 、I/O 等等。

guava类似Apache Commons工具集

Cache

缓存在很多场景下都是相当有用的。例如，计算或检索一个值的代价很高，并且对同样的输入需要不止一次获取值的时候，就应当考虑使用缓存。

Guava Cache与ConcurrentMap很相似，但也不完全一样。最基本的区别是ConcurrentMap会一直保存所有添加的元素，直到显式地移除。相对地，Guava Cache为了限制内存占用，通常都设定为自动回收元素。在某些场景下，尽管LoadingCache 不回收元素，它也是很有用的，因为它会自动加载缓存。

Guava Cache是一个全内存的本地缓存实现，它提供了线程安全的实现机制。

通常来说，Guava Cache适用于：

• 你愿意消耗一些内存空间来提升速度。
• 你预料到某些键会被查询一次以上。
• 缓存中存放的数据总量不会超出内存容量。（Guava Cache是单个应用运行时的本地缓存。它不把数据存放到文件或外部服务器。

如果这不符合你的需求，请尝试Memcached这类工具）

Guava Cache有两种创建方式：

• cacheLoader
• callable callback

LoadingCache是附带CacheLoader构建而成的缓存实现

import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;

public class LoadingCacheDemo {

	public static void main(String[] args) {
		LoadingCache<String, String> cache = CacheBuilder.newBuilder().maximumSize(100) // 最大缓存数目
				.expireAfterAccess(2, TimeUnit.SECONDS) // 缓存1秒后过期
				.build(new CacheLoader<String, String>() {
					@Override
					public String load(String key) throws Exception {
						return key;
					}
				});
		cache.put("j", "java");
		cache.put("c", "cpp");
		cache.put("s", "scala");
		cache.put("g", "go");
		try {
			System.out.println(cache.get("j"));
			TimeUnit.SECONDS.sleep(1);
			System.out.println(cache.get("s")); // 1秒后 输出scala
			TimeUnit.SECONDS.sleep(2);
			System.out.println(cache.get("s")); // 2秒后 输出s


		} catch (ExecutionException | InterruptedException e) {
			e.printStackTrace();
		}
	}

}
      

　　返回：

java
scala
s
      

　　回调：

import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;

public class CallbackDemo {

	public static void main(String[] args) {
		Cache<String, String> cache = CacheBuilder.newBuilder().maximumSize(100)
				.expireAfterAccess(1, TimeUnit.SECONDS)
				.build();
		try {
			String result = cache.get("java", () -> "hello java");
			System.out.println(result);
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
	}

}
      

　　

refresh机制： 

- LoadingCache.refresh(K) 在生成新的value的时候，旧的value依然会被使用。 

- CacheLoader.reload(K, V) 生成新的value过程中允许使用旧的value 

- CacheBuilder.refreshAfterWrite(long, TimeUnit) 自动刷新cache

并发

ListenableFuture

传统JDK中的Future通过异步的方式计算返回结果:在多线程运算中可能或者可能在没有结束返回结果，Future是运行中的多线程的一个引用句柄，确保在服务执行返回一个Result。

ListenableFuture可以允许你注册回调方法(callbacks)，在运算（多线程执行）完成的时候进行调用, 或者在运算（多线程执行）完成后立即执行。这样简单的改进，使得可以明显的支持更多的操作，这样的功能在JDK concurrent中的Future是不支持的。

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;

import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;

public class ListenableFutureDemo {

	public static void main(String[] args) {
		// 将ExecutorService装饰成ListeningExecutorService
		ListeningExecutorService service = MoreExecutors.
				listeningDecorator(Executors.newCachedThreadPool());

		// 通过异步的方式计算返回结果
		ListenableFuture<String> future = service.submit(() -> {
			System.out.println("call execute..");
			return "task success!";
		});

		// 有两种方法可以执行此Future并执行Future完成之后的回调函数
		future.addListener(() -> { // 该方法会在多线程运算完的时候,指定的Runnable参数传入的对象会被指定的Executor执行
			try {
				System.out.println("result: " + future.get());
			} catch (InterruptedException | ExecutionException e) {
				e.printStackTrace();
			}
		}, service);

		Futures.addCallback(future, new FutureCallback<String>() {
			@Override
			public void onSuccess( String result) {
				System.out.println("callback result: " + result);
			}

			@Override
			public void onFailure(Throwable t) {
				System.out.println(t.getMessage());
			}
		}, service);
	}

}
      

call execute..
result: task success!
callback result: task success!
      

IO

import java.io.File;
import java.io.IOException;
import java.util.List;

import com.google.common.base.Charsets;
import com.google.common.collect.ImmutableList;
import com.google.common.io.Files;

public class FileDemo {

	public static void main(String[] args) {
		File file = new File(System.getProperty("user.dir"));
		System.out.println(file.getName());
		System.out.println(file.getPath());
	}

	// 写文件
	private void writeFile(String content, File file) throws IOException {
		if (!file.exists()) {
			file.createNewFile();
		}
		Files.write(content.getBytes(Charsets.UTF_8), file);
	}

	// 读文件
	private List<String> readFile(File file) throws IOException {
		if (!file.exists()) {
			return ImmutableList.of(); // 避免返回null
		}
		return Files.readLines(file, Charsets.UTF_8);
	}

	// 文件复制
	private void copyFile(File from, File to) throws IOException {
		if (!from.exists()) {
			return;
		}
		if (!to.exists()) {
			to.createNewFile();
		}
		Files.copy(from, to);
	}

}
      

collection-others
D:\GITHUB\java\code\test01\collection-others
      

参考：

Google Guava官方教程（中文版） guava-importnew