Last updated: 9th January, 2014
Why this Guide
Work in progress
Target Audience
The Basics
Java the language. Java the ecosystem. Java the JVM.
A Multi-language platform
JVM Bytecode
Cross Platform
JVM Implementations, Editions and Versions
Editions and Versions
Editions
Versions
Installing Java
Application Output a.k.a Artifacts
JAR Files
WAR Files
Running Java Applications
Classpath
Build Tools
Ant
Maven
Gradle
IntelliJ IDEA Build
Frameworks and Libraries
JSON Serialization
Unit Testing
Mocking Frameworks
Logging
IoC Containers
HTTP Clients
Web Frameworks
Networking
Other Libraries and Utilities
Conventions
Namespaces
Property and Method Names
Tooling
IDE’s
Continuous Integration
Random Tools
IntelliJ IDEA for the Visual Studio User
Working with the JVM
Class Loaders
Creating your own class loaders
More information on class loaders
Dynamic Class Loading from Current Module
Dynamic Class Loading from Another Module
Conferences
Changelog
Why this Guide
When you come to a new platform, from a similar one, you often spend time trying to get up to speed with concepts/frameworks you know, but you don’t know, because they go by a different name, a different approach.
It’s time-consuming and sometimes even frustrating. This guide is an attempt to help others avoid some of those newbie questions.
This guide is also to help me, as I’m sure I’ve made and will make mistakes, so please let me know if you see any errors. Or better yet, send me a pull request
Work in progress
While it is a blog post, it is also a page that I will update as and when I come across new things. At the top is the latest updated date.
Target Audience
This guide was primarily focused for .NET Developers as there are quite a few comparisons with .NET. In fact the URL still indicates it. Having said that, I’m hoping it is just as
useful for non .NET developers that are also new to the Java platform.
The Basics
Java the language. Java the ecosystem. Java the JVM.
They are different. One thing is the language (think C#), another the ecosystem (think .NET ecosystem), another the platform (think CLR).
Unfortunately it seems Java is commonly used to refer to all three.
Don’t let one put you off the other. I don’t like Java as a language, but the Java ecosystem is very active and a lot of innovation is happening. In fact, as a .NET Developer
you’re probably familiar with libraries such as NHibernate, NUnit, NLog, NAnt, etc. all of which originate from the Java ecosystem
(drop the N).
A Multi-language platform
Think of the JVM as the CLR. Both are virtual machines that provide a platform for multiple languages. They have their differences of course, but both host multiple languages.
While on the CLR, we mostly have C#, VB.NET (a dying breed) and F#, on the JVM there is Java, Scala, Clojure, Ceylon, Groovy, JRuby and Kotlin just to name a few.
JVM Bytecode
JVM bytecode is what JVM based languages compile down to to run on the JVM. It’s similar to IL in .NET.
Cross Platform
The JVM is 100% cross platform. Apart from Windows, OSX and Linux, it also runs on many other types of devices.
JVM Implementations, Editions and Versions
The JVM has multiple implementations. The most common one is Oracle’s and OpenJDK. There’s even a .NET implementation called IKVM.NET
Editions and Versions
This is probably by far the most complicated section on this guide. It’s amazing how you can screw up something as simple as naming/versioning. This even makes Microsoft’s product naming look decent.
Here we go:
Editions
JRE - Java Runtime Environment. This is for running JVM applications. You can’t develop applications running on the JVM with just this.
Java SE (JDK) - Java Standard Edition. Also known as the JDK. This is the minimum you need to develop applications on the JVM.
Java EE - Java Enterprise Edition. Well, name says it all. It’s where you get all the Enterprisey stuff like distributed, large-scale applications. Yes, couldn’t be more ambiguous. It includes Java SE.
Java ME - Java Micro Edition. This is a smaller subset focused for mobile phones and smaller devices. It’s like the .NET Micro Framework.
JavaFX - Replacement for Swing, which was/is the main GUI toolkit in Java. Also (albeit somewhat controversial topic) is also targeted at RIA’s. As if HTML/JS/CSS isn’t good enough?).
As you can deduce, all Java XY’s are also JDK’s.
Find out more about the history and naming
Versions
The currently released version of Java is 7. Java 8 is due out sometime in 2014.
To find out what version of Java you have installed, type
You’ll get something like this:
That’s Java 7. Why? Well easy, drop the 1 from 1.7.0_40 and you get 7.0_40. The 0_40 indicates the update pack. For Java 7 see all releases
Basically 1.5 means Java 5. 1.6 is Java 6. 1.7 is Java 7 and yes, you guessed it, Java 8 will be 1.8.
Yes. I know.
Installing Java
Once you’ve figured out which version you want by studying Editions, go to Oracle’s install guide page.
Oh, and if you’re wondering why you need the Ask Toolbar installed, don’t blame Oracle. Apparently it was a deal Sun struck before the buyout. I hear they’re not going to renew the deal once it expires.
Application Output a.k.a Artifacts
Both in .NET as well as native applications, when compiling you usually end up with an executable and/or a series of DLLs. With Java, you get a bunch of
.class files in an output folder.
Each class file usually corresponds to a Java class (when compiling Java language or other languages that follow the convention when compiling to bytecode).
These classes are JVM bytecode, which is similar to IL on the CLR.
JAR Files
Instead of shipping a hundred class files, you can also create a JAR which is nothing more than a zipped up version of the .class files. You can create JAR files using
your favorite tool or simply running
jar ships with the JDK (/bin folder).
WAR Files
A WAR file is a JAR files for Web Application, created by Sun. It contains a bunch of class files and some additional
metadata and folders with information for web servers such as TomCat.
Running Java Applications
Any Java application that has a main class can be run from the command prompt. Type:
You have to run this from the folder where the .class files are.
Classpath
When running applications, the JVM looks for all necessary dependencies in the current folder and then the CLASSPATH environment variable which points to one or more
folders containing .class files or JAR’s/ZIP’s.
You can set the CLASSPATH environment variable globally, which will then be used by Java or pass it as a command line argument when running an application:
Each entry is separated by a colon.
Build Tools
In .NET there are many build tools including MS Build, NAnt, Albacore, Fake, etc. The JVM doesn’t lag far behind. Although some languages have their own build tools such as
such as Leiningen for Clojure or SBT for Scala, most languages (including the previous) can use more standard build tools.
Ant
It’s XML. It’s what NAnt is based on. It’s like MS-Build. I did mention though it’s XML.
Maven
Maven is quite popular. When you see a project with a pom.xml file, that’s Maven. Maven is also broken. Maven is also XML.
However, Maven is more than just a build tool. It’s a packaging system. It’s like NuGet in .NET, like NPM in Node.js. Much like nuget.org there’s also a maven.org. And similar to the whole
“if it’s not on nuget.org it doesn’t exist”, well, kind of the same situation in the Java ecosystem.
Like NuGet, you can also host your own Maven repository. Artifactory is a product that allows you to do so.
Gradle
Gradle is a better Maven. It’s based on Groovy so you get rid of the horrible XML and offers apparently a better way of managing dependencies.
I’m currently trying to use Gradle more.
IntelliJ IDEA Build
Albeit an IDE and more belonging in the tools section, IntelliJ IDEA also offers its own build system. However, you’re limited to using it in environments that understand it, which is basically
IntelliJ IDEA and TeamCity.
Frameworks and Libraries
There are far too many frameworks and libraries to list, so I’m going to limit this section to what I’ve discovered or has been recommended to me based on my own needs. If you
think there are other must-haves, please, send me a pull request.
JSON Serialization
Jackson - It’s the one I use. It works well.
Unit Testing
Quite a few unit testing frameworks:
JUnit - As standard as it gets. Works well. Supported by pretty much all tools.
Spek - Disclaimer. It’s my own framework, but since I’m using it, it’s worth a mention. Offers a better DSL. At least I think so.
JBehave - Dan North’s original JBehave framework.
TestNG - An alternative to JUnit. Not used it myself so can’t comment much.
Mocking Frameworks
I don’t do much mocking lately, but I have used one that I found:
Mockito
Logging
SLF4J - This is the common facade for logging on the JVM platform. Sticking to this allows you to (in theory) swap out logging and allows applications to choose which library they want.
IoC Containers
Guice - From Google. It’s the one I’m using. It’s pretty decent.
Spring - From Spring Framework. Apparently you can now use it without XML. Not sure. I don’t use it.
HTTP Clients
Using the standard Apache Commons one. Open to better alternatives.
Apache HTTP Client - Using this one. Sorely lacking a wrapper.
Web Frameworks
A lot of the web frameworks are based off of a common interface which is the Java Servlet API. Think of it as kind of like OWIN.
Applications can then be hosted on GlassFish, Jetty, Apache TomCat.
Oh btw, Oracle announced it will discontinue GlassFish commercial support and its main Evangelist, Arun Gupta, recently left Oracle for RedHat. He now offers as alternative WildFly
A very modern and lightweight option for web development is Vert.x. Built on Netty, you can even use different languages such as Java, JavaScript, Ruby.
Networking
Netty - Awesome asynchronous event-driven framework for writing high-performance web applications. It abstracts the communication layer so you can use HTTP, Sockets, et al.
Other Libraries and Utilities
JodaTime - Date and Time management in Java are horrendously broken. Worse than in .NET. Use JodaTime for sanity. This is where NodaTime from Jon Skeet originates.
Reflections - Making Reflection nicer.
Apache Commons - A bunch of small libraries for everyday use.
Conventions
Although conventions are largely based on the programming language you pick, there are some more or less common conventions
Namespaces
Namespaces are in reverse order, starting with the top-level domain name, then the company/organization, etc. i.e.
and unfortunately, at some point, it was decided that each segment becomes a folder. Which means that you end up with things like this on GitHub:
Fortunately if you use a decent IDE, these will be collapsed and become manageable.
Property and Method Names
If you’re coming from C# and using a language such as Java, Scala or Kotlin, then the conventions are reversed in terms of naming fields, properties, methods. They are all named using lowerCamelCase.
If you end up using Java, browse through this comparison.
Tooling
When you install the JDK you get a compiler (javac) and a jar creator (jar), javadoc (for creating docs) and a few other goodies. With that and a text editor you can
create and run applications.
IDE’s
There are three main IDE’s in the Java space:
NetBeans
Eclipse
IntelliJ IDEA
All three are OSS and free. IntellIJ IDEA has an Ultimate Commercial version which is recommended if you want some additional support for frameworks, enterprise features, et al. Full Comparison
While Eclipse is probably the most common and extended, my choice is IntelliJ IDEA. And if you like ReSharper, you’re going to like it. Of course, you can call me biased.
Continuous Integration
In terms of Continuous Integration tools, pretty much the same ones that exist in .NET exist on the JVM. In fact, most of them are JVM based.
TeamCity - Offers a free edition.
Jenkins - A spin-off of Hudson
Random Tools
A collection of tools that I find useful and will add to as I come across them.
JRebel - Awesome plugin to IntelliJ IDEA and other IDE’s that allows for hot-swapping, i.e run code without re-compiling.
YourKit - Java Profiler
IntelliJ IDEA for the Visual Studio User
This has become its own guide
Working with the JVM
This section describes some common tasks you’d do with the JVM. Most examples will be in Kotlin but can easily be adapted to other languages.
Class Loaders
Class Loaders on the JVM is a long topic, way too long for this guide, so I’m just going to touch on the basics.
In .NET you have an Assembly class that loads other classes. On the JVM, you have Class Loaders. And that’s plural, i.e. there can be more than one class loader.
The default class loader which is used to start up your app can be obtained using the method getSystemClassLoader() of the ClassLoader class:
Don’t try firing up a new instance of ClassLoader because it’s an abstract type. There are a couple of implementations of class loaders which are often used, one of
which is the URLClassLoader.
One very important concept of Class Loaders. Each Class Loader has a property which points to a parent class loader.
How does this effect class loading? Well, when you’re trying to load a class, the JVM will first try and ask the parent to load the class. If the parent cannot load the class, then your class loader will try and load the class.
Class Loaders, including URLClassLoader allow you to specify an alternative parent when creating an instance.
The default system class loader always kicks in and tries to load classes that are on the given classpath, if this behavior is not overridden by subclasses.
Also, class identity in JVM is similar to .NET, which means that the same classes loaded from different class loaders are not compatible, even when on the same chain.
Creating your own class loaders
You can not only create your own class loaders, inheriting from ClassLoader, but you can also change the default class loader, something that’s not possible in .NET.
More information on class loaders
There are so many articles out there on class loaders. Here are a few I found:
Extensive tutorial on Class Loaders from Zeroturnaround
The Basics of Java Class Loaders
Ted Newards’s Papers on Finding, Loading Classes and more
Oracle’s Papers on Java Class Loading
and just use Google, because there are tons of blog posts, articles and papers on the topic.
Dynamic Class Loading from Current Module
In .NET, to load a class from the current assembly, you can do something like:
where Loader is the current namespace of the assembly where Customer is. This works as long as classes are in the current assembly.
The equivalent on the JVM would be:
? is a Kotlin specific construct which basically means only execute the operation if classLoader is not null. It’s shortcut for
Dynamic Class Loading from Another Module
In .NET, you’d do:
On the JVM, you usually use URLClassLoader, where you pass in a list of URL’s, not folders. The benefit of URL’s means that you can load from disk, from the web, etc.
If your classes are packaged as a JAR, you pass in the JAR filename:
You can of course use File instead of URL and point to a file, which is more common, but then you need to convert the file to a URL:
If your classes are located as individual .class files in a folder, you pass in the folder.
Why am I not instantiating URLClassLoader and using the newInstance method instead? Well apparently it has the benefit of
calling securityManager.checkPackageAccess if a Security Manager is installed.
A couple of very important points that will save you headaches when using directories (not JARS):
Make sure you pass the trailing / to the URL/File.
Make sure you stop at the root folder. What does this mean? When you compile org.sampleModule.Customer class, it generates an output of:
output-root-folder/org/sampleModule/Customer.class
where the dots are replaced with /. This means that you the URLLoader is expecting you to point to the root, not where the namespaces start. The full namespace
is provided in the call to loadClass.
Thanks @orangy for saving me from this headache.
Conferences
I’ve been going to Java Conferences for the past few years even when I wasn’t doing more Java development. Here’s a pick of some I’ve gone to that are decent:
Devoxx - Biggest edition is in Antwerp, although they now have in France and UK.
JAX - A long-running and large conference in Germany. From the same guys that run BASTA!
JavaZone - It’s like NDC but Java. A lot of talks in Norwegian though.
JavaOne - The Big One. This is like the TechEd of the Java world.
There are also some ‘cross-platform’ conferences such as NDC, QCon, YOW!, GOTO, etc.
Changelog
Tracks changes made to this guide.
Date
Change
30th Dec 2013
Updated JavaFX description. Added ChangeLog Section
06th Jan 2014
Updated title and fixed added link to IntelliJ IDEA guide
09th Jan 2014
Added Section on Class Loading
JVM Minimal Survival Guide was originally published by Hadi Hariri at Hadi Hariri on December 29, 2013.