JavaBeat

JavaBeat Newsletter-1: What’s new and noteworthy in the Java ecosystem?

by Leave a Comment

We at JavaBeat have thought of coming up with a fortnightly post, a JavaBeat Newsletter covering the latest news in the Java ecosystem be it in the Java language, Other JVM based languages, Cloud support, Tools and other frameworks and also few noteworthy posts added on JavaBeat.

also read:

Here we have the first edition of JavaBeat Newsletter:

Interesting blog posts from JavaBeat

News and updates

Languages

Web and Desktop Frameworks

Tools and IDE

Cloud

Podcasts

  • Java Spotlight episode 84: Anil Gaur on JavaEE 7.
  • Java Spotlight Episode 83: Scott Kovatch on Java for MacOSX.
  • JavaPosse Episode 385.

Hope this edition of the newsletter was resourceful. Looking forward to hear from our readers regarding this new initiative.

Virtual Extension Methods(or Defender Methods) in Java 8

by Leave a Comment

As part of the JSR-335 (Project Lambda) which adds closure support to Java language, there were quite a few changes in the language to support the use of closures in the existing Java APIs (Collection APIs to a large extent). One such change is the introduction of Virtual Extension Methods.

also read:

We all are aware of the fact that the interfaces don’t contain any implementation for the methods. To provide support for new APIs which support the use of closures and also which can run on Multi core platforms there has to be some way to add these APIs to existing classes. For example, methods like forEach, map, reduce, filter which act on a collection can be added to the Collection class directly or create a new interface and let all the collection API implement them or leave it to the user of the API to implement the new interface. The first 2 approaches would lead to breaking lots of existing code because of the lack of implementation of these new methods in the interface. The last approach is possible, but it doesn’t enhance the collection API out of the box.

The team which handles JSR-335 thought of a way to add default implementation to the interfaces, which gives an option for the implementor to override the method or to leave it as is. This way new APIs can be added to the Collection class without breaking the existing code and yet provide the full support of the closures to the existing code. One can read in depth about Virtual Extension Methods here.

Lets see an example of a virtual extension method:
[code lang=”java”]
interface TestInterface{
public void testMe();

public void aDefaulter() default{
System.out.println("Default from interface");
}
}
[/code]
Using the “default” keyword we can add new methods to the existing interface and allowing the implementing classes to use this default implementation if they don’t override. Something like:
[code lang=”java”]
public class DefenderMethods{
public static void main(String[] args){
InterfaceImplementer imp = new InterfaceImplementer();
imp.testMe();
imp.aDefaulter();
}
}
class InterfaceImplementer implements TestInterface{
public void testMe(){
System.out.println("Hello World!");
}
}
[/code]

The output for above program would be:
[shell]
~/javaP/java8$ javac DefenderMethods.java
~/javaP/java8$ java DefenderMethods
Hello World!
Default from interface
[/shell]

Moving further, we can override the aDefaulter method in its implementing class, something like
[code lang=”java”]
class InterfaceImplementer implements TestInterface{
public void testMe(){
System.out.println("Hello World!");
}

public void aDefaulter(){
System.out.println("Defautler overridden from class");
}
}
[/code]
for which the output will be:
[shell]
~/javaP/java8$ javac DefenderMethods.java
~/javaP/java8$ java DefenderMethods
Hello World!
Defautler overridden from class
[/shell]

The bytecode generated for the DefenderMethods class still uses invokevirtual opcode for invoking the default method, which indicates its treated like any other usual interface method in its invocation.

There’s lot more to this concept like overriding rules, method invocation rules which I would like to cover in subsequent posts. And also sample code from the JDK 8 which uses this feature.

Embedding HTML into Java Swing Applications

by Leave a Comment

HTML in Swing applications? Yes, you have read it right. Swing doesn’t provide components to embed HTML and I have seen lot of people asking how can we add html content in Swing applications. Your concerns have been addressed by the latest release of JavaFX which is JavaFX 2.0. You might wonder what this JavaFX is, so let me just touch upon that as well.

also read:

JavaFX is the RIA platform envisaged by Sun Microsystems as the next UI toolkit for Java, as Swing has been around for a long time and has started to age. The initiative was good, but was not rightly implemented. The JavaFX 1, 1.2, 1.3 or in general anything before 2.0 is no longer supported. Pre JavaFX 2.0 one had to use JavaFX Script to create the applications and these could invoke the Java API. But learning a new language altogether was not appealing for a Java developer as one couldn’t easily use with existing Java code base. In 2.0 the JavaFX Script was totally removed to make way for the Java based api for creating JavaFX components. Once you have setup the JavaFX SDK, you get to use the JavaFX specific API in the javafx.* packages. There are lot of cool things underneath the JavaFX platform, but that’s out of the scope of this article.

Coming back to our main focus, JavaFX provides a component called WebView which with the help of WebEngine can be used to load web pages along with constructing the DOM and running the required JavaScript. But that’s a JavaFX component. How is it going to help us in our Swing application? Exactly, JavaFX provides another component called JFXPanel which can be used to embed JavaFX components into Swing applications and in turn the JFXPanel is added to our JFrame or other Swing containers.

[code lang=”java”]
JFrame myFrame = new JFrame();
JFXPanel myFXPanel = new JFXPanel():
myFrame.add(myFXPanel);
[/code]

Now the required JavaFX components would be added to the JFXPanel. The JavaFX components are to be created only in the JavaFX Application thread and not in the main thread or the thread created using SwingUtilities.invokeLater. Before that lets just get familiar with a few JavaFX components which we would be using in this example:

  • javafx.scene.Scene: All components in the JavaFX application are represented as a scene graph – a collection of parent and child components. The Scene component is the container for the scene graph or the components, and we define the root for all these containers when we instantiate the Scene component.
  • javafx.scene.layout.BorderPane: Its the JavaFX’s version of all familiar Swing BorderLayout.

So lets try to add a WebView component to the JFXPanel.

[code lang=”java”]
Platform.runLater(new Runnable() {
@Override
public void run() {

BorderPane borderPane = new BorderPane();
WebView webComponent = new WebView();

webComponent.getEngine().load("http://google.com/");

borderPane.setCenter(webComponent);
Scene scene = new Scene(borderPane,450,450);
myFXPanel.setScene(scene);

}
});
[/code]
The Platform.runLater creates a JavaFX application thread, and this thread has to be used for all the JavaFX based operations (we can create multiple such threads, but yes, for any of the JavaFX related operation is carried out as part of this thread).

In the above snippet, we create an instance of BorderPane, set it as the root of scene when we create a Scene object and then add the WebView to the BorderPane. We also ask the WebEngine of the WebView to load the URL: www.google.com. The scene object is then added to the JFXPanel. Remember, that JFXPanel is alread added to the JFrame or some Swing components. So you have a Swing application loading your web pages.

Below is the complete code for loading web pages in Swing applications.

[code lang=”java”]
import javafx.application.Platform;
import javafx.embed.swing.JFXPanel;
import javafx.scene.Scene;
import javafx.scene.layout.BorderPane;
import javafx.scene.web.WebView;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class SwingHtmlDemo {
public static void main(String [] args){

SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
ApplicationFrame mainFrame = new ApplicationFrame();
mainFrame.setVisible(true);
}
});

}

}

/**
* Main window used to display some HTML content.
*/
class ApplicationFrame extends JFrame{

JFXPanel javafxPanel;
WebView webComponent;
JPanel mainPanel;

JTextField urlField;
JButton goButton;

public ApplicationFrame(){

javafxPanel = new JFXPanel();

initSwingComponents();

loadJavaFXScene();
}

/**
* Instantiate the Swing compoents to be used
*/
private void initSwingComponents(){
mainPanel = new JPanel();
mainPanel.setLayout(new BorderLayout());
mainPanel.add(javafxPanel, BorderLayout.CENTER);

JPanel urlPanel = new JPanel(new FlowLayout());
urlField = new JTextField();
urlField.setColumns(50);
urlPanel.add(urlField);
goButton = new JButton("Go");

/**
* Handling the loading of new URL, when the user
* enters the URL and clicks on Go button.
*/
goButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
Platform.runLater(new Runnable() {
@Override
public void run() {
String url = urlField.getText();
if ( url != null && url.length() > 0){
webComponent.getEngine().load(url);
}
}
});

}
});

urlPanel.add(goButton);
mainPanel.add(urlPanel, BorderLayout.NORTH);

this.add(mainPanel);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(700,600);
}

/**
* Instantiate the JavaFX Components in
* the JavaFX Application Thread.
*/
private void loadJavaFXScene(){
Platform.runLater(new Runnable() {
@Override
public void run() {

BorderPane borderPane = new BorderPane();
webComponent = new WebView();

webComponent.getEngine().load("http://google.com/");

borderPane.setCenter(webComponent);
Scene scene = new Scene(borderPane,450,450);
javafxPanel.setScene(scene);

}
});
}
}
[/code]

I used JavaFX SDK for Linux on Ubuntu and IntelliJ to develop this sample application. One can download the JavaFX SDK from here.

Whats new in Java 7 – try-with-resource construct in Project Coin

by Leave a Comment

In our previous post we looked at different features added as part of Project Coin, in this post we will look at another language construct added as part of Java 7 and Project Coin in particular. It is the try-with-resource construct also called as Automatic Resource Management. Before getting into the details of the construct, let me show you some basic code which I would be using through out this example.

also read:

Lets create a class called Resource which implements Closeable interface and its a dummy resource class something on liens of a FileReader or your other IO classes. Lets also have a custom exception say SomeException which extends Exception class. The code for the two is as follows:

[code lang=”java”]
class Resource implements Closeable{

public String resourceName;
public Resource(String resourceName) throws SomeException{
this.resourceName = resourceName;
System.out.println(this.resourceName+" created!
Might throw an exception");
}

public void useResource() {
System.out.println("Using the resource "+this.resourceName);
}

@Override
public void close() throws IOException {
System.out.println("Closing the resource "+this.resourceName);
}
}

class SomeException extends Exception{
}
[/code]

Suppose I wanted to create an instance of Resource and use it, prior to the try-with-resource construct we would do something like:

[code lang=”java”]
Resource myResource = null;
try{
myResource = new Resource("POOR OLD RESOURCE");
myResource.useResource();
}catch(SomeException ex){
ex.printStackTrace();
}finally {
if (myResource != null) {
try {
myResource.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
[/code]

Output:

[shell]
POOR OLD RESOURCE created! Might throw an exception
Using the resource POOR OLD RESOURCE
Closing the resource POOR OLD RESOURCE
[/shell]
We generally clear all the resources in the finally block because that is the one which is called irrespective of the exception being thrown or not. But close() method in the Closeable interface itself throws an IOException which makes us to use another try..catch block in the finally method. Now, if both the try block and the catch block throw exception, prior to Java 7 the one thrown in the try block would have been suppressed by the one thrown in the catch block. In Java 7 there’s has been a new API added to Throwable which states- getSuppressedExeceptions. Let me not go into those details now. Coming back to our try-with-resources construct, the above code can be written concisely as:

[code lang=”java”]
try ( Resource myResource2 = new Resource("TRY-WITH-RESOURCE")){
myResource2.useResource();
}catch ( SomeException | IOException ex){
ex.printStackTrace();
}
[/code]

Output:

[shell]
TRY-WITH-RESOURCE created! Might throw an exception
Using the resource TRY-WITH-RESOURCE
Closing the resource TRY-WITH-RESOURCE
[/shell]

Look at the reduction in the number of lines, and also it makes the code more readable. The construct:

[code lang=”java”]
try ( Resource myResource2 = new Resource("TRY-WITH-RESOURCE"))
[/code]

is the new construct added as part of Project Coin. One can use and declare multiple resource within the try block.

[code lang=”java”]
try ( Resource myResource2 = new Resource("TRY-WITH-RESOURCE");
Resource myResource3 = new Resource("TRY-WITH-RESOURCE2"))
[/code]

The complete code can be downloaded from here.

Using JsonSlurper Groovy API from Java to parse JSON

by Leave a Comment

We have seen here on how to parse JSON in Java using Gson and here on how to parse JSON in Groovy. I also touched upon in brief about Groovy here. The beauty of these JVM languages is that one can invoke these APIs from Java, the only requirement is that you need to have the language jar on the classpath. In our example below we use JsonSlurper in Groovy to parse the JSON documents from Java. Sounds cool right! In one of the talks on Functional Programming, Venkat showed us how we could exploit the Software Transactional Memory feature in Clojure to create concurrent applications in Java with less pain.

also read:

With so many JVM languages coming up i.e languages which run on JVM, developers are more becoming ployglot i.e use multiple langauges in their code. Going on same lines, in the below example I show you how we could exploit the JSON API in Groovy and use it in our Java program. So all you readers out there keep in mind to add the language specific jar to your classpath. This jar tells the compiler where to find the required API information. For Groovy you can download the required Groovy Development Kit from here. Let GROOVY_HOME be the home directory of your Groovy installation. You would find a jar in the GROOVY_HOME/embeddable folder which would be named like: groovy-all-.jar. This is the jar which you need to add it to the classpath for your Java code to find the right APIs.
If you are not familiar with JSON, do stop by to read about it here, if you are not familiar with Json parsing in Groovy, do read it over here.
The json document which I used is:

[code]
[
{
"id":"6253282",
"name":"Twitter API",
"screen_name":"twitterapi",
"url":"http://dev.twitter.com",
"followers_count":1004641,
"friends_count":33,
"favourites_count":24,
"statuses_count":3277
},
{
"id":"15082387",
"name":"Sanaulla",
"screen_name":"sanaulla",
"url":"http://blog.sanaulla.info",
"followers_count":241,
"friends_count":302,
"favourites_count":41,
"statuses_count":1876

}
]
[/code]

The Java code which does the parsing is:

[code lang=”java”]
import groovy.json.JsonSlurper;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.List;
import java.util.Map;

public class JavaJsonParserDemo {

public static void main(String [] args){

String jsonSrouce = "/home/mohamed/twitterUser.json";
JsonSlurper jsonParser = new JsonSlurper();
try {
List<Map> parsedData = (List<Map>)jsonParser.parse( new FileReader(jsonSrouce));
for ( Map aObject : parsedData){
System.out.println(aObject);
System.out.println(aObject.get("screen_name"));
}
}catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
[/code]

If you happen to explore the source of JsonSlurper here, you can see that the parse() method invokes either parseObject() or parseArray(). In our sample JSON it would invoke parseArray(), which would return some List. Looking into parseArray() we can find that the List is actually a List of Maps. Keeping this in mind, the declaration used above is List.
Running this program the output would be:

[code]
{id=6253282, favourites_count=24, friends_count=33, name=Twitter API,
screen_name=twitterapi, statuses_count=3277, followers_count=1004641,
url=http://dev.twitter.com}
twitterapi
{id=15082387, favourites_count=41, friends_count=302, name=Sanaulla,
screen_name=sanaulla, statuses_count=1876, followers_count=241,
url=http://blog.sanaulla.info}
sanaulla
[/code]

What’s new in Java 7- Features as part of Project Coin

by Leave a Comment

As part of the Project Coin, there were quite a few language enhancements were added to the Language. The last time Java language changed was in the Java 5 release when Generics were added. The changes in introduced in the Java 7 were welcomed by java community around the world. This was seen as a stepping stone to the plethora of changes to be introduced with Java 8 and above. Nonetheless Java 7 has its own set of issues, but this shouldn’t be a concern for someone to download the latest build and give it a shot.

also read:

In this post I would like to pick a few features added as part of Project Coin and in the coming posts try to cover the remaining features. The enhancements we would be looking at are:

  • String in Switch statements.
  • Generic Type Inference (Diamond Operator)
  • Multi Catch blocks
  • Binary Integral literals and underscores in numeric literals.

Generic Type Inference (Diamond Operator)
Pre Java 7, for a map of string versus list of integers we would have a declaration like:
[code lang=”java”]
Map<Stirng,List<Integer>> myMap = new HashMap<Stirng,List<Integer>>();
[/code]

we could also write:
[code lang=”java”]
Map<Stirng,List<Integer>> myMap = new HashMap();
[/code]

But for the above code the compiler would issue an warning:

[shell]Note: Java7FeatureDemo.java uses unchecked or unsafe operations.[/shell]

With Java 7, the above declaration is equivalent to:
[code lang=”java”]
Map<Stirng,List<Integer>> myMap = new HashMap<>();
[/code]

The compiler now would inference the type based on the declaration on the left. This is in my opinion is a good step towards removing redundancy in the declaration.

If you are using a IDE which supports Java 7 language enhancements, in my case I was using IntelliJ, when you use the pre Java 7 type of declaration it suggests:

Java 7 - Diamond Operator

Strings in switch:
Prior to Java 7, we didn’t have an option to use Strings in switch. An alternative approach was to use enums in the switch statement:

[code lang=”java”]
public class PreJava7 {
enum GRADE{
A,B,C,D;
}

public static void main(String[] args){

GRADE choice = GRADE.A;

switch (choice){
case A:
System.out.println("A chosen");
break;
case B:
System.out.println("B chosen");
break;
case C:
System.out.println("C chosen");
break;
}
}
}
[/code]

With Java 7 the same code can be written as:

[code lang=”java”]
String choice = "A";

switch (choice){
case "A":
System.out.println("A chosen");
break;
case "B":
System.out.println("B chosen");
break;
case "C":
System.out.println("C chosen");
break;
}
[/code]

Multi Catch blocks:
If a code block throws multiple exceptions and you want all of the catch blocks to do the same operation, say logging the exception, we would write something like:

[code lang=”java”]
public class PreJava7 {
public static void main(String[] args){
try {
exceptionMethod1();
exceptionMethod2();
} catch (IOException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
}

}
static void exceptionMethod1() throws IOException{}
static void exceptionMethod2() throws NoSuchFieldException{}
}
[/code]

Look at the redundancy of code in both the catch blocks. With the introduction of Mutli catch blocks, the same catch block can be used to capture multiple exceptions thereby leading to code reuse. So the modified code would be:

[code lang=”java”]
try {
exceptionMethod1();
exceptionMethod2();
} catch (IOException | NoSuchFieldException e) {
e.printStackTrace();
}
[/code]

If you use an IDE which supports Java 7 features, then using multiple catch blocks would generate the suggestion as follows:
Java 7 Multiple Catch Blocks

Binary Integral literals and underscores in numeric literals:
Binary literals can be represented by using b or B, just like the way we used x for Hexadecimal literals.

[code lang=”java”]
int binary1 = 0b011;
int binary2 = 0B111;

System.out.println(binary1);
System.out.println(binary2);
[/code]

Now coming to the underscores in numeric literals:
Pre Java 7, we would write something like:

[code lang=”java”]
int hugeNumber = 1000000000;
[/code]

A trivia now: How fast can you count the number of zeros in hugeNumber? The time taken to count the number increases with the age of a person. Jokes apart, lets see how this is can be changed with Java 7 enhancement:

[code lang=”java”]
int hugeNumber2 = 1_000_000_000;
System.out.println(hugeNumber == hugeNumber2);//Prints True
[/code]

So, how easy is it now to count the number of zeros?

These were some of the few enhancements added as part of Project Coin in Java 7 release. There are few more features which were pushed to Java 8 and another feature try-with-resources ( Automatic Resource Management) which is part of Java 7 and I would write about it in my upcoming posts.

If you are interested in obtaining a fully functional code, please do it from here.
Note: In order to run the examples given above you need to download the JDK 7 from here.

Running in the Cloud

by Leave a Comment

This article is based on Mahout in Action, to be published on June, 2011. It is being reproduced here by permission from Manning Publications. Manning publishes MEAP (Manning Early Access Program,) eBooks and pBooks. MEAPs are sold exclusively through Manning.com. All pBook purchases include free PDF, mobi and epub. When mobile formats become available all customers will be contacted and upgraded. Visit Manning.com for more information. [ Use promotional code ‘java40beat’ and get 40% discount on eBooks and pBooks ]

also read:

Running in the Cloud

Introduction

Don’t have a hundred machines lying around on which to run these big distributed computations? Fortunately, today, service providers allow you to rent storage and computing time from a computing cloud.

Amazon’s Elastic MapReduce (figure 1) service (http://aws.amazon.com/elasticmapreduce/) is one such service. It uses Amazon’s S3 storage service instead of a pure Hadoop Distributed File System (HDFS) instance for storing data in the cloud. After uploading your .jar file and data to S3, you can invoke a distributed computation using the Amazon Web Services (AWS) Console.

After logging in to the main AWS Console, select the Amazon Elastic MapReduce tab. Choose to Create New Job Flow. Give the new flow whatever name you like and specify Run your own application. Choose the Custom jar type and continue. Specify the location on S3 where the .jar file resides; this will be an s3: URI, not unlike “s3://my-bucket/target/mahout-core-0.4-SNAPSHOT.job”.

The job arguments will be the same as when running on the command line; here it will certainly be necessary to configure the number of mappers and reducers. The number of mappers and reducers can be tuned to your liking. We recommend starting with a number equal to the number of virtual cores you reserve for the computation. While any instance type can be used, we recommend starting with the “regular” types unless there is a reason to choose something else: small, large, or extra large. The number and type of instances is selected on the next AWS Console screen.

If your input data is extremely large, some recommender jobs such as that in org.apache.mahout.cf.taste.hadoop.item may need more RAM per mapper or reducer. In this case, you may have to choose a high-memory instance type. You may also opt for a high-CPU instance type; the risk is that the jobs will spend enough time reading and writing data to S3 that these instances’ speedy CPUs will go mostly unused. Therefore, the conventional instance types are a good place to start. If using the small instance type, which has one virtual core per instance, then simply set the number of mappers and reducers equal to the number of instances you will select.

You may leave other options untouched unless you have reason to set them. This is the essence of running a recommender job on Elastic MapReduce; refer to Amazon’s documentation for more information about how to monitor, stop, and debug such jobs.

Summary

We introduced Amazon’s Elastic MapReduce, which uses Amazon’s S3 storage service instead of a pure Hadoop Distributed File System (HDFS) instance for storing data in the cloud.

HTTP messaging in Java

by Leave a Comment

This article is based on Android in Practice, to be published on Summer 2011. It is being reproduced here by permission from Manning Publications. Manning publishes MEAP (Manning Early Access Program,) ebooks and pbooks. MEAPs are sold exclusively through Manning.com. All print book purchases include an ebook free of charge. When mobile formats become available all customers will be contacted and upgraded. Visit Manning.com for more information.

also read:

Technique: HTTP the Java way

Introduction

The standard Java class library already has a solution for HTTP messaging. An open-source implementation of these classes is bundled with Android‘s class library, which is based on Apache Harmony. It’s simple and bare-bones in its structure and, while it supports features like proxy servers, cookies (to some degree), and SSL, the one thing that it lacks more than anything else is a class interface and component structure that doesn’t leave you bathed in tears. Still, more elaborate HTTP solutions are often wrappers around the standard Java interfaces and, if you don’t need all the abstraction provided, for example, by Apache HttpClient interfaces, the stock Java classes may not only be sufficient, they also perform much better thanks to a much slimmer, more low-level implementation.

Problem

You must perform simple networking tasks via HTTP (such as downloading a file) and you want to avoid the performance penalty imposed by the higher-level, much larger, and more complex Apache HttpClient implementation.

Solution

If you ever find yourself in this situation, you probably want to do HTTP conversations through a java.net.HttpURLConnection. HttpURLConnection is a subtype of the more generic URLConnection, which represents a general purpose data connection to a network endpoint specified by a java.net.URL. A URLConnection is never instantiated directly; instead, you construct a URL instance from a string and, based on the URL’s scheme, a proper implementation of URLConnection is returned:

[code lang=”java”]
URL url = new URL("http://www.example.com/");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.connect();
…
conn.disconnect();[/code]

This connection implementation lookup by URL scheme is performed by a protocol handler object. The Java class library and Android already provide protocol handlers for all common schemes such as HTTP(S), FTP, MAILTO, FILE, and so on, so typically you don’t have to worry about that. This,of course, also means that you are free to create your own protocol handlers that instantiate your own custom URLConnection. URLConnection is based on TCP sockets and the standard java.io stream classes. That means I/O is blocking, so remember to never run them on the main UI thread.

Let’s see how it works in a practical example. We want to extend the MyMovies application to display a simple message dialog with the latest update news downloaded from a Web server so the user is always up to date about what has changed in the latest release. For this to work, we just have to place a text file containing the update notes somewhere on a Web server, download and read the file, and display its text in a message dialog. Figure 1 shows what that will look like.

For simplicity, we will show the dialog on every application start, a “detail” that would probably annoy the heck out of your users if this were a production release, but the example serves our purpose well enough. Implementation wise, the plan is to write an AsyncTask that establishes a connection to an HTTP server via HttpURLConnection and downloads the file containing the update notes text. We then send this text via a Handler object to our main activity so we can show an AlertDialog with that text. Let’s look at the MyMovies activity class first, which contains the callback for the handler to show the pop-up dialog (listing 1).

Listing 1 Showing an update notes pop-up dialog in MyMovies

[code lang=”java”] public class MyMovies extends ListActivity implements Callback {
private MovieAdapter adapter;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
…
new UpdateNoticeTask(new Handler(this)).execute(); #A
}
…
public boolean handleMessage(Message msg) {
String updateNotice = msg.getData().getString("text"); #B
AlertDialog.Builder dialog = new AlertDialog.Builder(this);
dialog.setTitle("What’s new");
dialog.setMessage(updateNotice); #C
dialog.setIcon(android.R.drawable.ic_dialog_info);
dialog.setPositiveButton(getString(android.R.string.ok),
new OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
dialog.dismiss();
}
});
dialog.show();
return false;
}
}

#A Starts a new task to download the file
#B Reads update text from the message
#C Sets update text on the dialog[/code]

We launch the UpdateNoticeTask in the last line of onCreate() since that’s where the download proceeds. Listing 2 has the source code.

Listing 2 Downloading a text file using HttpURLConnection and AsyncTask

[code lang=”java”] public class UpdateNoticeTask extends AsyncTask {
private String updateUrl = "http://android-in-practice.googlecode.com/files/update_notice.txt";
private HttpURLConnection connection;
private Handler handler;
public UpdateNoticeTask(Handler handler) {
this.handler = handler;
}
@Override
protected String doInBackground(Void… params) {
try {
URL url = new URL(updateUrl);
connection = (HttpURLConnection) url.openConnection(); #1
connection.setRequestMethod("GET"); #2
connection.setRequestProperty("Accept", "text/plain"); #2
connection.connect(); #3
int statusCode = connection.getResponseCode();
if (statusCode != HttpURLConnection.HTTP_OK) { #4
return "Error: Failed getting update notes";
}
String text = readTextFromServer(); #5
connection.disconnect(); #6
return text;
} catch (Exception e) {
return "Error: " + e.getMessage();
}
}
private String readTextFromServer() throws IOException {
InputStreamReader isr =
new InputStreamReader(connection.getInputStream());
BufferedReader br = new BufferedReader(isr);
StringBuilder sb = new StringBuilder();
String line = br.readLine();
while (line != null) {
sb.append(line + "\n");
line = br.readLine();
}
return sb.toString();
}
@Override
protected void onPostExecute(String updateNotice) { #7
Message message = new Message();
Bundle data = new Bundle();
data.putString("text", updateNotice);
message.setData(data);
handler.sendMessage(message);
}
}

#1 Get an instance of HttpURLConnection
#2 Configure the HTTP request
#3 Establish the connection
#4 Handle non-200 server reply
#5 Read text from response body
#6 Close the connection
#7 Pass retrieved text to the activity
[/code]

After reading the URL from the parameters, the first thing we have to do is use that URL object to retrieve an instance of a fitting URLConnection instance (#1)—an HttpURLConnection in this case, since our URL has the http:// scheme). Note that the call to openConnection() does not yet establish a connection to the server, it merely instantiates a connection object. We then configure our HTTP request (#2): we first tell it that it should use the GET method to request the file (we could have also omitted this call, since GET is the default) and also set an HTTP Accept header to tell the server what kind of document type we expect it to return—plain text in this case. The request is now configured and can be sent to the server by a call to connect() (#3). Depending on the server reply, we either return an error message if we received a status message that was not 200/OK (#4) or proceed to read the text from the response body (#5). Don’t forget to close the connection when you are done processing the response (#6). Finally, we send the text we received from the server to our main activity using the Handler (#7).

Discussion

The example we showed here was extremely simple—the simplest kind of request you can send, really. For these scenarios, HttpURLConnection does the job quite well. The biggest problem with it is its class architecture. HttpURLConnection shares a large part of its interface with the general purpose URLConnection (obviously, since it inherits from it), which means that some abstraction is required for method names. If you’ve never used HttpURLConnection before, you have probably pondered the call to setRequestProperty(), which is the way to set HTTP headers—not very intuitive. This is simply because implementations for other protocols may not even have the concept of header fields but would still share the same interface, so the methods in this class all have rather generic names.

While this is just a cosmetic thing, the actual problem with URLConnection is its entire lack of a proper separation of concerns. The request, the response, and the mechanisms to send and receive them are merged into a single class, often leaving you wondering which methods to use to process which part of this triplet. This is a bit like creating a five-course meal just to stick it in the blender: you can still serve it, but it’s just disgusting. It also makes each part difficult to customize and even more difficult to mock out when writing unit tests. It’s simply not a beaming example of good object-oriented class design.

There are also some more practical problems with this class. If you find yourself in a situation where you need to intercept requests to preprocess and modify them (a good example is message signing in secure communication environments, where the sender needs to compute a signature over a request’s properties and then modify the request to include the signature), then HttpURLConnection is not a good choice for sending HTTP requests. That’s because request payload is sent unbuffered, so there is no way to get your hands on it in a non-intrusive way. Last but not least, HttpURLConnection in Apache Harmony has bugs—serious bugs. One of the major ones is detailed in the sidebar.

Android, HttpURLConnection, and HTTP header fields

As you already know, the Java class library bundled with Android is based on Apache Harmony, the open-source Java implementation driven by the Apache foundation. At the time of this writing, there is a serious bug that affects HTTP messaging using HttpURLConnection: it sends HTTP header field names in lowercase. This is nonconformant to the HTTP specification and, in fact, breaks many HTTP servers since they will simply drop these header fields. This can have a wide array of effects, with documents served to you in the format that doesn’t match your request (for example, the Accept header field was ignored) and failed requests to protect resources due to the server’s failure to recognize the Authorization header field. A workaround is simply to not use HttpURLConnection until these problems have been fixed and use Apache HttpClient instead. If you want to follow the progress of fixing this bug, you can find the official issue report at this Web address: http://code.google.com/p/android/issues/detail?id=6684.

Summary

Overall, HttpURLConnection is a simply structured but rather low-level way of doing HTTP messaging, and its clumsy interface, lack of object-orientation, and proper abstractions make it difficult to use. For simple tasks like the file download shown here it’s absolutely fine and comes with the least overhead (it doesn’t take a sledgehammer to crack a nut) but, if you want to do more complex things like request interception, connection pooling, or multipart file uploads, then don’t bother with it—there’s a much better way to do this in the Java world and, thanks to the engineers at Google, it’s bundled with Android!

Core Concepts of the Java Memory Model (JMM)

by Leave a Comment

This article is based on The Well-Grounded Java Developer, to be published Summer-2011. It is being reproduced here by permission from Manning Publications. Manning publishes MEAP (Manning Early Access Program,) eBooks and pBooks. MEAPs are sold exclusively through Manning.com. All pBook purchases include free PDF, mobi and epub. When mobile formats become available all customers will be contacted and upgraded. Visit Manning.com for more information. [ Use promotional code ‘java40beat’ and get 40% discount on eBooks and pBooks ]

also read:

Java Memory Model (JMM)

Introduction

The Java Memory Model (JMM) is described in section 17.4 of the Java Language Specification (JLS). This is quite a formal part of the spec and describes the JMM in terms of synchronization actions and the mathematical construct known as a partial order. This is great from the point of view of language theorists and implementers of the Java spec (in other words, compiler and VM makers) but not as good for application developers who need to understand the details of how their multithreaded code will execute.

Rather than repeat the formal details, we’ll list the most important rules in terms of a couple of basic concepts—the synchronizes-with and happens-before relationships between blocks of code. (If you’ve studied formal approaches to OO programming you may have heard the expressions has-a and is-a to describe the building blocks of object orientation. Happens-before and synchronizes-with are similar conceptual building blocks for understanding Java concurrency.)

  • HAPPENS-BEFORE This relationship indicates that one block of code fully completes before the other can start.
  • SYNCHRONIZES-WITH This means that an action will synchronize its view of an object with main memory before continuing.

In figure 1, we can see an example of a volatile write, which synchronizes-with a later read access (for the println).

Figure 1 Synchronizes-withThe JMM has these main rules:

  • An Unlock operation on a monitor synchronizes-with later lock operations.
  • A write to a volatile variable synchronizes-with later reads of the variable.
  • If an action A synchronizes-with action B, then A happens-before B.
  • If A comes before B in program order within a thread, then A happens-before B.

The general statement of the first two rules is that “releases happen before acquires;” in other words, the locks that a thread holds when writing are released before the locks can be acquired by other operations (including reads). There are some other additional rules, which are really about sensible behavior:

  • The completion of a constructor happens-before the finalizer for that object starts to run. (An object has to be fully constructed before it can be finalized.)
  • An action which starts a Thread synchronizes-with the first action of the new Thread.
  • Thread.join() synchronizes-with the last (and all other) actions in the thread being joined.
  • (Transitivity) If X happens-before Y, and Y happens-before Z, then X happens-before Z.

These simple rules actually define the whole of the platform’s view of how memory and synchronization works, as you can see in figure 2.

Figure 2 Transitivity of happens-before

Minimum Guarantees

In practice, these are the minimum guarantees made by the JMM. Real JVMs, however, may behave much better in practice than these guarantees suggest. This can be quite a pitfall for the developer, however, because it is easy for the false sense of safety given by the behavior of a particular JVM to turn out to be just a quirk, which is hiding an underlying concurrency bug.

Summary

We showed where Java’s conceptions of locks and synchronization come from as we explored the often-misunderstood details of the Java Memory Model (JMM). Many Java programmers are aware of the JMM and have been coding to their own understanding of it, without ever being formally introduced to it, so this new understanding builds upon that informal awareness and places it onto firm foundations.

Visualizing Memory Usage with VisualVM

by Leave a Comment

This article is based on The Well-Grounded Java Developer, to be published Summer-2011. It is being reproduced here by permission from Manning Publications. Manning publishes MEAP (Manning Early Access Program) eBooks and pBooks. MEAPs are sold exclusively through Manning.com. All pBook purchases include free PDF, mobi and epub. When mobile formats become available all customers will be contacted and upgraded. Visit Manning.com for more information. [ Use promotional code ‘java40beat’ and get 40% discount on eBooks and pBooks ]

also read:

VisualVM in Oracle JVM

Introduction

VisualVM is a visualization tool that ships with the standard Oracle JVM. It has plugin architecture and, in one standard configuration, can be used as a more convenient replacement for the now venerable JConsole. In figure 1, we show a standard VisualVM summary screen.

Figure 1 VisualVM application summary screen There are a lot of useful tabs across the top of the right-hand panel. We run with the Extensions, Sampler, JConsole, MBeans, and VisualVM plugins, which makes up an excellent toolset for really getting to grips with some of the dynamic aspects of the Java runtime. We recommend installing all of the above plugins into VisualVM before doing any serious work with it.

There are several important things to notice in figure 2—first is the “saw tooth” pattern of memory utilization. This is an absolutely classic visualization of how memory is used in the Java platform. It represents objects being allocated in Eden, used, and then collected in young collections.

Figure 2 VisualVM overview screen After each young collection, the amount of memory used falls back to a baseline level. This level is the combined usage of the objects in tenured and survivor. It can be used to ascertain the health of a Java process over time. If the baseline stays stable (or even decreases over time) while the process is working, then the memory utilization should be very healthy.

If the baseline level rises, then this does not necessarily mean that anything is necessarily wrong—just that some objects are living long enough to reach tenure. In this case, a full collection will eventually occur. The full collections will lead to a second “saw tooth” pattern—with the memory used falling back to a baseline corresponding to the level that has only truly live objects in memory. If the full collection baseline is stable over time, then the process should not run out of memory.

One key concept is that the gradient of the slope on the saw teeth is the rate at which a process is using young generation (usually Eden) memory. So, the aim of reducing the amount of young collections is basically trying to reduce the steepness of the saw teeth.

Another way of visualizing the running memory usage is shown in figure 3—here, we can see Eden, the Survivor spaces (S0 and S1), and the Old and Perm generations. As the application runs, we can see the sizes of the generations change. In particular, after a young collection, we will see Eden shrink, and the Survivor spaces swap roles.

Figure 3 VisualVM’s VisualGC plugin Exploring the memory system and other aspects of the runtime environment will help you understand how your code runs. This, in turn, shows how the services that the VM provides impact performance—so it’s definitely worth taking time to experiment with VisualVM, especially in combination with switches such as Xmx and Xms.

Summary

Automatic memory management is one of the most important parts of the Java platform. Before managed platforms such as Java and .NET, the average developer could expect to spend a noticeable percentage of their career hunting down bugs caused by imperfect memory handling.

In recent years, however, automatic allocation techniques have become so advanced and reliable that they have become part of the furniture—a large number of Java developers are unaware of how the memory management capabilities of the platform work, what options are available to the developer, and how to optimize within the constraints of the framework. In this article, we discussed VisualVM, a visualization tool available through standard Oracle JVM.