SLF4J

The Simple Logging Facade for Java (SLF4J) serves as a simple facade or abstraction for various logging frameworks (e.g. java.util.logging, logback, log4j) allowing the end user to plug in the desired logging framework at deployment time.

Before you start using SLF4J, we highly recommend that you read the two-page SLF4J user manual.

Note that SLF4J-enabling your library implies the addition of only a single mandatory dependency, namely slf4j-api.jar. If no binding is found on the class path, then SLF4J will default to a no-operation implementation.

In case you wish to migrate your Java source files to SLF4J, consider our migrator tool which can migrate your project to use the SLF4J API in just a few minutes.

In case an externally-maintained component you depend on uses a logging API other than SLF4J, such as commons logging, log4j or java.util.logging, have a look at SLF4J's binary-support for legacy APIs.

http://www.slf4j.org/

Delombok

Normally, lombok adds support for all the lombok features directly to your IDE and compiler by plugging into them.However, lombok doesn't cover all tools. For example, lombok cannot plug into javadoc, nor can it plug into the Google Widget Toolkit, both of which run on java sources. Delombok still allows you to use lombok with these tools by preprocessing your java code into java code with all of lombok's transformations already applied.

Delombok can of course also help understand what's happening with your source by letting you look at exactly what lombok is doing 'under the hood'.

Delombok's standard mode of operation is that it copies an entire directory into another directory, recursively, skipping class files, and applying lombok transformations to any java source files it encounters.

Delombok's output format can be configured with command line options (use --format-help for a complete list). A few such options are automatically scanned from input if possible (such as indent). If delombok's formatting is not conforming to your preferred code style, have a look!

http://projectlombok.org/features/delombok.html

JFreeSVG

JFreeSVG is a fast, light-weight, vector graphics library for the Java(tm) platform that makes it easy to generate graphical output in SVG format directly from Java code. The library contains:


SVGGraphics2D - generate Scalable Vector Graphics (SVG) output via standard Java2D API calls;
CanvasGraphics2D - generate Javascript code that draws to an HTML5 Canvas object;

JFreeSVG is free software under the terms of the GNU Affero General Public Licence(AGPL) version 3 or later. For those that do not wish to be bound by the terms of the AGPL, an alternative licence is available to purchase.

http://www.jfree.org/jfreesvg/

Lombok

Reducing Boilerplate Code with Project Lombok

http://jnb.ociweb.com/jnb/jnbJan2010.html

JSON-lib

JSON-lib is a java library for transforming beans, maps, collections, java arrays and XML to JSON and back again to beans and DynaBeans.
It is based on the work by Douglas Crockford in http://www.json.org/java.

http://json-lib.sourceforge.net/

Libjitsi

libjitsi is an advanced Java media library for secure real-time audio/video communication. It allows applications to capture, playback, stream, encode/decode and encrypt audio and video flows. It also allows for advanced features such as audio mixing, handling multiple streams, participation in audio and video conferences.

Originally libjitsi was part of the Jitsi client source code but we decided to spin it off so that other projects can also use it.

libjitsi is distributed under the terms of the LGPL.

https://jitsi.org/Projects/LibJitsi

Apache Commons

The Commons Proper is dedicated to one principal goal: creating and maintaining reusable Java components. The Commons Proper is a place for collaboration and sharing, where developers from throughout the Apache community can work together on projects to be shared by the Apache projects and Apache users.

Commons developers will make an effort to ensure that their components have minimal dependencies on other libraries, so that these components can be deployed easily. In addition, Commons components will keep their interfaces as stable as possible, so that Apache users (including other Apache projects) can implement these components without having to worry about changes in the future.

This article gives an overview of (some of) the components which can be found here.

http://commons.apache.org/

ORM Lite

Object Relational Mapping Lite (ORM Lite) provides some simple, lightweight functionality for persisting Java objects to SQL databases while avoiding the complexity and overhead of more standard ORM package

http://ormlite.com/

JFreeChart

JFreeChart is a free 100% Java chart library that makes it easy for developers to display professional quality charts in their applications. JFreeChart's extensive feature set includes:

• a consistent and well-documented API, supporting a wide range of chart types;
• a flexible design that is easy to extend, and targets both server-side and client-side applications;
• support for many output types, including Swing components, image files (including PNG and JPEG), and vector graphics file formats (including PDF, EPS and SVG);
• JFreeChart is "open source" or, more specifically, free software. It is distributed under the terms of the GNU Lesser General Public Licence (LGPL), which permits use in proprietary applications.

http://www.jfree.org/jfreechart/

jPod intarsys PDF library

Pod is a rich PDF manipulation and rendering framework. A complete rendering library based on jPod 

http://sourceforge.net/projects/jpodlib/

Joda-Time

Joda-Time provides a quality replacement for the Java date and time classes. The design allows for multiple calendar systems, while still providing a simple API. The 'default' calendar is the ISO8601 standard which is used by XML. The Gregorian, Julian, Buddhist, Coptic, Ethiopic and Islamic systems are also included, and we welcome further additions. Supporting classes include time zone, duration, format and parsing.

http://www.joda.org/joda-time/

XStream

Stream is a simple library to serialize objects to XML and back again.

http://xstream.codehaus.org/

StringTemplate

StringTemplate is a java template engine (with ports for C#, Python) for generating source code, web pages, emails, or any other formatted text output. StringTemplate is particularly good at code generators, multiple site skins, and internationalization / localization. StringTemplate also powers ANTLR.

http://www.stringtemplate.org/

ANTLR

What is ANTLR?

ANTLR (ANother Tool for Language Recognition) is a powerful parser generator for reading, processing, executing, or translating structured text or binary files. It's widely used to build languages, tools, and frameworks. From a grammar, ANTLR generates a parser that can build and walk parse trees.

http://www.antlr.org/

Smack

Smack is an Open Source XMPP (Jabber) client library for instant messaging and presence. A pure Java library, it can be embedded into your applications to create anything from a full XMPP client to simple XMPP integrations such as sending notification messages and presence-enabling devices.

http://www.igniterealtime.org/projects/smack/

jcodec

Codec is an open source pure java implementation of video and audio codecs and formats.

Features 

Roadmap 

H.264 ( AVC ) Main profile decoder 

MP3 decoder/encoder 

Apple ProRes decoder and encoder 

AAC encoder 

H264 Baseline profile encoder 

Matroska ( MKV ) demuxer and muxer 

MP4 ( ISO BMF, QuickTime ) demuxer/muxer and tools 

MPEG 1/2 decoder ( supports interlace ) 

MPEG PS/TS demuxer 

Java player applet 

VP8 encoder 

MXF demuxer

https://github.com/jcodec/jcodec

Smaxe

Smaxe Ltd provides solutions for rich media, web-conference product implementation for Java:

Libraries (SDK) for J2SE

JUV RTMP Client - lightweight Java RTMP Client SDK.

JUV RTSP/RTP Client - lightweight Java RTSP/RTP Client SDK.

JUV Media SDK - pure Java SDK to read/write media files, decode and play audio/video stream.

JUV Webcam SDK - Java Webcam Capture SDK (based on open-source BridJ library).

Libraries (SDK) for J2ME

JUV RTMP Client (J2ME edition) - lightweight J2ME RTMP Client SDK for J2ME midlets.

Applications

JUV RTMP Researcher - RTMP protocol sniffer/debugger application for Win/Mac/Linux.

JUV RTSP/RTP Researcher - RTSP/RTP protocol sniffer/debugger application for Win/Mac/Linux.

JUV WebSocket Researcher - WebSocket protocol sniffer/debugger application for Win/Mac/Linux.

Tools

JUV RTMP Tester - RTMP server-side functional/regression/load testing tool.

Freeware

JUV FLV Tool - freeware library that lets you process audio/video FLV files.

JUV RTMP Downloader - freeware Java library (built on top of JUV RTMP Client library) that lets you download RTMP streams (both Video-On-Demand and live).

JUV RTMP LoadTester (Lite) - freeware Java tool (built on top of JUV RTMP Tester library) that lets you load-test the VOD/Live stream playback functionality of the RTMP server.

Open Source Solutions

SolrTM

SolrTM is the popular, blazing fast open source enterprise search platform from the Apache LuceneTMproject. Its major features include powerful full-text search, hit highlighting, faceted search, near real-time indexing, dynamic clustering, database integration, rich document (e.g., Word, PDF) handling, and geospatial search. Solr is highly reliable, scalable and fault tolerant, providing distributed indexing, replication and load-balanced querying, automated failover and recovery, centralized configuration and more. Solr powers the search and navigation features of many of the world's largest internet sites.

Solr is written in Java and runs as a standalone full-text search server within a servlet container such as Jetty. Solr uses the Lucene Java search library at its core for full-text indexing and search, and has REST-like HTTP/XML and JSON APIs that make it easy to use from virtually any programming language. Solr's powerful external configuration allows it to be tailored to almost any type of application without Java coding, and it has an extensive plugin architecture when more advanced customization is required.

http://lucene.apache.org/solr/

Lucene

Apache LuceneTM is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.

Lucene offers powerful features through a simple API:

Scalable, High-Performance Indexing

over 150GB/hour on modern hardware

small RAM requirements -- only 1MB heap

incremental indexing as fast as batch indexing

index size roughly 20-30% the size of text indexed

Powerful, Accurate and Efficient Search Algorithms

ranked searching -- best results returned first

many powerful query types: phrase queries, wildcard queries, proximity queries, range queries and more

fielded searching (e.g. title, author, contents)

sorting by any field

multiple-index searching with merged results

allows simultaneous update and searching

flexible faceting, highlighting, joins and result grouping

fast, memory-efficient and typo-tolerant suggesters

pluggable ranking models, including the Vector Space Model and Okapi BM25

configurable storage engine (codecs)

https://lucene.apache.org/core/

Guava

The Guava project contains several of Google's core libraries that we rely on in our Java-based projects: collections, caching, primitives support, concurrency libraries, common annotations, string processing, I/O, and so forth.

https://code.google.com/p/guava-libraries/

Janino

Janino is a super-small, super-fast Java™ compiler. Not only can it compile a set of source files to a set of class files like JAVAC, but also can it compile a Java™expression, block, class body or source file in memory, load the bytecode and execute it directly in the same JVM.

http://docs.codehaus.org/display/JANINO/Home

Javolution

real-time goals are simple: To make your application faster and more time predictable!

High-Performance - Hardware accelerated computing (GPUs) with ComputeContext.

Minimalistic - Collection classes, supporting custom views, closure-based iterations, map-reduce paradigm, parallel computations, etc.

Optimized - To reduce the worst case execution time documented through annotations.

Innovative - Fractal-based structures to maintain high-performance regardless of the size of the data.

Multi-Cores Ready - Most parallelizable classes (including collections) are either mutex-free (atomic) or using extremely short locking time (shared).

OSGi Compliant - Run as a bundle or as a standard library. OSGi contexts allow cross cutting concerns (concurrency, logging, security, ...) to be addressed at run-time through OSGi published services without polluting the application code (Separation of Concerns).

Interoperable - Struct and Union base classes for direct interfacing with native applications. Development of the Javolution C++ library to mirror its Java counterpart and makes it easy to port anyJava application to C++ for native compilation (maven based) or to write Java-Like code directly in C++ (more at Javolution C++ Overview)).

Simple - You don't need to know the hundreds of new Java 8 util.* classes, most can be built from scratch by chaining Javolution collections or maps. No need to worry about configuration, immutability or code bloating !

Free - Permission to use, copy, modify, and distribute this software is freely granted, provided that copyright notices are preserved (BSD License).

http://javolution.org/

Java Chronicle

This library is an ultra low latency, high throughput, persisted, messaging and event driven in memory database. The typical latency is as low as 16 nano-seconds and supports throughputs of 5-20 million messages/record updates per second. It uses almost no heap, trivial GC impact, can be much larger than your physical memory size (only limited by the size of your disk). and can be shared between processes with better than 1/10th latency of using Sockets over loopback. It can change the way you design your system because it allows you to have independent processes which can be running or not at the same time (as no messages are lost) This is useful for restarting services and testing your services from canned data. e.g. like sub-microsecond durable messaging.

https://github.com/peter-lawrey/Java-Chronicle

Quartz

Quartz is a richly featured, open source job scheduling library that can be integrated within virtually any Java application - from the smallest stand-alone application to the largest e-commerce system. Quartz can be used to create simple or complex schedules for executing tens, hundreds, or even tens-of-thousands of jobs; jobs whose tasks are defined as standard Java components that may execute virtually anything you may program them to do. The Quartz Scheduler includes many enterprise-class features, such as support for JTA transactions and clustering.

http://www.quartz-scheduler.org/

Ehcache

Ehcache is an open source, standards-based cache for boosting performance, offloading your database, and simplifying scalability. It's the most widely-used Java-based cache because it's robust, proven, and full-featured. Ehcache scales from in-process, with one or more nodes, all the way to mixed in-process/out-of-process configurations with terabyte-sized caches.

http://ehcache.org/