详解Java Google Guava

Java资料网推荐详解Java Google Guava这篇文章给大家，欢迎收藏Java资料网享受知识的乐趣

详细介绍

        Google Guava是Google为Java开发的开源库集合，它提供了丰富的工具类和集合框架的扩展，旨在提高开发效率和代码质量。Guava包括但不限于集合操作、并发编程辅助、缓存机制、字符串处理、I/O操作、原生类型支持、常见算法实现、函数式编程支持、测试库等模块。其核心设计原则是简化编程模型、减少代码量、提高代码的可读性和可维护性。

使用场景

1. 集合库增强

Guava提供了许多超越Java标准库的集合类，比如Multiset（多重集）、Multimap（多重映射）、ImmutableList、ImmutableSet、ImmutableMap等不可变集合，以及BiMap（双向映射）等。这些集合类型不仅丰富了数据结构的选择，还增强了代码的安全性，比如不可变集合确保了集合创建后不可被修改，这对于多线程环境特别有用。 

包括但不限于以下：

• Immutable Collections（不可变集合）：如ImmutableList, ImmutableSet, ImmutableMap等，提供线程安全且性能高效的不可变集合，适用于常量集合或集合的防御性拷贝。
• Multiset/Multimap（多重集合/映射）：允许一个键对应多个值，适合计数或元素去重等场景。
• BiMap（双向映射）：提供键值互查的能力，即可以从值反向获取键。
• Table（表）：类似于二维数组或映射的映射，支持行列键值。

2. 缓存机制

Guava Cache是实现本地缓存的一个强大工具。它支持自动过期、基于大小的驱逐策略、软引用和弱引用等多种特性，使得开发者可以很容易地实现高性能的数据缓存。通过自定义加载器和监听器，可以进一步定制缓存的行为，比如缓存项失效时的处理逻辑。

3. 并发工具

Guava提供了丰富的并发工具，如ListenableFuture和Service接口，用于异步编程和管理服务生命周期。ListenableFuture扩展了Java的Future接口，增加了回调功能，使得异步操作的结果处理更为灵活。而Service接口及其子类，如AbstractService，简化了服务的启动、停止和状态管理。

• ListenableFuture：扩展了Java的Future接口，增加了回调机制，使得异步编程更加灵活。
• Service框架：提供易于使用的服务生命周期管理工具，如Service和AbstractService。
• RateLimiter：用于控制系统的吞吐量，实现限流功能。
• 并发集合：如ConcurrentHashMultiset, Striped64（用于低锁争用的计数器）等，提供了高性能的并发数据结构。

4. 原子操作与并发对象

Guava中的原子类，如AtomicDouble、AtomicLongMap等，提供了比Java标准库更丰富的原子操作支持。这些类在多线程环境下保证了高性能和线程安全的操作，特别是在计数器、标志位等场景下非常有用。

5. 字符串处理与预编译正则表达式

Guava提供了CharMatcher、Joiner和Splitter等工具，使得字符串操作更加高效和易于阅读。特别是CharMatcher，它提供了强大的字符匹配功能，而Joiner和Splitter则分别简化了字符串的拼接和分割操作。此外，Guava还支持预编译正则表达式，通过Pattern和Matcher的封装，提高了正则表达式的复用性和执行效率。

例：

com.google.common.base.Strings类提供了很多实用的字符串处理方法，如isEmpty(), isNullOrEmpty(), commonPrefix(), commonSuffix()等，简化了字符串操作。

6. 函数式编程支持

虽然不及Java 8及以后版本中的Lambda表达式和Stream API那么直接，Guava提供了Function、Predicate、Supplier等接口，支持函数式编程风格，为Java 7及以下版本的开发者提供了函数式编程的便利。

7. 限流与资源管理

如开头提及，Guava的RateLimiter实现了令牌桶算法，是一种简单有效的限流工具，可以控制服务的访问速率，防止系统过载。这对于保护后端服务免受突发流量冲击尤为重要。

8. 其他实用工具

Guava还包括了很多其他实用工具，如Optional用于优雅地处理null值问题，Range和Ordering用于区间判断和排序，还有类型安全的构建器模式（Builder Pattern）等，这些都是提升代码质量的好帮手。

使用示例：

import com.google.common.base.Preconditions;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.collect.ImmutableList;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;

public class GuavaUsageExample {
    public static void main(String[] args) {
        // 使用Preconditions进行参数检查
        String name = getUserName();
        Preconditions.checkNotNull(name, "用户名不能为空");

        // 使用ImmutableList创建不可变列表
        ImmutableList<String> users = ImmutableList.of("Alice", "Bob", "Charlie");

        // 创建一个简单的缓存
        LoadingCache<String, String> cache = CacheBuilder.newBuilder()
                .maximumSize(100)
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .build(
                        new CacheLoader<String, String>() {
                            public String load(String key) {
                                return createExpensiveObject(key);
                            }
                        });

        String value = cache.getUnchecked("key");
        
        // 异步执行任务
        ListeningExecutorService executor = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(10));
        ListenableFuture<String> future = executor.submit(() -> "Hello Guava");
    }

    private static String getUserName() {
        return "Alice";
    }

    private static String createExpensiveObject(String key) {
        // 模拟耗时操作
        return "Expensive Data for " + key;
    }
}

注意事项

1. 版本兼容性与依赖管理

• 注意事项：Guava的更新较快，不同版本间可能存在API变更，导致项目升级时出现兼容性问题。
• 示例：在Maven项目中使用特定版本的Guava，避免依赖冲突：

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>30.1-jre</version> <!-- 请替换为实际需要的版本 -->
</dependency>

使用<exclusions>标签排除其他库中可能引入的Guava冲突版本。

2. 性能与内存管理

• 注意事项：合理使用不可变集合和其他高性能数据结构，注意它们对内存的影响。
• 示例：使用ImmutableList时，避免频繁创建大量大型不可变集合，可能导致内存占用过高。

// 正确使用不可变集合，避免不必要的内存消耗
ImmutableList<String> names = ImmutableList.of("Alice", "Bob", "Charlie");

3. 并发编程中的异常处理

• 注意事项：在使用ListenableFuture等并发工具时，确保异常得到妥善处理，避免任务执行失败后无响应。
• 示例：使用Futures.addCallback来处理异步任务的完成和异常情况。

ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(10));
ListenableFuture<String> future = service.submit(() -> doSomething());
Futures.addCallback(future, new FutureCallback<String>() {
    @Override
    public void onSuccess(String result) {
        System.out.println("成功：" + result);
    }

    @Override
    public void onFailure(Throwable t) {
        System.err.println("失败：" + t.getMessage());
    }
});

4. 缓存策略选择

• 注意事项：正确配置Guava Cache的大小、过期策略，避免内存泄漏。
• 示例：合理设置缓存的最大大小和过期时间。

LoadingCache<String, ExpensiveObject> cache = CacheBuilder.newBuilder()
        .maximumSize(1000)
        .expireAfterAccess(10, TimeUnit.MINUTES)
        .build(
                new CacheLoader<String, ExpensiveObject>() {
                    public ExpensiveObject load(String key) {
                        return createExpensiveObject(key);
                    }
                });

5. 避免过度封装

• 注意事项：虽然Guava提供了很多高级抽象，但过度使用可能导致代码难以理解和维护。
• 示例：在使用Guava的集合转换时，确保转换的必要性和清晰性。

// 明智地使用转换，保持代码的可读性
List<String> names = Lists.transform(originalList, item -> item.getName()); // 明确转换逻辑

6. 谨慎使用默认值

• 注意事项：使用Optional等工具时，避免滥用默认值，以免掩盖潜在问题。
• 示例：正确使用Optional来避免空指针异常，而不是直接使用默认值。

Optional<String> optional = Optional.ofNullable(getValue());
String value = optional.orElseThrow(() -> new IllegalStateException("Value is required"));

注意：在使用Google Guava时，开发者需综合考虑版本兼容性、性能优化、并发编程的正确性、资源管理、以及代码的可读性和可维护性等多个方面。通过上述示例，可以更好地理解如何在实际开发中运用Guava，同时避免常见陷阱，提升代码质量和应用程序的稳定性。

优缺点

优点

1. 丰富的集合类：Guava提供了如ImmutableList, ImmutableSet, Multiset等，增强了Java集合框架，提高了代码的安全性和性能。

   // 使用ImmutableList创建不可变列表
   ImmutableList<String> names = ImmutableList.of("Alice", "Bob", "Charlie");

2. 强大的缓存功能：Guava Cache提供了自动过期、大小限制、软引用/弱引用等功能，简化了缓存管理。

   LoadingCache<String, String> cache = CacheBuilder.newBuilder()
           .maximumSize(100)
           .expireAfterWrite(10, TimeUnit.MINUTES)
           .build(new CacheLoader<String, String>() {
               public String load(String key) {
                   return expensiveComputation(key);
               }
           });

3. 并发工具：提供了线程池管理、Future扩展（ListenableFuture）、RateLimiter等，简化并发编程。

   ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(10));
   ListenableFuture<String> future = service.submit(() -> "Hello Guava");

4. 实用工具类：如Strings、Preconditions、Objects等，提供了大量简洁、强大的工具方法，提升代码质量。

   String cleanName = Strings.nullToEmpty(dirtyName).trim();

缺点

1. 学习曲线：Guava提供了大量的API，对于新手来说，可能需要一段时间去学习和熟悉。

   应对策略：建议分模块学习，先掌握最常用的功能，如集合、缓存，逐步深入。

2. 版本兼容性：Guava更新频繁，新版本可能引入不兼容变更，影响现有代码。

   应对策略：项目升级Guava版本时，详细阅读版本更新日志，进行充分的测试，确保兼容性。

3. 性能考虑：虽然Guava提供了高性能的数据结构和工具，但不恰当的使用也可能导致性能问题。

   应对策略：合理选择数据结构和工具类，进行性能测试，确保符合性能要求。

解决问题方案

1. 版本冲突问题

问题描述：在项目中引入Guava时，可能与其他第三方库依赖的Guava版本不一致，导致类路径冲突。

解决方案：

• 明确指定版本：在构建工具（如Maven或Gradle）的依赖配置中明确指定Guava的版本，确保项目统一使用一个版本。
• 依赖排除：若第三方库自带了Guava依赖，可通过依赖排除功能排除该库自带的Guava版本，确保使用项目指定的版本。

示例：

<dependencies>
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>30.1-jre</version> <!-- 指定Guava版本 -->
    </dependency>
    <dependency>
        <groupId>some-third-party</groupId>
        <artifactId>library</artifactId>
        <version>1.0</version>
        <exclusions>
            <exclusion>
                <groupId>com.google.guava</groupId>
                <artifactId>guava</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

2. 缓存未按预期工作

问题描述：使用Guava Cache时，可能遇到缓存项没有按预期被加载、过期或被驱逐的情况。

解决方案：

• 检查配置：确保CacheBuilder的配置正确，如maximumSize, expireAfterWrite, refreshAfterWrite等。
• 调试与监控：使用Cache.stats()方法获取统计信息，检查命中率、缺失率等，以诊断问题。

示例：

LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
    .maximumSize(1000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .removalListener(new RemovalListener<Key, Graph>() {
        public void onRemoval(RemovalNotification<Key, Graph> notification) {
            System.out.println(notification.getKey() + " was removed, cause: " + notification.getCause());
        }
    })
    .build(
        new CacheLoader<Key, Graph>() {
            public Graph load(Key key) throws AnyException {
                return createExpensiveGraph(key);
            }
        });

3. 并发编程中的异常丢失

问题描述：使用ListenableFuture或Service时，如果没有正确处理异常，可能导致异常被忽略，难以调试。

解决方案：

• 添加回调处理异常：使用Futures.addCallback为ListenableFuture添加回调，确保异常能得到恰当处理。
• 服务生命周期管理：正确实现Service.Listener来监听服务状态变化，包括异常情况。

示例：

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

    @Override
    public void onFailure(Throwable t) {
        System.err.println("Failure: " + t.getMessage());
        // 正确处理异常
    }
}, MoreExecutors.directExecutor());

4. 性能瓶颈

问题描述：尽管Guava提供了高效的工具，但在特定场景下仍可能出现性能瓶颈，如频繁的不可变集合创建、错误的缓存策略等。

解决方案：

• 性能分析：使用性能分析工具（如VisualVM或JProfiler）定位性能瓶颈。
• 优化数据结构：根据具体需求选择合适的数据结构，比如在频繁修改的场景下，避免使用不可变集合。
• 调整缓存策略：根据实际访问模式调整缓存大小、过期时间等，避免不必要的计算和内存占用。

         Guava是Java开发中非常有价值的工具库，它通过提供高级数据结构、并发工具、实用工具类等，极大地提高了开发效率和代码质量。然而，开发者在享受其便利的同时，也应注意其学习成本、版本兼容性和性能优化等问题，通过合理的使用策略和持续的学习，最大化Guava的效用。

文章来源:https://blog.csdn.net/Rcain_R/article/details/138635483
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：jacktools123@163.com进行投诉反馈，一经查实，立即删除！