Bech on Enterprise Java

About Eclipse and Tekken

2007-03-13T07:23:00.000-07:00

Eclipse and Tekken

The keyboard shortcuts in eclipse are a bit like advanced Tekken combat moves, for those who aren't into computer games; Tekken is a very good fighting game for the Sony Play Station consoles. A lot of the cool moves can only be made using insane combinations of the controller buttons, in the right sequence. In that sense, Eclipse and the computer game has a lot in common.

So... I'm using Eclipse for the moment, and have after a long period of swearing started to adapt a way of working that is similar to what I'm used to with IntelliJ. Here are a few painkillers for other Eclipse users that are used to IntelliJ. I guess most of this will be "old news" to experienced Eclipse users, but who knows. Why might pick up a trick or two.

Before starting I have to say that I try to learn keyboard shortcuts for everything I do. Other people prefer clicking around in the interface and I respect that. However, working with mostly the keyboard has some advantages; It's faster, It's better for your health and it's faster (did I mention that?)

Even after a months of using Eclipse, I still get confused on what shortcuts that are available through CTRL+SHIFT and what is through ALT+SHIFT. A good way to remember what is what is to think of the alt+shift shortcuts as "menu shortcuts". To Illustrate; Pressing Alt+shift+s gives you about the same options as pressing "source" on the menu. The CTRL+SHIFT shortcurs are more often helper dialogues like Open resource (CTRL+SHIFT+R) or open type. (CTRL+SHIFT+T)

Anyhow; here's a compilation of my most used keyboard shortcuts for eclipse. If you use these in combination, you can probably put the mouse away entirely.

Ctrl+M (Maximise)

I try to do as much work as possible with the source code window maximised. I try to use the "Navigator", and "Package Explorer" windows as little as possible, as I have found no way to switch to them with focus, without using the mouse.

Ctrl+F7 (Switch views)

In IntelliJ U can easily hide and show windows like the project navigator using the ALT key and number in combination, when you want the window to go away, you can press the same key, or escape.

Using the Ctrl+F7 and Ctrl+M (see previous) in combination makes navigating the different windows a bit easier. This shortcut lets you switch between the editor, navigator, console and all other views. I use it a lot to quickly go to the editor and almost always follow up with a CTRL+M, to use the entire screen area for code editing.

Ctrl + . (Next problem)

This navigates you to the next "problem" (red or yellow marker in the sidebar).

Ctrl+Shift+T (Find Type)

Finding a class in the package explorer or navigator can be like finding the famous needle in the haystack. It is often faster to hit this combo, and start typing the name of your class.

The good news is that wildcards and camel-back searching works like a dream.

Ctrl+Shift+R (Find Resource)

Same as above, only for resources that is not java classes. (JSP files ,properties etc. )

Alt+Shift+T (Refactor)

This shortcut is pretty neat as it pops up all refactoring options, given the context of the cursor position. The action you want to take is available in only one more keystroke. In full "Tekken* style" the shortcut key for "rename" is the key 'n', instead of using for example 'r' (that is unused). Don't ask me why.

Ctrl+F6 (Open files)

This is probably my single most used Eclipse shortcut. It pops up a list of all the recent files you have edited. An annoying "feature" of this key is that the CTRL key has to be pressed while doing a selection, or at least for a period of time for the window to "stick". If you briefly press Ctrl+F6, you get your last window. The design idea is probably that you often swap between the two most recent files.

I always use the combo "alt+right/left key" for that, so for me this extra "intelligence" is just annoying.

Alt+Right and left Arrows

The alt key in combination with the left and right arrow keys can be used as a "back" and "forward" in the file history.

F3 (Go to declaration) and "Ctrl clicking"

The entire source code can be navigated as a hyperlinked system. If the cursor is over a class name and you press F3, you immediately go to the declaration of that class.. Pressing F3 while the cursor is over a variable takes you to the declaration of that variable.

Similar navigation can be done by holding down the ctrl key and moving the mouse around. When the mouse pointer is hovering over a class name or variable, the name of the class or variable turns into a clickable hyperlink.

other usefull shortcuts that you're probably used to from IntelliJ

Ctrl+Shift+O (Optimize Imports)

This is one of many features that IntelliJ has implemented a bit smoother than Eclipse.

In general, the "Auto import" feature doesn't work to well if your code has compilation errors. This can be impractical if you let's for example say you want to copy / paste a block into your code from somewhere, and get a lot of "red markers" in your code as a result of the unknown classes.

In Eclipse you should avoid typing entire class names, it's better to type half way through and ctri+space to auto complete. This is because it imples an automatic import.

Ctrl+Shift+F (Format code)

This key combo formats your code according to default of project specific format.

Alt+Shift+X, T (Run as unit test)

This is one of many Tekken moves in Eclipse. Press Alt+shift+X after a while, a hint-box should appear with your choices. Press T to run the current class as a unit test . A disadvantage of using this shortcut is that the class currently in the editor has to be the unit test. This shortcut is best used in combination with the CTRL+F11 shortcut explained later.

Ctrl+F11 (Run last launch config)

If you run your unit test once using alt+shift+X (something that can and will break your fingers over time) there is no need to press the same combo again. Just use Ctrl+F11 to re-execute your last "run" or "debug" configuration.

Alt+Shift+Z

The nifty surround with functionality, also the home of the automatic collection iterator shortcut.

Alt+Shift+S (source)

Here you'll find shortcuts to all the nifty things like implement/override methods, generate getters/setters etc.

Ctrl+F8

Working with perspectives is important in eclipse. The whole editor changes it's window layout when working in debug mode. The Ctri+F8 shortcut enables you to switch back to java view (where I usually work) after a debugging session.

Ctrl + T

View Implementation/type hierarchy. If your editor is showing an interface, and you want to know all available implementations, this shortcut is handy. It also works if your cursor is located over an interface declaration.

Working with JSF & MyFaces ; java.lang.IllegalStateException: Client-id : xxx is duplicated in the faces tree.

2006-11-06T03:48:00.000-08:00

If you're working with JSF using Myfaces nad Tomahawk, and you are getting a stacktrace like this, you have probably just changed the internal structure of your JSP page. For some strange reason, that doesn't work too well in all cases.

What you need to do, is to make sure a new browser session is started, and access the page again.

java.lang.IllegalStateException: Client-id : xxx is duplicated in the faces tree. Component : _idJsp0:minus, path: {Component-Path : [Class: javax.faces.component.UIViewRoot,ViewId: /cars/default/jsp/agreement/bets/doors/viewd........

Being an innocent victim of software development communism

2006-10-24T00:47:00.000-07:00

I like Analogies from the construction industry.

A carpenter comes to the house you are building. You welcome him, but ask him to leave his tools in the car; all carpenters and craftsmen working on your house have to use the exact same tools! You hand him, not crappy tools, but different ones than he's used to. Now watch this guy fumble, stumble and ask around.

I started writing, and I am probably going to finish a lengthy post about Eclipse annoyances, and how much I love IntelliJ. After being "force fed" Eclipse for the last 3 weeks, I've got some fuel for the fire so to speak. But, that's another story.

What I was thinking the other day, was how crippled I get when someone take away the tools I'm used to and give me new ones. Standardisation may be a good thing, but I say stop when it comes to my personal tools.

Continuous build systems (including reporting tools). CMS (Code management systems like CVS, Subversion etc), Test frameworks etc of course needs to be common for a development team.

However, IMO Developer's choice of container for development and IDE must be a personal choice. It's like dictating what kind of deodorant people should put on in the morning!

Disclaimer; this is my personal view, and not one of my employer. I respect the decisions taken by my current customer to standardize, even if disagree.

Poke 53281,0

2006-10-19T14:10:00.000-07:00

I recently heard the "Last ninja 2" soundtrack in a breakfast show on a Norwegian radio show. One thing lead to the other, And before I knew anyting of it I had a c64 emulator installed. To my great amusement, my fingers just automaticly typed in the command poke 53281,0 and poke 53280,0.....

Honour and respect to those who can reply with the result of theese commands on a C64 system .)

... And If this blog entry doesn't make any sense at all to you you're just not old enough :-)

More on the BEA 8.1 Servlet Filter & RequestDispatcher issue

2006-08-07T00:17:00.000-07:00

After doing some more research, it seems that the BEA developers found the Servlet 2.3 specification to be "ambigous", and decided to create an implementation that executes filters on both incoming http requests from cleients, and on request dispatcher requests.

This issue is resolved in the Servlet 2.4 spec. and there is a "dispatcher" element in the "filter" tag in web.xml

The valid values are:

- REQUEST: (default) only when the request comes directly from the client
- FORWARD
- INCLUDE

Please notice that the default behaviour has changed. Upgrading to Weblogic 9.2 or or doing a manual check in the filter for repeated requests solves the problem.

The BEA 8.1 Servlet Container implementation is causing problems for Jakarta Struts applications using filters.

2006-08-03T02:00:00.000-07:00

I just discovered some strange behavior in a struts based application that uses Hibernate, and a mechanism based on Thread local variables to hold Hibernate Sessions.

Servlet filters are a great tool to handle aspects of your web application like custom Authorization & Authentication logging, modification of requests etc. The servlet 2.3 specs say the following in Section 6.2.1

"When the container receives an incoming request, it takes the first filter instance in the list and calls its doFilter method, passing in the ServletRequest and ServletResponse, and a reference to the FilterChain object it will use. "

The BEA developers have obviously interpreted this to mean incoming request from clients, i.e. "regular" http requests, and requests coming in via the RequestDispatcher class. The Oracle OC4J does not execute the filter chain for incoming RequestDispatcher calls. This is where it gets interesting for Struts based applications.

There are two types of "forwards" in struts, those with redirect="true", and redirect="false". When the redirect attribute of the forward tag in struts-config.xml is set to "true", a response is sent to the client, forcing it to send a new request to the server.

The actual HTTP Response going to the web browser may look something like this ;

HTTP/1.x 302 Moved Temporarily
Date: Thu, 03 Aug 2006 08:37:07 GMT
Server: Oracle Application Server Containers for J2EE 10g (10.1.2.0.2)
Content-Length: 222
Connection: Keep-Alive
Keep-Alive: timeout=15, max=100
Content-Type: text/html
Location: http://localhost:9999/adminssytem/viewEmployees.do

In this case, the filter chain should- and is, executed twice per client transaction. The user does not notice both requests though. This practice is quite common when using the HTTP Post method, so that the user can "reload" the page in his browser without re-posting the form data.

The forwards with redirect="false", uses a RequestDispatcher to forward requests internally. This is sometimes also called "Server Side redirect", and is very useful since you can chain struts actions together in a "Chain of responsibility pattern". By creating small reusable actions, you can easily use them as building blocks in your application.

The fact that BEA chooses to execute the filter chain, between struts actions has a huge impact on code relying on this mechanism. Taking the example of Authorization, a costly verification of user credentials will be executed between each Struts action. With long action chains, this can be a huge performance penalty.

In this Example;

<action path="/deletePhoneNumber"

type="DeletePhoneNumberAction"

name="PhoneForm"

scope="request">

<forward name="success" path="/viewPhoneNumbers.do"/>

</action>

<action path="/viewPhoneNumbers"

type="ViewPhoneNumbersAction"

name="PhoneForm"

scope="request">

<forward name="success" path="/WEB-INF/jsp/displayNumbers.jsp"/>

</action>

A filter with a .do mapping, will be executed two times in the Weblogic server.

1) On the initial HTTP Request hits the deletePhoneNumberAction.
2) After the DeletePhoneNumberAction is finished, and before the viewPhoneNumbers Action is executed.

This can impact design, cause bugs, and slow down the system significantly. If anyone has a workaround, or know of an entry in the weblogic.xml that solves this, please feel free to comment. It would also be interesting to know the rationale behind the decision to implement the Servlet container with a very “creative” interpretation of the specification in this case.

Struts 1.2: Why is not the reset, validate or even execute invoked?

2006-07-25T05:37:00.000-07:00

Here is another one of those stupid mistakes that can keep you wondering what's going on;

As you probably know, Struts lets you override methods in the ActionForm class. It's quite common to override both the validate(), and reset() method.

It's however very important to notice that there exists two of each ;

public void reset(ActionMapping mapping,
javax.servlet.ServletRequest request)

public void reset(ActionMapping mapping,
javax.servlet.http.HttpServletRequest request)

and

public ActionErrors validate(ActionMapping mapping,
javax.servlet.ServletRequest request)

public ActionErrors validate(ActionMapping mapping,
javax.servlet.http.HttpServletRequest request)

If you override the wrong method (the ones with the ServletRequest signature, instead of HttpServletRequest), you'll soon notice that you code is not getting executed.

The JavaDoc claims for the generic methods "The default implementation attempts to forward to the HTTP version of this method." What "Attemts" means beats me. In the cases where I've made this mistake uptil now, that "attemt" has not succeeded.

Please note that this fact also applies to the Action class itself. There exists one execute() method for the Generic Servlet Class, and one for the HTTP Servlet.

I'm not sure why the design is like this; I havn't heard of anyone using Struts to SIP Servlets, or any other kinds of servlet other than HTTP.

If you googled for the problem, and found my page; Please let me know and add a comment ! :-)

Hibernate: Could not synchronize database state with session, Unexpected row count: 0 expected: 1

2006-06-23T06:29:00.000-07:00

If you get this error message during a session.flush();

Could not synchronize database state with session
org.hibernate.HibernateException:
at org.hibernate.jdbc.NonBatchingBatcher.addToBatch(NonBatchingBatcher.java:32)

And let's assume you're working with a Persistent object with a generated primitive key, and an "unsaved value" strategy. Your problem is probably that you forgot to initialize the private field used as an id to the "unused value". This means that you should never never never write a persistent class like this ;

public class MyClass () {
private int id ;
}

But rather do this ;

public class MyClass () {
private int id = -1 ;
}

One of those stupid mistakes that can snaeak in and cause some minutes of headache. Did you get here by searching for the exception, and this solved your problem, please leave a comment! :-)

Problems with Jakarta Axis 1.3 in Oracle 10g (10.1.0.2)

2006-02-23T03:57:00.000-08:00

Since I found the solution to this problem on a japanese site (jajakarta), and no trace of it elsewhere I better blog it. I can now only hope that google and all other search engines will index this page, and display it when someone enters the keywords "oracle.xml.parser.v2.XMLDOMException Axis"

When you atempt to deploy a web service on the Oracle 10g platorm (10.1.0.2), using Axis 1.3 straight out of the box, you run into problems with the Oracle XML parser.

I'm not sure exactly what causes this, but I've tracked it down to the class org.apache.axis.utils.XMLUtils It seems this class is not able to initialize fully with the Oracle provided XML libraries.

The result of this problem, is that if anyone try to auto generate a WSDL file by appending ?wsdl to a service

example : http://localhost/services/sampleservice?wsdl )

Axis will provide the following output

Fault - ; nested exception is: oracle.xml.parser.v2.XMLDOMException: Implementation does not support the object requested.

The soultion to this problem is to specify command line arguments to the java VM running the server during startup like this ;


-Djavax.xml.parsers.SAXParserFactory=
      org.apache.crimson.jaxp.SAXParserFactoryImpl
-Djavax.xml.parsers.DocumentBuilderFactory=
      org.apache.crimson.jax.DocumentBuilderFactoryImpl

As you can see, we here decide to use the crimson parser instead of the one provided in the Oracle XML library. We could also have included Xerces in our application and sepcified the parser provided there ofcourse.

The top 10 Things i Love the most about IntelliJ IDEA (5.1)

2006-02-20T01:40:00.000-08:00

Just like a carpenter needs a good saw and hammer, having a good IDE is paramount to being a productive developer. I recently upgraded from IDEA 4.5 to 5.1 and would like to tell you all how much I enjoy working with my new tool.

This is the top 10 features I use most, and that has the greatest impact on my workflow. The focus here is fast code editing, and does not take into consideration major other features like App server integration, code analysis etc.

Please feel free to comment on this entry with other nifty workflow tips !

- “Rename” (Shift+F6) with this key combo I can refactor the name of methods and members when I am about to use them. You usually discover that the name of a method is bad when you’re about to use it. Being able to rename it, without going to the declaration saves a lot of time. Bad names are a thing of the past.

- "Recent files" (Ctrl + E) this key combo displays a list of the last edited files. I Usually want to go back to one of the last three files I worked on.

- "Quick find class or file" (Ctrl-N and Ctrl-Shift-N). This feature really speeds up my workflow. Instead of using the tree-navigator to find a class, I can press ctrl+n, type in the name of a class. Matches are displayed as I type. This also works for other files using the ctrl+shift+n. In conjunction with the "recent files” I end up not using the mouse. In fact, when doing only coding with my laptop, I sometimes don't connect the mouse at all.

- “Delegate” (Ctrl+insert) this neat feature lets you expose the interface of a contained class. If you've been using the decorator design pattern/wrapper you understand the value of this neat feature.

- “Subversion Integration”. I was waiting for this. Setting up subversion was a pain in 4.5 involving copying of binaries to your windows directory. In 5.1 Subversion integration is integrated, and works very well. You can even use the IDEA file compare when you have subversion conflicts.

- Ctrl + mouse click. If I’m inside a configuration file (Struts-config.xml for example) and need to quickly go to the Action class specified in an action mapping. Hold the Ctrl key in, and the text representing the class name becomes clickable.

- "Reformat code" (Ctrl + Alt + L) I’m currently write code for a client not using the same coding standard I’m used to. Setting up intelliJ to meet their standard was very painless. I find myself pressing this key combo on reflex now.

- "Optimize imports" (Ctrl + Alt + O). Quickly removes redundant and unused class files form my imports.

- "Source health indicator" The Red/Green/Yellow light indicating the state of my code. Seeing the green light, I instantly know the file compiles.

- "Source problem tags" The Red/Green/Yellow bars indicating problems in my code. If I am editing at the bottom of my source file and my source indicator is yellow, I look for see some yellow bars at the “top” of my code, this usually means that some imports are now redundant and I press. Ctrl-Alt-O, and… Voila! The yellow bars disappear and the light is back to green.

Intellij IDEA: Additional javadoc tags for xdoclet(Hibernate and ejbdoclet tasks)

2006-02-16T02:43:00.000-08:00

I recently had the need to collect all tags used by xdoclet for the hibernate, and ejbdoclet tasks so that I could import them into the "unknown javadoc tags" of intelliJ. Since a precompiled comma separated list was hard to find for ejbdoclet, I share them just in case someone should find it useful.

Ejbdoclet tags

ejb.activation-config-property,ejb.bean,ejb.dao,ejb.data-object,
ejb.destination-ref,ejb.ejb-external-ref,ejb.ejb-ref,ejb.ejb-service-ref,
ejb.env-entry,ejb.facade,ejb.finder,ejb.home,ejb.interface,ejb.message-destination,ejb.permission,ejb.persistence,ejb.pk,ejb.remote-facade,
ejb.resource-env-ref,ejb.resource-ref,ejb.security-identity,
ejb.security-role-ref,ejb.security-roles,ejb.transaction,ejb.util,ejb.value-object,dao.call,ejb.aggregate,ejb.create-method,ejb.ejb-external-ref,
ejb.ejb-ref,ejb.ejb-service-ref,ejb.env-entry,ejb.facade-method,ejb.home-method,ejb.interface-method,ejb.permission,ejb.persistence,
ejb.persistent-field,ejb.pk-field,ejb.relation,ejb.resource-env-ref,
ejb.resource-ref,ejb.select,ejb.transaction,ejb.value-object,
ejb.ejb-external-ref,ejb.ejb-ref,ejb.ejb-service-ref,ejb.env-entry,
ejb.resource-env-ref,ejb.resource-ref

Hibernate tags

hibernate.cache,hibernate.class,hibernate.discriminator,
hibernate.jcs-cache,hibernate.joined-subclass,hibernate.joined-subclass-key,hibernate.mapping,hibernate.query,hibernate.subclass,
hibernate.any,
hibernate.any-column,hibernate.array,hibernate.bag,hibernate.collection-cache,hibernate.collection-composite-element,hibernate.collection-element,hibernate.collection-index,hibernate.collection-jcs-cache,
hibernate.collection-key,hibernate.collection-key-column,
hibernate.collection-many-to-many,hibernate.collection-one-to-many,hibernate.column,hibernate.component,hibernate.generator-param,hibernate.id,hibernate.index-many-to-many,hibernate.list,
hibernate.many-to-any,hibernate.many-to-any-column,hibernate.many-to-one,hibernate.map,hibernate.one-to-one,hibernate.parent,hibernate.primitive-array,hibernate.property,hibernate.set,
hibernate.timestamp,hibernate.version

Arne Berner provided me with these ones for Weblogic as well(http://aberner.blogspot.com/ )

(Moved from comments to main blog entry)

weblogic.allow-concurrent-calls,weblogic.allow-remove-during-transaction,weblogic.automatic-key-generation,weblogic.cache,weblogic.cache-ref,weblogic.clients-on-same-server,weblogic.clustering,weblogic.create-as-principal-name,weblogic.data-source-name,weblogic.delay-database-insert-until,weblogic.dispatch-policy,weblogic.ejb-local-reference-description,weblogic.ejb-reference-description,weblogic.enable-batch-operations,weblogic.enable-bean-class-redeploy,weblogic.enable-call-by-reference,weblogic.enable-dynamic-queries,weblogic.iiop-security-descriptor,weblogic.instance-lock-order,weblogic.invalidation-target,weblogic.lifecycle,weblogic.lock-order,weblogic.message-driven,weblogic.order-database-operations,weblogic.passivate-as-principal-name,weblogic.persistence,weblogic.pool,weblogic.pool-name,weblogic.remove-as-principal-name,weblogic.resource-description,weblogic.resource-env-description,weblogic.run-as-identity-principal,weblogic.run-as-principal-name,weblogic.transaction-descriptor,weblogic.transaction-isolation,weblogic.use-select-for-update,weblogic.verify-rows

Spring vs. J2EE? Does Spring really suck ? - Let Google decide !!

2006-02-01T06:32:00.000-08:00

When faced with a tough business-, architectural- or design decision, why listen to Gartner, Jupiter or any so called analysis company? The solution is as always free, and readily available.

When choosing a middleware or framework, it is crucial that there is a critical mass of users out there, finding & fixing bugs, blogging, producing tutorials etc. This is especially important with open source!

So! One could easily argue that the maturity and quality of a product can be related to the number of people that are currently building software with it. (aka People are not stupid!) One could also easily assume that the more people that are involved with a product, the larger internet footprint as more web pages are produced!

So, let's think. Who is currently number #1 at measuring this? Google is at least a good candidate. I'm therefore introducing a new measuring unit called IGP (Indexed Google pages)

Publicity and published pages and number of pages is not always positive. So let's add another factor to the equation, and introduce yet another TBF called NGP or Negative-Indexed Google pages. The NPG is a measure of how many indexed pages Google has, with the product name in the proximity of a negative word.

First, i tried one of there more obscene curse words I know, with let's say "Interesting results". I ended up using "headache" instead since it produces less explicit results, and bad frameworks often gives us developers a lot of headaches.

Now... Let's put this methodology through the test. Let us put J2EE and the Spring framework Head-to-head!

Since "Spring" is a fairly general word, I am bold enough to state that pages related to the spring framework should contain both the word "Spring" and "Java". I believe this is a reasonable assumption.

Words and Technologies	IGP	NGP	Ratio
J2EE + (headache)	24,900,000	58,400	0,0024
Spring Java + (headache)	9,740,000	208 000	0,021

Looking closer at the table, we can easily conclude that the J2EE framework is far more mature and holds a level of quality (A factor of 10!) superior to the Spring framework! J2EE has both a higher IGP and lower NGP ratio than Spring. I guess CrazyBob was right after all!

Feel free to use this methodology to put other technologies head to head, and please blog the results!

Struts 1.2 & Velocity Tools; ActionMessagesTool and ErrorsTool confusion

2006-02-01T03:49:00.000-08:00

This is probably obvious to most experienced front end programmers. But since I spent 30 minutes digging in apache code, and 15 minutes fixing a misunderstanding in my code, I'll blogg my embarrassment.

Let's say you have a struts action with the following catch clause. Notice that we use the ActionMessages class instead of the ActionErrors class to contain error messages. The use of ActionErrors and ActionError is one of the things that have changed from Struts version 1.1 and 1.2 (See also previous blog entry)


catch (SomebusinessException e)  {
    ActionMessages errors = new ActionMessages();
    errors.add("name", new ActionMessage("error.general.name_already_in_use"));
    saveErrors(request, errors);
    return mapping.findForward("input_error");
}

This might lead you to think that you should use the ActionMessages Tool in Velocity. This is (of course) not the case since we still use the "saveErrors" method in our Action subclass. So, when rendering the error message you (still) have to include the ErrorsTool in your toolbox.xml


<tool>

<key>errors</key>
<scope>request</scope>
<class>
   org.apache.velocity.tools.struts.ErrorsTool
</class>
</tool>

The ActionMessagesTool should NOT be used. ErrorsTool and ActionMessagesTool, and both are actually just very thin wrappers to the StrutsUtils class. The ActionMessagesTool class uses a method in StrutsUtils called getMessages() that does the following ;


ActionMessages errors = 
    (ActionMessages)request.getAttribute(Globals.MESSAGE_KEY);

The ErrorsTool uses a method in the StrutsUtils class called getErrors() that does the following ;


ActionMessages errors = 
    (ActionMessages)request.getAttribute(Globals.ERRORS_KEY);

So using the wrong Velocity tool (ActionMessagesTool) gives you an empty collection of messages when you have invoked the saveErrors method in your Action class. Beware!

Struts: Going from 1.1 to 1.2 error handling

2006-01-30T01:41:00.000-08:00

Assigned to upgrade some code for my current client I discover that the way to do error handling and display error messages has changed between version 1.1 and 1.2 of the Struts framework

There has definitly been some deprecations

- add(String, ActionError) in the ActionErros classs is deprecated.
- saveErrors(HttpServletRequest, ActionErrors) in the Action class is deprectated.

The ActionErrors class itself, however, is not deprecated. It seems that there are too many internal dependencies to this class. But the contributors would like to remove it, so it will probably disappear in future releases.

The ActionError and ActionErros scheme is now replaced with ActionMessage and ActionMessages.

After doing some reading, it seems the html:messages tag was introduced because people didn't like the fact that using html:errors required HTML markup in the message resources. Using html:messages removes this requirement.

I found this very good article describing migration on the Struts Wiki. Since there was no mention of this in the "official" developer guide, I guess that more and more informatio will be published through the Wiki. Maybe someone should copy the entire development guide over there.

The upgrade guide can be found here:
http://wiki.apache.org/struts/StrutsUpgradeNotes11to124
Notes on the deprecations on error handling can be found here:
http://wiki.apache.org/struts/StrutsDeprecatedActionErrors
A Practical example on how-to do it can be found here
http://www.niallp.pwp.blueyonder.co.uk/HelpTagsErrorsAndMessages.html

So... In summary Old Code like this:

ActionErrors errors = new ActionErrors();
errors.add(ActionErrors.GLOBAL_MESSAGE, new ActionError("error.user.internalerror"));
saveErrors(request, errors);

Has to be replaced with code like this

ActionMessages errors = new ActionMessages();
errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage("error.user.internalerror", e.getMessage(), e));
saveErrors(request, errors);

And the JSP code that used to look like this ...

<html:errors />

(Where you had to specify header, footer, prefix and suffix for error messages like this)

errors.header=<h3><font color="red">Validation Errors</font></h3><ul>errors.footer=</ul>
errors.prefix=<li>
errors.suffix=</li></em>

... Is now replaced with JSP code like this ;

<logic:messagesPresent>
<h3><font color="red"><bean:message key="myForm.error.header" /></font></3>
<ul>
<html:messages id="msg">
<li>bean:write name="msg" /></li>
</html:messages>
</ul>
</logic:messagesPresent>

A change for the better if you ask me, Let's hope the Struts guys will put all the documentation in one place soon, and take out that last ActionErrors class that still isn't deprecated.

"Improving software quality, - by accounting for our slow brains"

2005-07-18T16:18:00.000-07:00

Isn’t it amusing that the solution to complex problems you encounter in your work all of a sudden pop into your head? Maybe during dinner? In the shower? while watching a movie? How about that test you took at school, with that last tricky question, that you all of a sudden see the solution to, clear as day, three days after turning in the test?!

Have you noticed that the code you wrote a month ago now seems to suck? I’ve definitely had both the “Eureka”- and the “what the heck did I do here!?” syndrome lots of times over the years.

If you look up the scientific papers, I’m sure you’ll discover that the brain isn’t very fast. It can process massive amounts of data, but the throughput just isn’t all that great. So! How can we take this into account when trying to improve as software professionals?

The solution might be to constantly have a number (two to three) tasks going on at the same time. That way, thoughts and Ideas can mature over time, and smart solutions might appear almost by themselves.-) so… My theory is that we can improve quality and maintain productivity by working multitasked but at a slower pace…

What do you think?

Java SE: Avoiding NullpointerExceptions by not initializing local variables to null

2005-06-16T00:59:00.000-07:00

I'm sure this is fairly obvious to a lot of experienced programmers. However, having not paid enoght attention to the small details this was recently pointed out for me (emberrasingly enough!) It's now a part of my "good coding practices".

In this piece of code we might get a NullPointerException at the 0.toString(). This happens if an exception is thrown inside the try/catch block We shold have logged the event and terminatet the flow of execution in the catch block, but forgot to do so!

public void bad() {
Object o = null;
try {
o = callSomeMethod();
} catch (Exception someException) {
someException.printStackTrace();
}
o.toString() ;
}

This code compiles, but will result in a nullpointer exception when in the cases where someMethod throws someException.

Situations like this can easily be avoided by not initializing the variable o to null. In this piece of code we not NOT initialize the object o, and get a compiler error at the .toString() method call, because there is a change that the variable 'o' has not been initialized.

public void good() {
Object o ;
try {
o = callSomeMethod();
} catch (Exception someException) {
someException.printStackTrace();
}
o.toString() ;
}

By avoiding initializing local varibales to null, we can avoid some of those NullpointerExceptions, and get more robust code!

Team dynamics; What happened to all the emails ?

2005-06-13T12:35:00.000-07:00

After working two or three weeks as a consultant for a very small client I'm puzzled by my current working environment!

My sureprise might come from fact that I've spent the last three years as an employed developer in in a fairly large financial organisation. A month ago I had a spacious desk, located in an open office solution with my project coworkers located in both the same room and the one adjacent. The customer was located in a different building.

At the moment, Im crammed into a small office, working with six or seven developers, litteraly sharing a desk with a co-worker. The closest thing to a "Customer", is the manager of the company (also speaking "tech") coming in from coffee once in a while.

It's natural to guess that it's going to be less formal and written communication in such an organisation, but what sureprises me is that almost no emails are sent!

Working for the large oranisation , I would often write lengthy emails to developers working in the room adjacent to mine, and cc the customer (or project manager) just to keep things "on the record" or to inform. I would use email to send files, tools, documents or whatever information that I wanted to distribute to team members.

The Outlook calendar was the plan of the day, and I would use it to organize meetings with my co-workers (located in the same room!) Even repeated meetings were scheduled this way.

Now things are different. USB Memory sticks are litterly flying around in the room, other files, links, code and documents are transfered using MSN or other IM variants. Meetings seem to be organised on a "need to have" basis, both regarding to timing and who actually participates.

In three weeks, I have received one or two emails from team members, in the same period of time, working for the financial institution my number written and receieved project related emails would have been in the range 100-150 (aproxemately 10 a day).

Im not sure what to make of this; It's just very interesting to see how different teams work differently. But Im sure I could have spent less hours writing emails and more hours writing code :-)

Distributed Caching mechanisms and sharing data in a cluster

2005-06-12T07:24:00.000-07:00

Working in the area of telecom, I just had the need to share data in an environment that has to ble highly scalable. The system will be set up as a cluster of BEA weblogic servers.

So.. How is it possible to share data, and efficiently cache data in such environments ? Im currently researching this, and have to implement some kind of sollution. The alternatives so far seems to be either to do it in the managed Weblogic environment, or do it on a lowever
level (Using socket communications).

Managed environments

This article describes a mechanisms for configuring up a Cache MBean in the weblogic server.
This article describes both an "easy to configure" solution that requires the administration server to be up and running all time. That is probably not acceptable in a HA environment.

It also introduces a JMS based broadcast sollution that are more robust, but requires more code.

http://dev2dev.bea.com/pub/a/2004/01/jiang.html

Using lower level mechanism

Distributed sharing of data and caching is also possible using TCP/UDP directly. The downside is that you have to configure this outside the component container, reducing maintainability.

(Copied from the site) JCS is a distributed caching system written in java for server-side java applications. It is intended to speed up dynamic web applications by providing a means to manage cached data of various dynamic natures. Like any caching system, the JCS is most useful for high read, low put applications. Dynamic content and reporting systems can benefit most. However, any site that repeatedly constructs pages, dropdowns, or common search results from a database that is updated at intervals (rather than across categories continuously) can improve performance and scalability by implementing caching. Latency times drop sharply and bottlenecks move away from the database in an effectively cached system.

http://jakarta.apache.org/jcs/index.html

Frameworks: Increasing productivity with Spring?

2005-05-23T10:53:00.000-07:00

I read this article on Spring and found it very usefull as a good starting point for myself. Having experienced the pain of writing testable and nice looking code in enterprise environments, I must honestly say that the framework looks promising.

http://www.onjava.com/pub/a/onjava/2005/05/11/spring.html

My first thoughts lead my mind back to the first time I started using EJBDoclet in conjunction with Maven (Wich I found reveloutionary at the time)

Since I knew the EJB 2.x Specification by heart I had no trouble finding my ways around cryptic error messages, generated descriptors with bugs in them, merge-files problems etc. I knew what all the generated stuff were supposed to look like.

So, The future will be very intersting; And a question came to mind

Do frameworks make you more productive before you know all the nitty-gritty details of all It's building blocks ?

Dependency injection, IOC patterns in general, Micro Containers and Hibernate are fairly new terms in my vocabulary. How much of this must I learn to get increased developer efficiency with Spring ? How much time will I spend debugging Hibernate code ?

Only time will show .-)

Patterns: Decorator. A Real life example

2005-05-12T02:21:00.000-07:00

The book Design Patterns: Elements of Reusable Object-Oriented Software, by Erich Gamma et al, classifies the Decorator pattern as a structural pattern. This pattern offers a flexible alternative to subclass. The main difference between subclassing and the Decorator pattern is this: with subclassing, you work with the class, whereas in the Decorator pattern, you modify objects dynamically. When you extend a class, the change you make to the child class will affect all instances of the child class. With the Decorator pattern, however, you apply changes to each individual object you want to change.

Need a very tangible and real example ?

Car suppliers often attach license plates to framings with their brand name printed on it. This framing, with the plate attached, are then again mounted on the car. In This way everyone can see where you bought your brand new car. If you're real cool you replace it with a custom one, like the one's show here from http://www.autolicenseframes.com

The framing is just a few centimeters wider than the license plate. The license plate fits into the framing. The bolt holes in the frame and the license plate are perfectly aligned with the holes in the car. This can be viewed as the interface or contract.

The framing can therefore be said to comply to this interface and it wraps the license plate. The framing adds functionality (aestethics) to the license plate without modifying it. No subclassing needed, in other words a real life decorator !

Patterns: Factory and Decorator, a powerfull combination

2005-05-12T01:40:00.000-07:00

Introduction

While working on a system that distributes passwords throgh different communication channles (email, SMS, snailmail etc) I noticed that the sloppy programmer (hired consultant ofcourse) had written the system with no audit logging what-so-ever.

Since the system had a fair general design, I figured out that adding logging, transparently to clients, without having to change the implementation should possible.

The old design

An interface called Distributor, and a set of implementations are the main point of interest. The Distributor interface declares one method called distribute. All concrete distributors implement this method.

A DistributionFactory class creates implementation clases based on an input parameter holding customer information. The business rules are not really important in this case so I've removed the argument to the constructor for simplicity

Exploring alternatives

The easiest way out here is of course to just go ahed and implement audit logging in all the Distributor implementations. Of course, this would be a violation of the DRY principle.

At one point I was tempted to create a Template. This would require me to create an abstract base class for all distributors with an abstract method called handleDistribution (or something similar)

I would then have had to modify all distributors and rename the method that implemented the functionality to handleDistribution, and of course implement the distribute (in the abstract base class) so that it would first call handledistribution, and then do logging later

The total impact of this would have been

No Change in the factory class, that's great!
Code changes in all distributors. Modify to extends the parent class. Not so great!
Rename of one method in every distributor. Not so great!
Create one new abstract base class with the template code. Not so great!

Using a Decorator

A real elegant solution is introducing a Decorator. The Decorator class conforms to the exising Distributor interface. The Decorator in this case is called LoggingDistributor

The LoggingDistributor takes a Distributor as an argument in the constructor, and impelments the distribute method by delegating the method calls to that actual instance. After
the delagation, it logs the event.

Conclusion

I was very satisified with this design, since it enabled me to change the system with minimal impact on the existing code. Only the Factory class is modified, and only one class added.

I think this is a great example, outside the GUI world, on how the Decorator and Factory pattern together can be very usefull in adding functionality to an existing system causing a minimal amound of modification.

source code available here