Using Guava CountingOutputStream

Last updated: January 8, 2024

Written by: baeldung

Reviewed by: Tom Hombergs

Java IO

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Overview

In this tutorial, we’re going to look at the CountingOutputStream class and how to use it.

The class can be found in popular libraries like Apache Commons or Google Guava. We’re going focus on the implementation in the Guava library.

2. CountingOutputStream

2.1. Maven Dependency

CountingOutputStream is part of Google’s Guava package.

Let’s start by adding the dependency to the pom.xml:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>32.1.3-jre</version>
</dependency>

The latest version of the dependency can be checked here.

2.2. Class Details

The class extends java.io.FilterOutputStream, overrides the write() and close() methods, and provides the new method getCount().

The constructor takes another OutputStream object as an input parameter. While writing data, the class then counts the number of bytes written into this OutputStream.

In order to get the count, we can simply call getCount() to return the current number of bytes:

/** Returns the number of bytes written. */
public long getCount() {
    return count;
}

3. Use Case

Let’s use CountingOutputStream in a practical use case. For the sake of example, we’re going to put the code into a JUnit test to make it executable.

In our case, we’re going to write data to an OutputStream and check if we have reached a limit of MAX bytes.

Once we reach the limit, we want to break the execution by throwing an exception:

public class GuavaCountingOutputStreamUnitTest {
    static int MAX = 5;

    @Test(expected = RuntimeException.class)
    public void givenData_whenCountReachesLimit_thenThrowException()
      throws Exception {
 
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        CountingOutputStream cos = new CountingOutputStream(out);

        byte[] data = new byte[1024];
        ByteArrayInputStream in = new ByteArrayInputStream(data);
        
        int b;
        while ((b = in.read()) != -1) {
            cos.write(b);
            if (cos.getCount() >= MAX) {
                throw new RuntimeException("Write limit reached");
            }
        }
    }
}

4. Conclusion

In this quick article, we’ve looked at the CountingOutputStream class and its usage. The class provides the additional method getCount() that returns the number of bytes written to the OutputStream so far.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.