If you are trying to use Rome and Rome Feed Fetcher, you may want to change the user agent.  However, the following will not change the default user agent:

FeedFetcher feedFetcher = new HttpURLFeedFetcher();
feedFetcher.setUserAgent("User Agent 007");
SyndFeed feed = null;
feedURL = new URL(rssUrl);
feed = feedFetcher.retrieveFeed(feedURL);
List entries = feed.getEntries();

To change the user agent you must use the InfoCache as shown:

FeedFetcherCache feedInfoCache = HashMapFeedInfoCache.getInstance();
FeedFetcher feedFetcher = new HttpURLFeedFetcher(feedInfoCache);
feedFetcher.setUserAgent("User Agent 007");
SyndFeed feed = null;
feedURL = new URL(rssUrl);
feed = feedFetcher.retrieveFeed(feedURL);
List entries = feed.getEntries();

Otherwise the User agent is set to “Java/1.5.0_04″. This is odd because the default client for Rome is “Rome Client (http://tinyurl.com/64t5n) Ver: 0.7″. It seems like an attempt to change the user agent without having a HashMapFeedInfoCache will result in changing the user agent, but somehow it reverts to “Java/1.5.0_04″ instead of whatever you set it to.

People Found This When Looking For:

• rome client http://tinyurl com/64t5n (1)
• user agent rome (1)
• user agent Rome Client (1)

Cobertura is a fork of jCoverage. It runs reports to let you see how much of your code is being tested by unit tests. This is incredibly useful to find areas of your code where a bug would go undetected.

It looks like there is a plugin for Maven already, so I’m going to have to give it a try sometime. link

Maven 1.0 has some problems with memory leaks. Most of the time these aren’t issues, but if you are trying to compile a multiproject you might run into problems. By default Maven tells java to let it have up to 256MB of ram. If you need to increase this you’ll need to open the maven.bat (windows) or maven.sh (unix) file and change the way that java is called. Somewhere around line 118 (on the .bat file)you should see the following:

if "%MAVEN_OPTS%"=="" SET MAVEN_OPTS="-Xmx256m"

Change the line so it reads:

if "%MAVEN_OPTS%"=="" SET MAVEN_OPTS="-Xmx1000m"

This will give Maven 1GB of memory to work with. While this doesn’t really solve the problem of the memory leak, it may give you enough space to keep the problem from crashing Maven.

You can also set MAVEN_OPTS by setting it up as a variable in your environment. If you do this the environment will override anything you set in the .bat or .sh file.

People Found This When Looking For:

• maven OutOfMemory Windows (3)
• maven memory (3)
• maven_opts memory (2)
• maven_opts HOW TO SET (2)
• maven change memory (2)
• maven memory windows (2)
• maven outofmemory (2)
• MAVEN_OPTS memory increasing (2)
• maven memory unix (1)
• maven site outofmemory (1)

Why Java Won’t Get It Right is an interesting entry about some of the problems with Java technology. The best part is that it is written by someone who actually knows Java. A part that I particularly liked was:

They over-architect everything. I’ve actually used a Java framework (I’m not gonna say which) that had XML config files that configured more XML config files! That’s just silly.

The author makes comparisons to Ruby on Rails and talks about how he doesn’t think Java will ever have anything like Rails.

I’ve seen a few demos of Rails and it is impressive, but much of the functionality it gives you has been available in WebObjects for some time. In fact I’ve met several Ruby developers that started with Rails and switched to WebObjects as their application got bigger. (Update: It turns out I was mistaken. They switched from Ruby to Webobjects, but they were using a different web framework instead of Rails.)

There is an interesting comparison between a Ruby project and a Java project posted on the Ruby on Rails site. The code comparison is interesting because it shows how much Ruby does for you automatically if you know how to use it. A lot of what Ruby is doing is giving you automatic setters and getters.

It would be interesting to see a comparison between the amount of code necessary to write a Ruby application and the same app in WebObjects, but when it comes down to actual productivity the language being used is rarely the bottleneck. The skills of the programmer are by far the most important factor. The tools available in the language are second and the language ranks third or lower.

Good tools have a huge impact on productivity. Simple things like auto-complete and real time syntax checking cumulatively make a large difference in productivity. One of the areas where WebObjects really shines is in giving you the ability to graphically connect your data with the view. You can still do everything manually in code, but the graphical tools give you the ability to really think about the problem on a level that is much closer to the user experience.

• Some thoughts on how Ruby is Similiar to Webobjects
• A look at some of the frameworks available for Ruby

The following is a JUnit test that looks like it should always run without a problem. Mark the current time in a variable called start call Thread.sleep and tell it to sleep for x number of seconds, note the current time again in a variable called end and then assert that end - start is going to be less than or equal to x.

    public void testThreadSleep() throws Exception {
        long start = 0;
        long end = 0;
        long elapsedTime = 0;
        for(int i = 1000; i < 1500 ; i = i + 20){
            start = System.currentTimeMillis();
            Thread.sleep(i);
            end = System.currentTimeMillis();
            assertTrue(i <= end - start);
        }
    }

However in acutally running this code the assertion is not always true. It appears that when you try to call Thread.sleep(x) it may not sleep for the entire x milliseconds. Obviously it might take longer than x because a thread isn’t guaranteed to run. There might be another thread with a higher priority or the system might be doing garbage collection. However I would expect that it wouldn’t run less than the specified amount of time, but that is what appears to be happening.

I believe this has to do with the way that the JVM operates. Evidently it may wake up a thread a few milliseconds before the appointed time. It is possible that it may be anticipating garbage collection and waking threads up slightly early

According to some posts on Java Ranch, Sun is looking to create a Sun Certified Java Associates exam. The idea is to have an exam that companies can use to certify entry level programmers. I’m not sure why this is better than the current Sun Certified Java Programmer certification. It sounds like they want a certification that is easier to pass for someone with less experience. I didn’t find the SCJP exam all that difficult. In fact I didn’t even bother to put it on my resume, but after reading all the comments at Java Ranch about how difficult it is to pass maybe I should.

This seems like an odd move on Sun’s part. Generally most companies aren’t complaining that the programmers they hire are overqualified. I suppose it may help them find promising junior programmers who they can mentor. The exam could help separate people who have a good foundational understanding of the language from those that have only played around with a few features. I suppose it makes sense from a financial stand point. The tests aren’t cheap.

I know that many scripting language programmers are trying to learn Java or C# as their next career step. If you’ve only worked with a scripting language, the transition to object oriented anything is going to be a big step. Trying to understand threads, nested classes, etc. when you are still trying to transition away from thinking of everything as a web page with code snippets can be a pretty big challenge. The new exam could help give these people their first real “win” in the Java language. Sun may see this more as a marketing tactic to help bring people to Java that might be considering C#. Once someone passes the SCJA they are probably going to want to move up to the SCJP.

At least in my case the Sun Certified Java Developer didn’t hold a lot of appeal for me once I passed the programmer exam. I figured that I’d rather spend my time creating something that I want to use instead of designing an application that is only going to be used as part of the certification process. It is a lot easier to code something you actually find interesting than something you plan to throw away.

• Short Comment on new exam
• Java Ranch Discussion of Exam

People Found This When Looking For:

• scja blogs (2)
• Java Ranchs SCJA certification page (1)

Agylen: Comparable vs equals has a nice discussion of how compareTo is used in Sets.

If you don’t understand how Java is going to use your compareTo and your equals methods you can run into a problem with Sets. Basically you shouldn’t have a compareTo() method that returns 0 unless equals() returns true.

Since a Set only allows once instance of each object, it will ignore the addition of any objects it already contains. If your object implements the Comparator interface the Set will check the compareTo method not the equals method.

It is common to write compareTo methods that only look at one field. For example, you might want to sort Person objects by their last name and then first name. If you only check the last and first name field, then comparing two John Smiths would return 0 even if they were different objects. This would cause the Set to evaluate them as the same object and prevent you from adding the second John Smith to the Set.

Using JUnit With Eclipse IDE is a great simple tutorial on how to use JUnit in Eclipse. It doesn’t assume any knowledge of JUnit, but is useful as a quick tutorial for people wanting to make a switch to the Eclipse development environment.

Reflection is a mechanism in java that allows to to get information about a class without needing to know the type of the class. The program below takes a java class name as a command line argument and shows you all of the methods and field names that are in the class.

You call the sample program like this:
java ReflectionTest java.util.Calendar

ReflectionTest takes the string you pass in on the command line and attempts to find a class by that name. If it finds one it gets an array of all the fields and displays their name and their values. It then gets an array of all the methods and displays their name and their return type.

Notice that the Calendar class doesn’t appear anywhere in the code. Reflection allows you to look inside a class without needing to know what the class is. You can use reflection to create objects that can work with classes that they don’t ever know about directly.


01 package test;
02 import java.lang.reflect.*;
03 
04 public class ReflectionTest{
05 
06     public static void main(String[] args) throws Exception {
07         if(args.length != 1) {
08             String usage = "example usage: ReflectionTest java.util.Calendar";
09             System.out.println(usage);
10             System.exit(0);
11         }
12         Class aClass = Class.forName(args[0]);
13         Field[] fields = aClass.getFields();
14         System.out.println("Number of Fields = " + fields.length);
15         for(int i = 0; i < fields.length; i++){
16             Field field = fields[i];
17             System.out.println("[" + field.getName() + "] " 
18                   + "with value [" + field.get(aClass) + "]");         
19         }
20         
21         Method[] methods = aClass.getMethods();
22         System.out.println("\nNumber of Methods = " + methods.length);
23         for(int i = 0; i < methods.length; i++){
24             Method method = methods[i];
25             System.out.println("[" + method.getName() + "] " 
26                     + "returns [" + method.getReturnType() + "]");
27         }
28         
29     }
30 }

On line 13 we use the class to get the fields and then print out their name and value in 15 to 19. Notice the odd reference of field.get(aClass) to get the value. It seems odd in this example because we are just passing it a class. You could also pass it a real live instance of a Calendar object and it would tell you what the field values are for that instance of Calendar.

The remaining code uses the same process to get the name and return type of each method in the class.

Here are the results of the program being run on java.util.Calendar as an argument:


Number of Fields = 41
[ERA] with value [0]
[YEAR] with value [1]
[MONTH] with value [2]
[WEEK_OF_YEAR] with value [3]
[WEEK_OF_MONTH] with value [4]
[DATE] with value [5]
[DAY_OF_MONTH] with value [5]
[DAY_OF_YEAR] with value [6]
[DAY_OF_WEEK] with value [7]
[DAY_OF_WEEK_IN_MONTH] with value [8]
and so on.......

Number of Methods = 46
[hashCode] returns [int]
[equals] returns [boolean]
[toString] returns [class java.lang.String]
[get] returns [int]
[clone] returns [class java.lang.Object]
[add] returns [void]
[isSet] returns [boolean]
and so on ...

Reflection is on of the tools that frameworks utilize to make things happen automatically. For example, if you create a Java Bean you can make a .JSP page automatically take form values and populate the bean using the setter methods. When Tomcat was being written they couldn’t predict what your particular object would look like, so they used reflection to look inside your object and find the appropriate methods to call.

Reflection is a good way to build future proof functionality. You can come up with a way of doing something that will work with any class you give it without needing to know about that class ahead of time or force the class to implement an interface.

It is a powerful tool that can help you achieve a great deal of simplicity. Automatically setting the values of a bean from a form in JSP is a good example of how reflection can simplify your code.

Here are a few links to discussions about reflection.

• Discussion of dynamic vs. static in Java
• How Apache BeanUtils use Reflection
• Discussion about how to get access to private fields and methods using reflection

I have some XSLT stylesheets that I use to integrate information from Amazon with my reading list on my website. This weekend I decided to create another list using Amazon’s “People Who Bought this Book also Bought” feature. After a couple generations of downloading books that were related to books I read, I ended up with an XML file with about 1,500 books in it. I tried running the transform using Xerces and it took 13 hours.

Obviously this wasn’t going to work, so I refactored parts of the XSLT and was able to cut that time in half. 6 hours still seemed like it was taking far too long. I considered doing away with the stylesheets and doing the transforms manually using Java to write directly to a file. After doing some searches I discovered that apache.org has a good solutions for this problem that is part of the Xalan-J project. Basically it allows you to take an XSLT stylesheet and compile it into java byte code called a “translet”. You can then run the transform using Xalan and the compiled java translet. This makes things run much quicker. It appears that this is because the transform doesn’t need to deal with the XSLT file and because of other optimizations.

To do this you must have xercesImpl.jar, xml-api.jar, and xalan.jar in your classpath. If you have problems be sure to double check this because the error message it gives you doesn’t always indicate that it can’t find a required class. Use the Xalan command line program to turn your XLST file into a translet.
java org.apache.xalan.xsltc.cmdline.Compile myXSLT.xsl

This will produce several class files:

myXSLT.class
myXSLT$0.class
myXSLT$1.class
myXSLT$2.class
myXSLT$3.class
myXSLT$4.class

To transform xml using this byte code do the following:
java org.apache.xalan.xsltc.cmdline.Transform myFile.xml myXSLT.xsl
This will run the transform using the byte code and output the results to the screen (unless you are redirecting the output from within the XSL file). To put it in a file:
java org.apache.xalan.xsltc.cmdline.Transform myFile.xml myXSLT.xsl > myFile.html

One thing I discovered was the fact that the redirect:write tag in my xsl file would not compile into byte code. I switched to using the xsltc:output tag instead and it would work, but the compiler always complained because I was using the select attribute instead of the file attribute. At first I thought I could just change the attribute name. However select allows you to use a variable name, but file does not. So <xsltc:output file="$filename"> will output to a file named “$filename” instead of whatever is in the variable $filename.

There is a way around this by using <xsltc:output file="{$filename}">

There are other options for doing the compile including -j which will put the class files into a jar and some options to allow you to compile multiple files at the same time.

When I finished figuring everything out I tried the same transform that had previously taken 13 hours on a 1,500 item xml file. This time I used a 5,000 item file, but it completed in 2 to 3 hours. If you use large xml files as input for XSLT transformations I would highly suggest looking into using translets.

• Another Bloggers take on Translets
• How translets relate to struts
• More praises and mention of a faster transform for stylesheets

People Found This When Looking For:

• java xslt transform is slow (1)
• xsl transform very slow xalan (1)