Forget Guava: 5 Google Libraries Java Developers Should Know
A look at five Google libraries that could make your life easier.
What are some of the most useful yet unknown Google Java libraries?
If we were to stop someone during an intense hackathon and ask them to name a popular Google Java library, the answer would probably be Guava. It’s no wonder, since its main focus is improving developer productivity. But what about other Google libraries? Have you had a chance to check them out? In the following post we’ll go over some interesting Java libraries from Google, and give you a peek as to what you can do with them.
Adding Another Library to the Mix
First, let’s be clear: we love Guava. It contains some of Google’s core libraries for Java-based projects, such as collections, caching, common annotations, I/O and others. These are useful not just for Google developers, but for the wider community as well. Although it’s not the only cool thing that came out of Google. We’re not talking about driverless cars, Google fiber or project Ara (and we’re still waiting for that last one) – we’re talking about more libraries. The good news is that there’s no need to comb through every available library in order to find the right one, since we did that for you. We chose 5 Google libraries that could make your life easier and code a little bit nicer. Check them out:
1. Dependency Injection – Guice
Guice is a lightweight dependency injection (DI) framework for Java, performing a similar role to Spring’s core Inversion of Control (IOC) library. It’s almost as popular as Guava. If you’re not familiar with it, Guice eases the need for factories and simplifies the use of ‘new’ in your code. In Google’s own words, Guice @Inject is the new new.
While this library won’t absolve you from writing factories, it will help make sure your code is not directly dependent on them. That way, it will be easier to change, unit test and reuse your code.
This library aims to make development and debugging easier and faster. The documentation even claims to help you get a better understanding of your code. Another cool feature Guice offers is generating helpful messages when errors occur, so you’ll have an idea of what happened and how you can solve it.
2. Static Analysis – Error Prone
This open sourced library is a static analysis tool for Java, allowing you to catch common programming mistakes at compile-time. You can be the best developer in your team, but you or one of your colleagues might be pre-occupied by the latest Game of Thrones episode, and make a mistake. In other words, this tool will help you catch mistakes before they become bugs in production and mess up your application. For example, one of the bug patterns it can detect is CannotMockFinalClass – which indicates that Mockito cannot mock final classes:
The Cool Factor
On the official library page you’ll find a list of common errors and their suggested fixes. This means that each error has a solution that someone already thought of, and you can implement it easily in your own code.
3. Meaningful Errors – Truth
Truth is a testing framework, made to help your test and error messages be more readable and discoverable. It generate meaningful error messages that report on why tests fail, while being extensible to new types of objects. Oh, and it comes with the awesome catch phrase “We’ve made failure a strategy”. You can use Truth in place of JUnit’s assertions, FEST, or Hamcrest’s matchers classes, or simply use it the way you see fit for your code. It presents you with a test verb that asserts on a subject, the value or object under test. You can use Truth in order to declare JUnit-style assumptions (and skip test on failure), assertions and exceptions.
4. Language-Agnostic Protocols – Kythe
Kythe provides and supports tools and standards to encourage interoperability (sharing, exchanging and using information between systems) among programs that manipulate source code. An easier way to explain it is to say that this library gives an ecosystem for building tools that work with source code.
The main goal of this library is to provide a standard, language-agnostic interchange mechanism, that will work on any source code. It includes build systems, compilers, interpreters, static analyses, editors, code-review applications and more. That way, you’ll be able to share information with any other system you’d like.
The Cool Factor
5. Serializing Structured Data – Protobuf
Protobuf, the library that’s also known as Protocol Buffers is Google’s language-neutral, platform-neutral, extensible mechanism for serializing structured data. If you’re not sure what it means, Google explains that it’s like XML, only smaller, faster and simpler. If we had to choose a slogan for this library, it would probably be “structure once, use anywhere”, and that’s the best way to describe it. Once you define how you want your data to be structured, you can use special generated source code to read and write from a variety of data streams and using a variety of languages.
The Cool Factor
Full disclosure is in order here: protobuf is one of our favorite libraries here and we can guarantee it will help you make complicated elements a little bit easier.
Did We Forget Anyone?
There are a few well-known companies besides Google that use GWT, such as Ruxit, Go Grid, Whirled and others.
Additional Google Libraries
Following a comment on twitter we’ve decided to add 2 more useful libraries that weren’t mentioned here, thanks @joschi83!
1. AutoValue – A collection of code generators that automate the generation of repetitive Java code.
2. GSON – The popular Java serialization/deserialization library that can convert Java Objects into JSON and back.
There are a lot of Java libraries that can help your code and make it smarter and easier to use. All you have to do is understand what you’re looking for, and see how a certain library can help. If you’re a hardcore Guava fan and couldn’t find anything useful in these other libraries, you should check out some of the lesser-known features of Google Guava that every developer could use.