OpenJDK is now an official Java 7 reference implementation, and is now one for Java 8 as well. This means that the most essential projects of the Java ecosystem are now open source. This also means that OpenJDK can be installed in various ways—from building from source to installing the binary package from the package manager, if any.
Sun's effort to release an open source JDK was the beginning of the project publicly stated in 2006, during the JavaOne conference. HotSpot was released under the GPLv2 license. The complete source code of the Java Class Library (JCL) was released in May 2007 under the GPL, except for several proprietary parts with GPL-incompatible licenses.
However, some proprietary parts (from 4 to 1 percent of the total code lines, depending on the update number) were required in OpenJDK in a separate proprietary bundle in the OpenJDK 7 b53 update in April 2009.
One may think that the initial installation and configuration are quite simple and do not need some sort of detailed explanation. In many ways, that's true; but there are some difficulties along the way.
We will start by distinguishing OpenJDK from Oracle JDK. The latter is based on the former, but not entirely. Each one has its own advantages and drawbacks. The primary OpenJDK advantage is the fact that it's open source while Oracle JDK is always recommended and is ready-to-use. Besides, OpenJDK 6 is the only maintainable Java 6 realization left, after the Java 6 discontinuation.
Then we will cover the installation process for Windows and possible issues with some Windows versions. After that, we will describe some typical profiles to configure an installed instance of OpenJDK for various needs, such as a server instance and developer instance.
Then we will go in to more complicated matters, such as installing OpenJDK on various Linux systems. There are at least two common ways to do it: the distribution-recommended way that depends on the distribution itself, and another way, which is common for all Linux systems.
Linux configuration is more or less the same as that of Windows, but there are some differences that need to be covered. The differences are, mainly, related to system philosophy, namely the way it's done and then what exactly is done.
Then we will proceed to OpenJDK internal structures—in an introductory way. We will consider OpenJDK projects that are already in use, and will learn how to use instruments that we will need later. Also, we will briefly look at OpenJDK groups and find out what they are doing and how they may influence OpenJDK's further evolution.
Last but not least, you will learn how to benefit from the Adopt OpenJDK program, which is also a part of the OpenJDK community. Adopt OpenJDK is an effort to improve OpenJDK usability readiness, test new language releases, and do whatever it needs to make OpenJDK more useful and welcoming among users as well as developers.
This chapter is written with an introductory purpose, and does not cover some details that are common to Oracle Java. However, it provides a necessary basis to work with.
We will use Java 7, as it is stable and the latest Java version available. All screenshots and processes are assuming that we use Java 7, if another is not explicitly mentioned.
If you already have OpenJDK built and installed as default and you are aware of the differences between OpenJDK and Oracle JDK, as well as of the existence of Adopt OpenJDK, you may skip this chapter entirely.
Though OpenJDK is an official reference implementation for the Java platform, certain Oracle-provided software are not open source. The most famous of them is the Java browser plugin, but there are a lot more differences than just that. This recipe will show you how to distinguish OpenJDK from Oracle JDK.
To follow this recipe, you will need an installed OpenJDK instance. It will be good if you have an Oracle JDK instance as well, to feel the difference. Also, we will assume that you have a Linux installation and an update-java-alternatives command installed and ready to use. To know how to install OpenJDK on various systems, see the later recipes in this chapter. To know how to switch the system Java version, if you do not have update-alternatives installed (for Fedora, Gentoo, and so on), visit the Configuring OpenJDK on Linux recipe or refer to your distribution documentation/forums.
Please take a look at the following procedures to know the difference between OpenJDK and Oracle JDK:
We will open a terminal and type the following command:
update-java-alternatives --listWe will see a full list of installed Java implementations:
$ update-java-alternatives --list java-1.6.0-openjdk-amd64 1061 /usr/lib/jvm/java-1.6.0-openjdk-amd64 java-1.7.0-openjdk-amd64 1071 /usr/lib/jvm/java-1.7.0-openjdk-amd64 java-6-oracle 1073 /usr/lib/jvm/java-6-oracle java-7-oracle 1081 /usr/lib/jvm/java-7-oracle java-8-oracle 1082 /usr/lib/jvm/java-8-oracle
Let's set Oracle Java as default. We will run the following command with
rootaccess:update-java-alternatives --set java-7-oracleThen we will go to https://www.java.com/en/download/installed.jsp?detect=jre and check our browser plugin version. We will see the activate link (following the name of the activating entity).
We can see from the result of our actions that the Java browser plugin has been installed.
Let's try to set OpenJDK as the default Java environment (the actual instance name may differ in your case):
update-java-alternatives --set java-1.7.0-openjdk-amd64Then we will go to our browser page and refresh it. It may be necessary to restart the browser so that the changes can take effect, as shown in the following screenshot:
We can see that the plugin is not from the JDK itself but from a project named IcedTea.
IcedTea is an open source project, whose goal is to replace proprietary parts of the Java ecosystem as much as possible. The plugin itself is from IcedTea-Web, an open source implementation of the Java Web Start and Java browser plugins.
In most distributions, the IcedTea plugin is installed by default. But it is necessary to keep in mind that it's an open source plugin, and definitely not a referenced one. This means that its functionality might be slightly different from the Oracle plugin. It is also possible that some features may not work.
Oracle JDK still has some proprietary components, and the browser plugin is one example. All we need in this chapter is to see the difference between the work of OpenJDK and Oracle JDK components that are different.
Also, the huge difference between OpenJDK and Oracle JDK lies in the license. OpenJDK is open source, while Oracle JDK contains proprietary pieces, and thus it is licensed under the Oracle binary license. The fact that OpenJDK is open source provides a whole new range of benefits (and exciting discoveries) through the ability to study and modify its source code. It is also worth mentioning that more than 90 percent of Oracle JDK is based on OpenJDK source code. This means the OpenJDK quality is not compromised in any way. The browser plugin is not the only thing that is missed in OpenJDK compared to Oracle JDK.
In Chapter 5, Building IcedTea, there is a detailed explanation of how to build IcedTea from source.
Windows is the most commonly used OS in the world, and many developers are using it as their primary system. Despite its popularity, Windows doesn't have such strong support by the OpenJDK development community, and installation of the product is not as easy as in Linux. This recipe will cover the steps required to install OpenJDK on Windows.
This recipe provides an easy but decentralized way to install programs, although the most recent versions provide package repositories of their own. However, on Windows, the only official way to install an up-to-date OpenJDK is to build it from source.
To follow this recipe, we will need an installed Windows system. Windows 7 or Windows 8 will be best, because Windows XP is already officially discontinued by Microsoft.
There is an official build of OpenJDK on Windows, but it exists for referential purposes only. It is official and easy to install, but it doesn't have any security updates or improvements. However, there are unofficial builds, maintained by Alex Casco. We will try to install OpenJDK in both ways:
We will start with an official reference build. To get it, we need to go to https://jdk7.java.net/java-se-7-ri/ and accept the license terms. Then, download and run the installer.
Unpack the downloaded file in a location you prefer. Let's name it
C:/OpenJDK.Open the Windows command line by navigating to Start | Run, type
cmd, and click on the Run button.Run the following command:
C:\OpenJDK\bin\java.exe -versionIt will output the Java version information. The output should look like this:
openjdk version 1.7.0 OpenJDK Runtime Environment <build 1.7.0-b146> OpenJDK Client VM <build 21.0-b16, mixed mode>
Congratulations! We've just installed the OpenJDK official binary.
The reference implementation is the only available official binary build of OpenJDK. But it lacks security and is used only for reference purposes. It is a simple archive that needs to be unpacked to use it.
To bypass this unpleasantness and give Windows users an opportunity to install OpenJDK as a binary without building it from source, one of the OpenJDK contributors established a completely unofficial but very useful OpenJDK build set for various platforms.
Moreover, this binary build, unlike the official one, is open source and licensed over GPL. So we can use it even in a completely open source environment without adding any proprietary pieces that will possibly get us in trouble.
Though an official reference binary is outdated, there is an unofficial project that provides OpenJDK builds from sources that are up to date.
Now we will install OpenJDK 7 from unofficial builds:
Go to https://github.com/alexkasko/openjdk-unofficial-builds.
Select an appropriate build for Windows and download it.
Unpack it and run
install.exe.
Click on the Run button when the preceding message appears.
Carefully read and accept the license and then click on Next.
Select the installation path in the next window. It will point to your home directory by default, so be careful—such an installation may be available to no one but yourself.
If the target directory does not exist, let the installer create it.
Check the red highlighted checkboxes in the preceding screenshot only if you want to set this JDK as default for all users in the system, not just for you. You may uncheck the fourth box if you don't need this JDK to be default at all.
Then click on the Next button and wait until the installation is finished.
Then click on Done.
Although the simplest way to install OpenJDK is to unpack binaries, manually or in an automatic fashion, there is no doubt that working with the source code will give us more flexibility at all possible levels.
To know more, read the following chapters:
Chapter 2, Building OpenJDK 6 up to Chapter 4, Building OpenJDK 8 to learn about building OpenJDK from source
Chapter 6, Building IcedTea with Other VM Implementations to build OpenJDK using other VMs
Chapter 13, Build Automation to work with future technologies, which will be unavailable in binary form for quite some time
Although the initial configuration is sufficient for most tasks, it may still be required to do some configuration. In the case of OpenJDK, this is performed by setting system variables. Here we will touch only on the case that often occurs when JDK is unpacked manually—how to set it as default.
To follow this recipe, we will need an OpenJDK instance installed on our Windows system. Windows 7 or Windows 8 will be best, because Windows XP is already officially discontinued by Microsoft.
At first, we need to install our OpenJDK implementation as the default Java instance. This is often necessary for development:
In order to do so, we will go to Start | Control Panel | System | Advanced | Environment Variables | User Variables (or System Variables for system-wide configuration) and add the path to the Java executable to the
PATHsystem variable, as shown:
If we were installing OpenJDK from unofficial builds, there may be no need to change the
PATHvariable at all.To validate our newly configured variable, we will go to the Command Prompt and type the following:
java -version
The expected output is the version of our newly installed build.
In order to set a newly installed OpenJDK instance as the default JDK, we need to change the system variable. After that change, our Java executables will be visible to the system.
The Linux operating system allows for many internal tweaks, as well as for changes to the system's source code. It is also known as a complicated OS, and not all distributions are user-friendly. There are many people using it, and it's open source, such as OpenJDK itself. The installation process varies between chosen distributions, and we will go through the process for the three most-used package managers, as well as through the process that will work for virtually all x86 Linux distributions.
To follow this recipe, you will need an installed Linux system. It will be better if it has the kernel version 2.6 or higher, though OpenJDK is reported workable on 2.4 kernels as well. Also, if you have the .deb, .rpm, or .ebuild package manager, the recommended way to install any package is to install it using those.
When the installation of various packages is concerned, the process is dependent on our Linux distribution.
For a Debian-based distribution:
Open a terminal and type:
apt-get install openjdk-7-jdk
This will trigger the installation automatically. If we get an error message, indicating that the package is not found, we should Google an appropriate name for an OpenJDK package for our distribution.
For an RPM-based distribution, we'll need to first search for the package names, because package names are varied between different distributions, as shown here:
yum search openjdk
You will see an output like this:
java-1.6.0-openjdk.x86_64 : OpenJDK Runtime Environment java-1.6.0-openjdk-demo.x86_64 : OpenJDK Demos java-1.6.0-openjdk-devel.x86_64 : OpenJDK Development Environment java-1.6.0-openjdk-javadoc.x86_64 : OpenJDK API Documentation java-1.6.0-openjdk-src.x86_64 : OpenJDK Source Bundle java-1.7.0-openjdk.x86_64 : OpenJDK Runtime Environment java-1.7.0-openjdk-demo.x86_64 : OpenJDK Demos java-1.7.0-openjdk-devel.x86_64 : OpenJDK Development Environment java-1.7.0-openjdk-javadoc.noarch : OpenJDK API Documentation java-1.7.0-openjdk-src.x86_64 : OpenJDK Source Bundle
You may install all of the packages that have the desired version. Then, we will run another command, using the package name we've just found:
yum install <a found package name>
This will also trigger an automatic download and installation.
If we have a Gentoo-based distribution, just type the following:
emerge openjdk-1.7
This will, depending on your distribution, unpack and install a binary package or, more probably, automatically build this package from source.
Aside from the recommended ways, there is a generic installation procedure. It is quite simple, though it may do some damage to your operating system, so don't use it unless you really know what you're doing:
This is the way to unpack the OpenJDK system and then install it yourself. To get the builds, we will refer again to the unofficial build page, https://github.com/alexkasko/openjdk-unofficial-builds.
Then unpack the downloaded package into a folder and run the following command from it:
java -jar ./install.jar
A GUI installer window will appear. Read and accept the license, choose the directory, and allow OpenJDK to be created, if it does not exist, as shown:
Check the preceding checkbox if you want to make this installation the default one. Then click on the Next button.
Wait for the installation to complete, and click on Next for the last time.
Then click on Done.
Linux configuration profiles differ from the Windows ones, because those systems are working with resources as well as with hardware in a slightly different fashion. Here, we will briefly explain those differences and a way to overcome them. Moreover, different Linux distributions, as always, have different ways to deal with the configuration. We will try to pass through the most noticeable ones.
To follow this recipe, you will need an OpenJDK instance installed on a Linux system. The deb, rpm, or ebuild distributions will suite us really well, although we will see a method for generic Linux configuration also.
Also, we will need the bash startup files to be installed properly.
First let's check whether your bash startup files are installed. The simplest possible way is to configure your OpenJDK using them. They are system-wide and easy to use, though there are drawbacks in their usage, such as update conflicts:
Type the following line in your terminal:
cat /etc/profile
If the file exists and contains some kind of shell script, then your bash startup file's setup is probably correct. If not, please set it up by following your distribution instructions.
Then add the
/etc/profile.d/openjdk.shfile.In order to configure different things, write the following:
To set JAVA_HOME JAVA_HOME=<youJDK installation directory> export JAVA_HOME To append JAVA_HOME to PATH pathappend $JAVA_HOME/bin PATH To adjust CLASSPATH directory AUTO_CLASSPATH_DIR=<classpath dir> pathprepend . CLASSPATH for dir in `find ${AUTO_CLASSPATH_DIR} -type d 2>/dev/null`; do pathappend $dir CLASSPATH done for jar in `find ${AUTO_CLASSPATH_DIR} -name "*.jar" 2>/dev/null`; do pathappend $jar CLASSPATH done export CLASSPATH
The preceding code is quite simple—it just appends all JAR files to the classpath.
This script is called during shell initialization, so whenever you perform shell initialization, these variables will be exported. The variables are thus system-wide, so be careful while playing with them, as they can cause your Java to fail permanently if you make some errors in this file.
On Linux, you can see the directory structure of the installed OpenJDK using the tree command.
To do so, install the tree package (use your distribution's documentation if possible) and type:
tree -L 1 <path-to-openjdk> -lah
You will see something like the following:
/usr/lib/jvm/java-7-openjdk-amd64 ├── [ 22] ASSEMBLY_EXCEPTION -> jre/ASSEMBLY_EXCEPTION ├── [4.0K] bin ├── [ 41] docs -> ../../../share/doc/openjdk-7-jre-headless ├── [4.0K] include ├── [4.0K] jre ├── [4.0K] lib ├── [4.0K] man ├── [ 20] src.zip -> ../openjdk-7/src.zip └── [ 22] THIRD_PARTY_README -> jre/THIRD_PARTY_README
This is the first-level directory structure in which:
ASSEMBLY_EXCEPTIONis about licensing, and so isTHIRD_PARTY_README.The
docsfolder is for various OpenJDK documentation (changelog, copyrights, authors, and so on).The
includedirectory is to include paths (forJNI, for example).The
jredirectory is where the Java Runtime is placed.The
libdirectory is where various OpenJDK libraries are placed (such as Jigsaw or CORBA support; mainly, it consists of all OpenJDK code).The
mancommand is a manual pages entry for OpenJDK. It contains OpenJDK classes,javadocs, and other manual entries. It may be extremely useful in the highly improbable event of Internet connection loss.
OpenJDK is not one huge project. It consists of a large number of subprojects, and is developed by relatively small groups of developers. We will look at them and realize what is going on under the hood of OpenJDK.
To follow this recipe, you will need an OpenJDK instance installed and an established Internet connection. The recipe is more for the initial understanding of the process rather than for practical use, so if you are familiar with these matters, don't hesitate to skip this recipe entirely.
We will see what OpenJDK consists of:
Go to http://openjdk.java.net/.
In the right column, there are overviews of groups as well as projects.
We will select one of them to get through the process.
Tip
The process will be described in detail in Chapter 8, Hacking OpenJDK.
Let the selected project be
JDK9.Go to the
JDK9project page at http://openjdk.java.net/projects/jdk9/.
There's not very much to see, because there is only the basic on-boarding information. Most of the project business is in the bug tracker.
After we read the information about the project on an official site, we will go to JDK JIRA to see what's happening here. We will go to the JDK9 part of JIRA at https://bugs.openjdk.java.net/browse/JDK/fixforversion/14949.
Here we can see various issues related directly to JDK9 and see how the process is going.
Groups are sets of developers who may work on different projects but in one large scope. Developers participate in chosen projects, and projects are sponsored by groups.
Tip
To participate in a group and become a contributor, follow the instructions at http://openjdk.java.net/contribute/.
There are four major types of projects:
Feature
Improvement
Replacement
Portability
For example, the JDK9 project is a featured one. The graphics rasterizer project is a replacement one, while the Swing group is a whole group that is focused on the improvement of Swing.
Various ports' projects are obviously the portability ones.
See Chapter 8, Hacking OpenJDK, Chapter 11, Troubleshooting, and Chapter 13, Build Automation—they will suit you just well
Tails in Chapter 4, Building OpenJDK 8
