Benji's Blog » Uncategorized

Java Abuse: Inline instanceof

benji — Thu, 16 Sep 2010 20:23:40 +0000

One annoyance in Java is having to do instanceof checks on multiple lines. e.g.

if (object instanceof Foo) {
    Foo foo = (Foo)object;
    foo.foo();
}

While this is often a sign of a design failure, there are times when instanceof checks are required often due to framework constraints etc. The above is quite ugly and involves using 3 lines instead of 1 for a single method call. If foo() is a void method we can’t even use the ternary ? : operator to make it more concise.

In c# with Lambdas and Extension methods one can create something like :

    object.When<Foo>(foo => foo.Foo());

Where “When” is an extension method added to all objects which takes a type parameter and a lambda to execute if the type parameter matches. (Implementation available if anyone cares).

Since Java doesn’t have Extension methods or Lambdas yet (Oracle minus minus) we can’t do this. We can however always use reflection and get something like:

package scratchpad;
 
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
 
import static scratchpad.When.when;
 
public class Let {
	public static void main(String... args) {
		Object a = new Foo();
		Object b = "hello world";
 
		when(Foo.class).isTypeOf(a).foo(); // Prints "foo"
		when(Foo.class).isTypeOf(b).foo(); // Does nothing at all
	}
}
 
class Foo {
	public void foo() {
		System.out.println("foo");
	}
}
 
class When {
	public static <T> Is<T> when(final Class<T> cls) {
		return new Is<T>() {
			@SuppressWarnings("unchecked")
			public T isTypeOf(Object o) {
				return o != null && cls.isAssignableFrom(o.getClass()) 
					? (T)o
					: NullObject.create(cls);
			}
 
		};
	}
 
	public interface Is<T> {
		public T isTypeOf(Object o);
	}
}
 
class NullObject implements MethodInterceptor  {
 
	@SuppressWarnings("unchecked")
	public static <T> T create(Class<T> cls){
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(cls);
		enhancer.setCallback(new NullObject());
		return (T)enhancer.create();
	}
 
	public Object intercept(Object o, Method method, Object[] os, MethodProxy mp) throws Throwable {
		return null;
	}
}

Netbeans on n900

benji — Mon, 23 Aug 2010 20:47:52 +0000

I meant to post some time ago about how great the n900 is for java development. Not only can one install OpenJDK, but Netbeans is even usable. It’s pretty easy to get running. Just install openjdk6 in the application manager. Then download and run the netbeans installer.

It even runs at quite a reasonable speed if you’re not running much else.

Java Abuse: public static void main was not invented here.

benji — Mon, 23 Aug 2010 20:42:48 +0000

Normally a command-line Java application will have an entry method that looks something like:

public static void main(String... args) {
    /* Code that launches the application/deals with command line params here */
}

This is far too easy, there must be a way to NIH it ¬_¬. There are a few annoyances with the public static void main method.

Args are passed in as an Array, rather than something like a List
We can’t choose to call the main method something other than main.
It’s a bit obscure how the startup process works.

There is a common way to execute code on app startup without using a static void main method. You can use a static initialization block:

static {
    /* Code here run on class load. */
}

So we could launch our application from within a static initialization block. However this presents a number of problems:

We get a nasty error when the application finishes (Exception in thread “main” java.lang.NoSuchMethodError: main)
We have no access to the command line arguments
We can’t have multiple “Main” classes with this method (Both static initialization blocks will be run, if both classes are loaded)
It doesn’t really provide any benefits over static void main.

These problems can, however, all be overcome.

Suppressing NoSuchMethodError

We can just call System.err.close(); at the end of our initialization method.

Access to the command line arguments

This one is probably the most difficult. I’ve not found any “good” way to do this, but there is a hack that works at present on Sun’s Java, though it may stop working at any point.

sun.misc.VMSupport.getAgentProperties().get("sun.java.command")

This will give the command line string used to start the application. There are alternatives involving attaching to the currently running VM with the Agent API or shelling out to external processes and using platform-specific commands to work out the command used to start the application. If anyone knows a proper way to access the command line arguments using the public API then please let me know.

Multiple Main Classes

We need to get our initialization system to ignore invocations from classes other than the one used to start our application. This can be done by checking the length of the StackTrace. e.g.

new Throwable().fillInStackTrace().getStackTrace().length == 2;

Reflection Examples

With these 3 issues solved it’s possible to do things like:

package MainlessDemo;
 
import java.util.List;
import static uk.co.benjiweber.realjava.mainless.Bootstrap.init;
 
public class ReflectionMainless {
	static { init(); }
	public void main(final List<String> args) {
		System.out.println("Hello World");
		System.err.println("From std err");
		for (String arg : args) {
			System.out.println(arg);	
		}
	}
}
/* Output:
$ javac -cp .:./RealJava.jar ./MainlessDemo/*.java && java -cp .:./RealJava.jar MainlessDemo.ReflectionMainless Foo Bar Baz
Hello World
From std err
Foo
Bar
Baz
*/

Here a statically imported “init” method instantiates our main class, invokes our non-static main method, and passes it the command line arguments. The class to instantiate can be determined by walking back up the stack trace again.

We can also inject constructor arguments if we wish:

package MainlessDemo;
 
import java.util.List;
import static uk.co.benjiweber.realjava.mainless.Bootstrap.init;
 
public class ReflectionMainlessWithArgs {
 
	// This time we pass in the constructor argument
	static { init("Hello World"); }
 
	private final String message;
 
	// Even though we load another class that is Launchable it doesn't get launched.
	static final ReflectionMainless test = new ReflectionMainless(); 
 
	public ReflectionMainlessWithArgs(final String message) {
		this.message = message;
	}
 
	public void main(final List<String> args) {
		System.out.println(message + " (Passed in through constructor)");
		for (String arg : args) {
			System.out.println(arg);	
		}
	}
}
/* Output:
$ javac -cp .:./RealJava.jar ./MainlessDemo/*.java && java -cp .:./RealJava.jar MainlessDemo.ReflectionMainlessWithArgs Foo Bar Baz
Hello World (Passed in through constructor)
Foo
Bar
Baz
 
*/

Interface Examples

Unfortunately, apart from substituting an argument Array for a List, we ‘ve not really improved anything. However, now that we’re in control of the initialization process we can do more interesting things, like use an interface:

public interface Launchable {
	public void main(List<String> args);
}

package MainlessDemo;
 
import java.util.List;
import uk.co.benjiweber.realjava.mainless.Launchable;
import static uk.co.benjiweber.realjava.mainless.Bootstrap.init;
 
public class SaferMainless implements Launchable {
	static { init(new SaferMainless()); }
 
	public void main(final List<String> args) {
		System.out.println("Hello from a Launchable");
		for (String arg : args) {
			System.out.println(arg);	
		}
	}
}
 
/*
Output:
$ javac -cp .:./RealJava.jar ./MainlessDemo/*.java && java -cp .:./RealJava.jar MainlessDemo.SaferMainless Foo Bar Baz
Hello from a Launchable
Foo
Bar
Baz
*/

Now it’s clearer how the initialization process works, you can use your IDE to follow execution through from the init block to the main method. This also gives us the freedom to call our main method something different, and inject dependencies before reaching the main method.

package MainlessDemo;
 
import java.util.List;
import uk.co.benjiweber.realjava.mainless.Launchable;
import static uk.co.benjiweber.realjava.mainless.Bootstrap.init;
 
public class SaferAnonymousMainless {
 
	static { init(new Launchable() {
		public void main(final List<String> args) {
			SaferAnonymousMainless mainless = new SaferAnonymousMainless();
			mainless.setMessage("I was injected manually");
			mainless.someMethodNotCalledMain(args);
		}
	}); }
 
	private String message;
 
	public void setMessage(final String message) {
		this.message = message;
	}
 
	public void someMethodNotCalledMain(final List<String> args) {
		System.out.println(message);
		for (String arg : args) {
			System.out.println(arg);	
		}
	}
}
/* 
Output:
$ javac -cp .:./RealJava.jar ./MainlessDemo/*.java && java -cp .:./RealJava.jar MainlessDemo.SaferAnonymousMainless Foo Bar Baz
I was injected manually
Foo
Bar
Baz
 
*/

Source for the BootStrap.init method is here

Thanks to Faux for some of the ideas.

Yes I know this isn’t remotely a good idea, no need to tell me

Java Abuse – Ternary Try/Catch

benji — Sun, 14 Jun 2009 13:03:27 +0000

We often discuss Java limitations on IRC and try to come up with (sometimes silly) workarounds. Unfortunately after time passes it’s often easy to forget the outcome, and lose code snippets. So I thought I’d start blogging some of them so I don’t lose them, and other people might suggest other ways of doing things that we’ve overlooked.

This particular problem occurs when you want to assign the result of a method that can throw an exception to a final variable. For example:

final Customer c;
try
{
	c = getCustomer(id);
} catch (CustomerNotFoundException e)
{
	c = createNewCustomer();
}

This will fail to compile with “variable c might already have been assigned”. Of course making c not final would solve the problem, but that’s no fun.

If we were not using Exceptions, Java provides a useful ternary operator “?:” that lets us do things like:

final Customer c = customerExists(id) ? getCustomer(id) : createNewCustomer();

Which is nice and clean, but means that getCustomer is going to have to return null or throw a RuntimeException in the case that there is no matching customer, which is undesirable. Also customerExists() may be expensive.

We could also possibly use something along the lines of

final Option<Customer> c = getCustomer();

Both of these alternatives, however, require changing the API you’re consuming, and avoiding Exceptions. It would be nice if there was an equivalent of “?:” for try/catch so that you could assign the result to a final variable. The best I can manage in Java is below, can anyone do better?

import java.lang.reflect.ParameterizedType;
 
abstract class TryCatch<T, U extends Exception>
{
	public T value()
	{
		try
		{
			return Try();
		} catch (Exception e)
		{
			if (getTypeOfU().isAssignableFrom(e.getClass()))
			{
				return Catch();
			} else
			{
				throw new RuntimeException(e);
			}
		}
	}
 
	@SuppressWarnings("unchecked")
	private Class<U> getTypeOfU()
	{
		return (Class<U>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[1];
	}
 
	public abstract T Try() throws U;
 
	public abstract T Catch();
}
 
//Example
public class Main
{
	private static CustomerRepo repo = new CustomerRepo();
 
	public static void main(String[] args) 
	{
		final Customer c = new TryCatch<Customer, CustomerNotFoundException>()
		{
			public Customer Try() throws CustomerNotFoundException
			{
				System.out.println("in try");
				return repo.getCustomer(1);
			}
 
			public Customer Catch()
			{
				System.out.println("in catch");
				return repo.createCustomer();
			}
		}.value();
	}
 
}
 
class CustomerRepo
{
 
	public Customer getCustomer(int id) throws CustomerNotFoundException
	{
		throw new CustomerNotFoundException();
	}
 
	public Customer createCustomer()
	{
		return new Customer();
	}
}
 
class Customer
{
}
 
class CustomerNotFoundException extends Exception
{
}

In C# we don’t run into the same problem since readonly is much less useful than Java’s final. However, if we wanted to try/catch at the same time we can do a bit better. Here’s an alternative in C#:

using System;
 
public class Example
{
	public static void Main()
	{
		Example t = new Example();
		t.Foo();
	}
 
	public void Foo()
	{
		String result1 = this.Try(() => GetBar(true)).Catch<BarException>(() => "Caught a BarException");
		String result2 = this.Try(() => GetBar(false)).Catch<BarException>(() => "Caught a BarException");
		Console.WriteLine(result1);
		Console.WriteLine(result2);
	}
 
	public String GetBar(bool succeed)
	{
		if (succeed)
			return "Success!";
		else
			throw new BarException();
	}
}
 
public class BarException : Exception {}
 
public class Tryer<TResult>
{
	private readonly Func<TResult> toTry;
	internal Tryer(Func<TResult> toTry)
	{
		this.toTry = toTry;
	}
 
	public TResult Catch<TException>(Func<TResult> whenCaught)
		where TException : Exception
	{
		try
		{
			return toTry();
		} catch (TException)
		{
			return whenCaught();
		}
	}
}
 
namespace System
{
	public static class ProvidesTry
	{
		public static Tryer<TResult> Try<T,TResult>(this T other, Func<TResult> toTry)
		{
			return new Tryer<TResult>(toTry);
		} 
	}
}

Software Portal Preview Available.

benji — Mon, 02 Feb 2009 22:59:35 +0000

In the last couple of weeks I’ve had some time to work on the software portal project for the first time for a while.

There is now a test snapshot that you can play with if you wish, and help find bugs.

Please do have a play and leave comments here or file a bug report under the Software Portal component.

You’ll need to register to add comments/screenshots/tags etc. Unfortunately since the account you use to login to other openSUSE.org services is controlled by Novell and they provide no openid/saml facility you cannot use the same user account. If you want permissions to edit application details just send me an email (benji at opensuse dot org).

Most of the recent work has been under the hood. Significant speed improvements to the repository indexer and a Webpin compatible webservice that will enable the various clients to continue to work against software portal as they did with webpin until they can be ported to the new api.

There are also some visible changes. The homepage now displays recent comments & top rated applications, and includes the tag cloud.

Users can now choose a specific vendor for an application for their distribution, as well as installing from the preferred vendor.

Editors can now customise which source packages map to which application.

and which binary packages should be installed by default when a user clicks install.

Snow

benji — Mon, 02 Feb 2009 22:04:42 +0000

This morning we had an unusual amount of snow here, more than we’ve had in my lifetime. Most public transport was suspended and the people attempting to drive were quickly getting stuck and sliding all over the place.

Motorists were making the classic motorist error. They’ve got too much power. I’ve got half a horsepower on this – you don’t want any more than that on snow.

Even Boris Johnson mayor of London apparently cycled to work today.

Also see this comic.