Magnus K Karlsson

How to install Oracle JDK on Ubuntu 11 from repository.

2012-01-31T02:16:00.000+01:00

With Oracle the acquisition of Sun the Oracle have retired the "Operating System Distributor License for Java" (JDL) and the only available JDK release will be the OpenJDK. I had previously some bad experience with the OpenJDK and I prefer to use the official Oracle version of JDK, but I don't want to install the JDK binaries manually – we are using Ubuntu! But the webupd8.org team have been nice to published the binaries in a Personal Package Archives (PPA) and so far I have no problem using it, so I can warmly recommend using it.

To install:
sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update
sudo mkdir -p /usr/lib/mozilla/plugins #just in case, this will be added to the package in the next version
sudo apt-get install oracle-jdk7-installer

And to uninstall:
sudo apt-get remove oracle-jdk7-installer

And to verify your installation:
java -version
java version "1.7.0_02"
Java(TM) SE Runtime Environment (build 1.7.0_02-b13)
Java HotSpot(TM) 64-Bit Server VM (build 22.0-b10, mixed mode)

And to verify the web browser installation:
http://java.com/en/download/installed.jsp
Verified Java Version
Congratulations!
You have the recommended Java installed (1.7.0_02).

And with maven 2:
mvn -version
Java version: 1.7.0_02
Java home: /usr/lib/jvm/java-7-oracle/jre
Default locale: en_US, platform encoding: UTF-8
OS name: "linux" version: "3.0.0-15-generic" arch: "amd64" Family: "unix"

Java Web Start
The only thing that did not work out of the box was the Java Web Start. To fix that open JNLP file link and when asked for application, brows to:
/usr/lib/jvm/java-7-oracle/bin/javaws

For complete reference see:
http://www.webupd8.org/2012/01/install-oracle-java-jdk-7-in-ubuntu-via.html

How to Make a Launcher (Shortcut) in the New Ubuntu 11.10 (Oneiric Ocelot) Dock.

2012-01-31T01:42:00.000+01:00

In my previous blog I wrote about how to create a custom launcher to the Unity dock, but when you upgrade to 11.10 (Oneiric Ocelot) that no longer holds. When you right click on the desktop the menu item Create Launcher... is no longer there.

The simplest way I have yet found is to manually create a desktop file anywhere one the file system, but I would recommend to put it in the same folder as the program you are creating to shortcut to.

Example of my eclipse.desktop:

How to implement MVC (Model View Controller) Pattern with Swing – Part 3

2012-01-31T01:28:00.000+01:00

In my third blog about implementing MVC pattern in Swing I will look at how to implement global actions, context sensitive global actions, updating status bar and popup dialogs. But before delving into these issues and I would like again to repeat each class responsibility in the MVC pattern:

Model:

Simple POJO model.

View:

Layout out the Swing components.
Responds to user action by sending request to Control.
Responds to Controller responds.

Controller:

Receives request from the View.
Do logic.
Sends Responds to View(s).

And a last reminder the Request and Responds to and from the Controller should be TOTALLY view technique neutral as the Model. The view specific code, in our case Swing code, ends in the view. Handling all Swing code is the responsibility of each view.

In my previous blog we have seen that each View is only responsible of its Swing component and what happens in other view is it totally unaware of. Try to think of separation of concern. It is the responsibility of the Controller to call the Response methods in each Views that should be updated.

Example:

And the corresponding Controller code:

The Toolbar is yet Another View

So now lets start with looking how to add a JToolBar to our Swing client. If you think of it for a while you will realize that the toolbar is yet another view. So lets write a new class that extends from our AbstractView.

I have here used javax.swing.Action for base class, since they contain all graphical properties such icon, label and tooltip. But also javax.swing.Action can be used for JButton and in JPopupMenu and JMenuItem.

And I have also deliberately not created a abstract class for our action, which could have loaded our images, since I do not believe that such extra abstraction class will not bring any extra to our code nor reduce the number of lines. It will only make our client code more less understandable. But what would justify an extra abstraction layer is if abstract action class called the Controller in thread safe ways and change cursor to busy and in case of failure show a generic exception dialog. That would really bring something to our code, but not loading icons, using Action is quite straightforward and I like to see directly what my code does.

Handling Context Sensitive Global Actions

So after realized that the toolbar is just another view, lets move onto how to make the toolbar context sensitive, i.e. when switching active panel/window the save actions is replaced with the active panel/window save action. But before we must first decide where the concrete Swing save action should be located. It clearly belong to the concrete view. Think again of separation of concern. But what we must do is to expose the global actions so we can send them to the toolbar view. And lastly where do we wire the views together? In the Controller of course.

Let first add an extra method in our abstract view:

Then in our controller we wire the global actions from the view to the toolbar view.

And in our toolbar view:

The last thing we need is to do is to switch back to the default when changing to other views. Here it can be justified to introduce some kind of View lifecycle mechanism, so the programmer does not have to concern about setting the correct toolbar action each time a new View is retrieved.

Managing a Statusbar

After thinking the GUI as a composition of different views, it should not be surprising to think of the statusbar as yet another view as well. And where is the respond sent to update this view. In the Controller of course. Here is a simple example how to implement a statusbar with swinglabs JXStatusBar.

se.msc.mvcframework.demo.view.StatusBarView

Managing Modular Popup Windows

The modular popup windows is also yet another view. The only difference it needs a parent JFrame to show from. And the solution to that is simple. Each View has a reference to the AbstractFrame that holds the JFrame via getFrame().

How to Merge PDF Files in Ubuntu

2012-01-23T10:37:00.001+01:00

There are so many good web article that you would like to read and sometimes they even stretch over several web pages, but what if you are not online or like to concatenate several different article of your choosing?

One way to do it, it to use the build in print to PDF file in Ubuntu. But what if there are several article? Then you probably want to merge these PDF files. In Ubuntu that is an easy task.

First install pdftk:

Then type the following in the the directory where all the pdf files are:

For a complete reference see http://ubuntuhowtos.com/howtos/merge_pdf_files.

Putting Logic in finally is not Thread-safe

2012-01-23T09:14:00.001+01:00

This is not a very good documented feature in Java. And if you search the web for when to use finally you will find numerous example of using finally for closing resources. And these are good example of when to use finally, but what they will not tell you is that the finally code will run in a separate thread with low priority. This means that if you put logic in your finally block this code will not be thread safe. No matter what you do to make it thread-safe.

The same thing goes if you are depending on the state of the resource. For example if you are building a state machine that should change state whenever a resource is open or closed. And you are relying and whichever the resource is open or closed by calling the resource itself. This will not be thread-safe if you close the resource in a finally block.

How to Make a Launcher (Shortcut) in the New Ubuntu 11.04 (Natty Narwhal) Dock.

2012-01-21T14:36:00.004+01:00

I have been using Ubuntu for some time for writing Java code and for that I use Eclipse. You can install Eclipse via Ubuntu repository, but you probably don't wont to do that because the version in the Ubuntu repository is so old. And installation of Eclipse is so easy, simply download the tar archieve and decompress it to any folder of your liking and then duoble click the eclipse executable.

But after that you probably want a Launcher in the Ubuntu dock? But how do you do that? There is a build in plus icon application for that, but in that program you you can only use installed program, not random program simply unzipped on your disk.

So to make a arbitrary launcher:

1. Right click on you desktop and select 'Create Launcher...'.

2. Type in Name, Command path and optional Comment.
3. And finally click on the default icon and brows to your eclipse home folder and select icon.xpm.
4. Then move the Launcher file to ~/.local/share/applications.
5. And finally drag the Layncher file from ~/.local/share/applications and drop it on the Ubuntu dock.

How to implement MVC (Model View Controller) Pattern with Swing – Part 2

2012-01-20T21:09:00.000+01:00

In my previous blog I lay the ground of the definition of the MVC pattern and showed you have to implement it with Swing technology. I also defined a minimum set of classes that will help you to separate the client code into the MVC components – View, Controller and Model.
In this blog I will implement a more complex Swing client to show you that the minimum set of framework classes still holds for upholding the separation of concern between the View, Controller and Model. And the MVC pattern really deliver a component based architecture. That is even if you decide to rearrange the views, that will not impose the previous written code of the views, you merely need to rewire the code in the controller. And maybe foremost the code will be clean and what I hope most, will be easy read and follow.

But first lets repeat the responsibilities of each class in the MVC pattern

View	Layout the Swing components. Sends user action request to the Controller. Updates the View from Controller responses.
Controller	Do business logic. Sends responses to views.
Model	A POJO.

And a few warnings:

Don't do any logic in the Swing Action, e.g. open other dialogs or frames, call for update in other views. All these code will only destroy the maintainability of you application, because what it is breaking the law of seperation of concern. A specific View should not be aware and shoould not care what other Views are doing. What the View should do is merely pass the user action to the Controller and it is the job of the Controller to decide what to do with the request.

For example. The Controller X recieves a request, does some logic, such as calling the Server Facade and recieves the responds. Call for update on View Y, Z and E and open a new dialog.

By keeping the swing logic in the Controller and also keeping the Controller free from Swing code, it will be easy to go back later to understand the logic and flow in the client, but also for other to read and finally to maintain. It will only be in one place you need to change your code if the working flow or logic changes.

So now lets discuss the example. It is a internal frame solution, that only got one internal frame a dossier window. The dossier window contains document and present these structure in a tree. The detail of each tree node is shown in the same internal frame but in a detail panel. Here is a snapshot of the example.

Lets start with Main class.
1. It creates and saves all Views and Controllers in HashMap that the base class holds, so that all Views and Controller will be accessible through the entire client.
2. Lay out the JFrame with a default view.

We have two form views that have simply to to important methods that populates the view – getValues and setValues.

Now for the Tree View. This View is more complex but only because Swing is so verbose. I will leave the detail of how to implement a modifiable tree you can download the source at the end of the blog or google. I will in upcoming blog present a better ways to decorate the existing swing components, to take a POJO Model and populate from that. And to hold that POJO Model, so you can later ask the swing component for a POJO Model instead of making tiring calling of get and set from the model to the swing component and vice versa. But showing you simplifying handling of swing components is out of the scoop of this blog. The import thing is to show you how to seperate the concern of the Views and Controllers and the interaction between them.

As you can see in the code above the the tree View does not do anything in theirs action, just merely call the correct Controller method.

And now the Controller where we wire everything together.

I hope by just reading the code in the Controller you will get the feeling what will happen. But the best part. Everything is type safe! You can click on the method and directly go the code!

Download the source.

How to implement MVC (Model View Controller) Pattern in Swing

2012-01-17T00:51:00.004+01:00

The MVC pattern is the most common pattern when it comes to web framework, but when building a rich client with swing or by using a rich client framework such as, Eclipse Rich Client Platform, Eclipse RCP , or Spring Rich Client Project, Spring RCP or trying to develop a similar platform yourself, thing tends to fast get very complicated. Why is that? Well, first Swing is very low tech. To do even the most simple thing requires quite a lot of lines of code. Another reason is that a lot of people have not taken their time to fully understand the MVC pattern. And maybe last there are a lot of misunderstanding what a view is in the MVC pattern and the Swing model. The Swing model is entire a presentation necessity and therefore only belong to the view.

So hopefully what I will achieve in this blog is to explain the MVC pattern and how to implement it with Swing. What I will not do in this blog is to explain how to use certain Swing components, their are quite a few tutorials out there, e.g. Oracle own Swing Tutorial, http://docs.oracle.com/javase/tutorial/uiswing/.

Last start with explaining the MVC pattern fundamental. Maybe the easiest way to explain MVC is to look at how things work in the web world.

What happens:

The View builds the graphical interface and reacts to user interaction, by redirecting the request to the Controller.
The Controller respond to the request, do logic and sends response to a view.
The View takes these parameters and presents them in a view to the user.

And as you already might have guessed the above request and response parameters is the Model in the MVC pattern.

Before continue I would like to stress a few things extra hard:

All graphical components are created and layed out in the view. Nowhere else!
The Controller is neutral to whatever graphical user interface technique used! A simple control question is. Think that you must change graphical technique, from example Swing to SVT. Will you controller classes be affected? This question might feel quite theoretical but is a good eye opener if you have successfully separated the view concern from the controller concern.
The Model should also be plain old Java object, POJO, and not infected with presentation specific codes. And again check that by asking yourself if you were forced to change presentation technique. How would that affect your model classes?

And a final reminder about the model in the MVC pattern and the model in Swing. The Swing model should not be confused with the model in the MVC pattern. The Swing model is entirely part of the choosen presentation technique, i.e. Swing and belongs only in the view and should not be mixed with the model in the MVC pattern.

The last thing before diving into concrete code is the concern of Object Instances Lifecycle. Now you might start to wonder what that has to do with MVC. And the question is none, but the problem is still real and I think one must adress this with some thinking and strategy, because it is so vital to the application and programmers daily life. And not to mention testability. Which is something I will not go into any deeper in this blog, but I can recommned the FEST test framework. Anyhow which Swing test framework you choose you must before have a clear lifecycle handle of object in your rich client. Otherwise you will end up with untestable code.

So lest start with the View. What does a view do?

Layout the graphical components.
Responds to user interaction (and sends the request to the Controller).
Updates the view (requested from the Controller).

Lets starts with the layout.

Try not to bother about the static component methods, such as frame, etc. they are all methods in a ComponentFactory that do all the Swing plumbing construction. I will later show them in the Appendix.

But our application will certaintly contains several views, so lets we refactor out the main method in a class thats holds the JFrame instance. What we also will do in our frame class is to solve the problem of object lifecycle and dependencies to those. We will create a map that hold all the views and another that holds the controllers. And finally we will inject the instance of the main frame to all views and controllers. In this way, we will have only one instance of all the views and controllers, but also they will be accessable everywhere.

Now lets get back to the View and add code for the user interaction request.

As you can see, it is easy to get instance references to the controller class, but the controller is also used in a type safe way. This approach have several advances compared with external configuration files where you wire views and controllers together through weak string references. What will happen if decide to refactor and change a controller method name?

The view can in the same manner be accessed in the same type safe way. To need for external configuration files, such as XML files.

So this is the basic of MVC. Now look if this holds for more complex GUI. Lets say we want to make a desktop application. Well the layout stays the same, but we need to put theirs panel in internal frame. We could do that in the view, but what happens if requirement changes and these views wants to put in a tabbed panel instead. No lets leave the views intact and instead lets created a decorating view that takes a view of panel as argument.

Then we need to modify our main frame class.

Conclusion
MVC greatly reducing the coupling between seperated classes, but doing right is not always easy.

The complete source code can be downloaded here.

How to Install Swedish BankID on Ubuntu 11.10 64-bits

2011-11-22T22:28:00.003+01:00

First download the Swedish BankID program from https://install.bankid.com/.

Unzip the file.

Install BankID

The last part is only for 64-bit OS and that is to simulate your 32-bit Firefox pluging to run on your 64-bit OS. To do that you need the ia32-libs and nspluginwrapper packages. On a clean installed computer they are not installed.

To install them

Then install the BankID plugin in Firefox.

Now restart Firefox and test your plugin via https://install.bankid.com/

To read more in depth of the installation, see http://ubuntu-se.org/wiki/NexusPersonal.

Can Programmers Learn Something from Industrial Design?

2011-11-21T23:20:00.000+01:00

Another interest of mine is design and art. Which I will not write more about on this technical blog, but I recently got aquinted with the designer Dieter Rams (http://en.wikipedia.org/wiki/Dieter_Rams) who is interesting in many ways, but one thing that I think is of interest to share on this blog is his famous:

Ten Principles for Good Desing

1. Good design is innovative.

2. Good design makes a product useful.

3. Good design is aesthetic.

4. Good desing makes a product understandable.

5. Good design is unobtrusive.

6. Good design is honest.

7. Good design is long-lasting.

8. Good desing is thorough, down to the last detail.

9. Good design is environmentally-friendly.

10. Good design is as little design as possible.

Where my favourite is the last ”Good design is as little design as possible.”. Like James Bond would have said it ”Less is more.” Or maybe as a programmers would have put it ”KISS”.

You can read more of these principles here http://www.vitsoe.com/en/gb/about/dieterrams/gooddesign.

Is Oracle Making any Progress with Pushing Java Forword?

2011-11-21T22:55:00.000+01:00

Well in one sense, Oracle have managed to release a new Java version 7, but there are still some differences to solve to make the work go faster and smother.

Read more about the Java 7 ballot
http://jcp.org/en/jsr/results?id=5111

and for the Java 8 ballot release.
http://jcp.org/en/jsr/results?id=5112

One can clearly see that the fighting of lawyers are still going on for the license of Java. I hope they solve it and comes to an agrement so that the evolving of Java progresses faster, than it has since Java 5.

For history of previous Java releases, please read
http://magnus-k-karlsson.blogspot.com/2010/10/jaoo-day-4-java-future-at-oracle.html

How to Disable the Overlay Scrollbar in Ubuntu 11.01 and 11.10

2011-11-21T22:34:00.000+01:00

How to Disable the Overlay Scrollbar in Ubuntu 11.01 and 11.10

I like the new look of Unity, but there is one thing that keeps bugging me and that is the new Overlay Scrollbar. To remove it, do the following from the Terminal.

First you need to become root

Then export the following setting:

Last reboot and voilà the classical scrollbar is back.

Java Bug hangs the JVM

2011-02-28T04:36:00.004+01:00

I'm not sure about publishing bugs, but I guess it's already out there and there is also a patch available. The problem is in java.lang.Double and the handling of maximum doouble value, i.e. 2.2250738585072012e-308. The following code will send the older JVM to an infinitive loop.

Ok, but is this really a problem? Yes, it is for Java server connected to Internet. Let's imagine a Bank Server written in Java and exposed/available from the Internet. And you can be quite certain there will some fields taking double as input. These html fields are all Strings, but when processing at the server they are parsed to Double. And this is a typical exploit scenario a hacker can use for hanging the server/DoS attack.

The solution is either patching your current JVM version or upgrading to the latest JVM, i.e. Java 6 Update 24.

http://blogs.oracle.com/security/2011/02/security_alert_for_cve-2010-44.html

This bug is foremost for server application, since desktop application can always be restarted, but if you want to upgrade your desktop java version, please go to http://java.com/.

Best Practice Aspect-Oriented Programming with JBoss AOP

2011-02-23T09:59:00.048+01:00

In my recent project I have been working with JBoss AOP. There have been some pitfalls, I have fallen into and in this blog I will share those you.

First of all. Do not choose aspect-oriented programming to solve everyday Java problems. Example of good cases are:

Logging
Caching
Security
Error Handling

But why does AOP does not suites to solve common Java problem? Lets look at an example with Spring and AspectJ.

The Logic class:
The Aspect class:Boilerplate XML configuration files

And now call it
The problem with the code above, is that in FooPojo there is no hint at all, that other code will be called. This can be very confusing for a junior programmer and also to a much more skilled programmer that is not familiar with AOP.So how to make AOP more clearer and more understandable?The answer is to look at other framework and how they have solved it. Take for example Spring. They use AOP very heavily under the hood, to solve common tasks as marking classes as transactional (@Transactional). And in J2EE, Oracle uses also Annotation, e.g. in JAX-WS they have the method Annotation @WebMethod, to signal that a method is a Web Service method.So lets copy that pattern, to write your own Annotation, as marker in the code that you want to apply apsect-oriented programming to.Our own Annotation, to trigger Aspect:
Our Aspect. Here we use interface implementation. This solution works on JBoss 4.3.0 - 5.1.0:

The JBoss AOP configuration file, META-INF/jboss-aop.xml

Now lets create a Test class, that we annotate with our own Annotation:

And a Unit Test to verify it is working.

And here is the maven pom.xml

To make the example complete, we also need to supply a log4j configuration file.

To run/debug this inside Eclipse we need to copy the argLine from the maven pom file to the unit test file configuration.

For more about JBoss AOP Maven plugin , see http://community.jboss.org/wiki/JBossAOPMavenPlugin.

The Default Timeout Value for Standard Java Socket is Infinitive!

2010-10-27T09:43:00.001+02:00

In my last week I have been doing some stability testing using both the Java standard java.net.Socket and javax.net.ssl.Socket. Which are both are part of the J2SE standard library. What I found out to my big surprise, was the standard value for socket timeout (getSOTimeout()) is infinitive!

What are the consequences of this? Well, except that all blocking socket operation will hang forever. But maybe the biggest problem is, it opens up for Denial of Service (DoS) problems.

Example DoS: A server is overloaded and services it's request slower and slower. And now, if new additional clients connected, even more resources are consumed. What will happen with this system in the end is it will ran out of memory or IO. This is not wanted!

What is wanted is a fail-fast strategy, i.e. client that do not get response in a certain time will close it Socket and report back to interactive user or machine.

Ubuntu 10.04 Change Default Size of Terminal

2010-10-24T22:46:00.000+02:00

One of the probably first thing you want to change when starting using Ubuntu is to change the default size of the Terminal window. In earlier version of Ubuntu that could be accomplished via the Edit -> Profile Preference menu from the Terminal, but with Ubuntu 10.04 that is no longer possible. Instead do the following:

Go to System -> Preferences -> Preferred Applications -> System (tab)

Change Terminal Emulator to "Custom".
Command: gnome-terminal --geometry=237x24
Execution flag: -x

JAOO Day 4 – Not Only SQL, NOSQL

2010-10-08T00:13:00.000+02:00

Today I listened to Emil Eifrem CTO at Neo Technology. What I liked most of his talk was the categorization of the today existing NOSQL solution:

Key-Value Database
An Amazons project that uses global key-value mapping to for DB.

Dynamo: Amazon's Highly Available Key-value Store (2007) (http://s3.amazonaws.com/AllThingsDistributed/sosp/amazon-dynamo-sosp2007.pdf).

Other Example:

Project Voldemort. http://project-voldemort.com/.

Column Database
A Google project that uses a big table, with column families.

BigTable: A Distributed Storage System for Structured
Data (2006) (http://labs.google.com/papers/bigtable.html)

Other Example:

Apache HBase. http://hbase.apache.org/
Apache Cassandra. http://cassandra.apache.org/

Document Database
Data is organized as document and a document is a key-value pair.

Example:

Apache CouchDB. http://couchdb.apache.org/
MongoDB. http://www.mongodb.org/

Graph Database
Data is organized in a graph, which Nodes and Relationships have properties.

Example:

Neo4J. http://neo4j.org/

Example of company using NOSQL

Google: Bigtable
Amazon: Dynamo
Amazon: SimpleDB
Yahoo: HBase
Microsoft: Dynomite
Facebook: Cassandra
LinkedIn: Voldemort

JAOO Day 4 – Java Future at Oracle

2010-10-07T23:26:00.001+02:00

Today I was listening at Brian Goetz in his talk “Java Future at Oracle”. This talk was a warn welcome, since yesterday Java User Group, where it was not so much warmth about the evolving of the Java language, due to the problem in the Java Community Process (JCP). And how this has set footprint in the deliveries of new JDK version.

JDK 1.0 1996
JDK 1.1 1997
JDK 1.2 1998
JDK 1.3 2000
JDK 1.4 2002
JDK 5.0 2004
JDK 6.0 2006
…
JDK 7.0 2011?
JDK 8.0 ???

So what about new feature, well he said that they going to push out JDK 7.0, but of the expense of cutting functionality, which means in short:

Some feature from Project Coin. http://openjdk.java.net/projects/coin/
Some feature from the Da Vinci Machine Project. http://openjdk.java.net/projects/mlvm/

And that's it.

But on the other hand he also said that JDK 8.0 will be planned to be released thereafter 1-2 years, which sounds promising. Which Project Lambda (http://openjdk.java.net/projects/lambda/) will among other stuff be included. Other stuff in the pipe is also the Project Jigsaw (http://openjdk.java.net/projects/jigsaw/).

But the most interesting stuff was the news that they plan to merge the HotSpot with the JRockit! Wow, what a killer that will be! But, an unanswered question is, if they will change the license model of the JDK. It is like Brian put it: Oracle is really an easy company to understand, it is about making money.

And what about the JCP? Well, he quickly mentioned the problem, and this a top priority for Oracle to solve. And I really do hope that they solve this and quickly.

JAOO Day 3. The Stagnation of the Java Language

2010-10-05T23:48:00.002+02:00

Today I visited one of Java User Group (JUG) at the JAOO conference – the “Next next step for the Java ecosystem.” There were three person in panel James Gosling, Kevlin Henney and Dave Thomas and they all three confirmed on the misfortune fact that the Java Community Process (JCP) is not working properly or as Rod Johnson (member of JCP board) put it in his session “Where Next for Enterprise Java”. Compare the number of Java Specification Request (JSR) produced this year with the number produced 2-3 years back.

And one can really ask when JDK 7 will be released and how much really will be included of the project Coin (minor language feature change), Jigsaw (effort to make Java more modular) and Lambda (bring closure to Java)?!?

And I guess this fact is the why there today are so many new language created for the JVM – the community is responding and will not wait.

But there is rescue to the help and as James put it, if you cannot wait use Scala.

James Gosling
http://nighthacks.com/jag

Kevlin Henney
http://blogs.stickyminds.com
http://programmer.97things.oreilly.com/
http://curbralan.com/

Dave Thomas
davethomas.net
eclipse.org
agilealliance.org

Rod Johnson
http://blog.springsource.com/author/rodj/

Getting Started with Scala - IDE support

2010-10-05T23:09:00.001+02:00

The key thing when start using a new library or as in this blog, start writing a completely new language, is to have an IDE that is working with and not against you.

I had the pleasure of talking with both Martin Odersky and Jonas Bonér at JAOO in Aarhus Denmark and they both recommended the IntelliJ Scala plugin, but Martin also added that he had started a company scalasolutions.com with one of the aim to write a better Scala plugin for Eclipse, and when that comes out, I would really recommend you to test it. Another question which IDE to choose is also of course which IDE you have previously worked with and acquainted with.

In this blog I will share my experience of using both the IntelliJ and Eclipse IDE, but also how to build your Scala code with Maven.

IntelliJ
Since I don't have a business license of IntelliJ I used the Community edition, you can find the comparison matrix between the free and commercial edition and also the download link from.
http://www.jetbrains.com/idea/features/editions_comparison_matrix.html

After installing IntelliJ, you install the Scala plugin with the Plugin Manager

File | Settings | Plugins

Select tab Available and search for Scala, then right click to install.

After restarting, you create a new Java Module and add Scala Library from local downloaded Scala distro.

Experience
Plus:

Normal code completion and code navigation works.
OBS when debugging, you have to append the name mangling '$1' to every variable to be able to Evaluate. This seems a bug in the Plugin, since the name mangling should be shielded from you and is strict Scala internal, to overcome Java restriction of operating overloading, etc.

Minus

The IntelliJ Scala plugin compiler is really slow, even for small amount of code. There are ways to get around this by using Scala background compiler server, but I have not got that up and running yet.

Eclipse
I used the Eclipse 3.5.2 (Galileo) and install the Eclipse Scala plugin (http://www.scala-ide.org/) with the Eclipse built in Software Installation.

Help | Install New Software... | http://download.scala-ide.org/update-current Add

After that you can create a new Scala Eclipse Project.

Experience
Plus

The Scala Plugin compiles code enormous time faster compared with the IntelliJ, but it also have drawbacks.
Code completion is not always working if program Scala in it most compact form, sometime it then helps to program a little more verbose, e.g. anonymous function "kalOk".exists(char => char.isUpperCase) instead of the more compact "kalOk".exists(_.isUpperCase)
OBS when debugging, you have to append the name mangling '$1' to every variable to be able to Evaluate. This seems a bug in the Plugin, since the name mangling should be shielded from you and is strict Scala internal, to overcome Java restriction of operating overloading, etc.

Minus

Code completion is not always working.

Conclusion
After testing both IDE, I must say that Eclipse wins, and mostly because of the slow compilation in IntelliJ. But I hope even if you choose to use another IDE, that this blog post helped you with choosing which IDE you will use.

Maven
After choosen IDE, you clearly also want to have build tool support and I will here discuss Maven, but I also knew that SBT (http://code.google.com/p/simple-build-tool/) is also a great alternative, but I will not cover that in this blog.

The simplest way is to use the scala archetype, but before please check the page http://docs.codehaus.org/display/MAVENUSER/Archetypes+List, to see that not a newer version has been released.

To check that everything worked install the new Maven project.

Now lets open the new pom and see what has been generated. The first thing you see is that Scala 2.7.0 is used, change that to 2.8.0 but also remove the Scala Spec Test in

scala-maven/src/test/scala/se/msc/example/MySpec.scala

Finally you can also remove the specs dependency. I will in coming post discuss Scala Unit Testing, but for now simply use JUnit 4, that you are probably familiar with.

Thats it happy coding!

Day 2 at JAOO. A Compact Day with James Gosling, Jim Webber and GIT

2010-10-05T00:56:00.000+02:00

Day 2 was a packed day with big stars as James Gosling and for you that don't know it, Gosling have quited Oracle, if you want to read more, google or read Gosling own blog http://nighthacks.com/roller/jag/.

But the day started with Cliff Click from Azul Systems (azulsystems.com) and talked about top ten performance problem they seen of hosted Java application in production. This was interesting and I will probably get back with a better blog about that. What also was interesting was suggested tools for detecting different kind of problem:

JVM

dtrace, hprof, introscope, jconsole, visual vm yourkit

dtrace, oprofile

Network

Ganglia, iostat, lsof, nagios and netstat

The next talk was from Google about Scalability, Availability and Stability, which in mine humble opinion, brought not so much new solution to the problems. It all cooked down to sharding, fanning out, replication vs. caching, eventual consistency and asynchronous calling.

After lunch did Jim Webber talked. Jim Webber is mainly the guy behing REST and if you are intrested about that you should definitely read his book. REST in Practise.
http://www.amazon.com/REST-Practice-Hypermedia-Systems-Architecture/dp/0596805829/ref=sr_1_1?s=books&ie=UTF8&qid=1286232319&sr=1-1

At the end of evening I had the pleasure of talking to both Martin Odersky and Jonas Bonér about the new started company Scala Solution (http://www.scalasolutions.com/) IDE plugns, faster compile time, who is owning the code, founding and Scala akka (http://akkasource.org/), but I will get back more about that later.

Day 1 at JAOO Object-Orienteed meets functional: An Overview of Scala

2010-10-03T17:43:00.003+02:00

The first Training at JAOO 2010 was held by Martin Odersky in Scala. Scala is truly an interesting new programming language, it runs on top of the JVM, but brings so much new programming technique that is not possible with the existing Java language.

It was a truly refreshing talk, but also a sadly realization that the evolution of the Java language has really slowed down since the release of Java 5. The difference between Java 6 and Java 5 is mostly a faster JVM, that is not bad, but on the functional side of new language technique is quite depressing to see such a short list of new feature. And it is not getting better. A couple of days ago a checked out the Oracle web page of new programmatic feature in Java 7 one can see the list is short.
http://www.oracle.com/technetwork/java/7-138633.html

And what is happening the other main stream programming corner at Microsoft? Well they have not been lazy. On could right fairly argue that C# has been become a more advance language than Java. So with this in mind, I'm really looking forward to participate the Training. So what did Martin talk about. Well, the Scala language is really huge, so the talk for 4 hours, did not covered all parts, but one thing is sure. Looking at Scala is almost like learning a new language. For you out there, that have not started looking at Scala I only got one question for you:

Do you want to program Java 6 or 10? See the complete video of Martin Odersky. http://www.scala-lang.org/node/1305

"If I were to pick a language to use today other than Java, it would be Scala"
by James Gosling, creator of Java
http://www.adam-bien.com/roller/abien/entry/java_net_javaone_which_programming

"I can honestly say if someone had shown me the Programming in Scala book by by Martin Odersky, Lex Spoon & Bill Venners back in 2003 I’d probably have never created Groovy."
by James Strachan, creator of Groovy
http://macstrac.blogspot.com/2009/04/scala-as-long-term-replacement-for.html

"Scala, it must be stated, is the current heir apparent to the Java throne. No other language on the JVM seems as capable of being a "replacement for Java" as Scala, and the momentum behind Scala is now unquestionable. While Scala is not a dynamic language, it has many of the characteristics of popular dynamic languages, through its rich and flexible type system, its sparse and clean syntax, and its marriage of functional and object paradigms."
Charles Nutter, creator of JRuby
http://blog.headius.com/2009/04/future-part-one.html

Opening New Window in Ubuntu 10.04 Does Not Get Focused

2010-08-05T00:05:00.000+02:00

I had a really annoying problem after installing Ubuntu 10.04 which I found a solution to today. The problem was whenever I was opening a new window that new opened window was not focused. Quite annoying! The solution is following:

System → Preferences → CompizConfig Settings Manager
Select General in the right hand window.
Select General Options.
Select the Focus & Raise Behaviour tab.
Change Focus Prevention Level to Off.

Your First Cup of Coffee

2010-07-05T19:24:00.003+02:00

A friend of mine asked me to provide a simple getting started guide for a first time Java programmer and it so happened it were other people that also wanted the same thing, so all of you out there here it comes, a simple learning by example guide in Java.

The example is a simple Web application that do simple Create, Retrieve, Update and Delete (CRUD) operation against a MySQL database.

Before starting writing you need to install the following on your system.

Java 1.6 SE (http://java.sun.com/javase/downloads/index.jsp)
MySQL Server and Query Browser (http://dev.mysql.com/downloads/)
Maven2 (http://maven.apache.org/download.html)
Eclipse EE 3.5.2 (http://eclipse.org/downloads/)

Installing programs on Windows is a pain and I will leave that as an exercise and instead show you how that this is done on a Linux platform, Ubuntu (ubuntu.com).

That's it! That took 3 minutes on a modest Internet connection. Are you still stuck on downloading the files on your Windows machine? And thereafter looking forward to reboot you system after each installation?

The Eclipse Ubuntu installation bundle is sadly quite old and therefore it is better to download the zip file manually and extracted it anywhere of you liking and run eclipse.exe (eclipse) in the eclipse folder.

Now lets create your database. Start the MySQL Query Browser and right click in the Schemata dockable window and then select Create Schema.... Enter simpledb.
Now double click on the newly created schema and then right click again to create a new table.

From here you can take several paths, either create a new project with maven archetype 'simple-webapp' (http://www.sonatype.com/books/mvnex-book/reference/web-sect-creating-project.html) or you can install the m2eclipse plugin (http://m2eclipse.sonatype.org/installing-m2eclipse.html) and create your project from Eclipse. Here, I will hopefully, choose the easiest way and do it manually, since we only will be needing two source files, where one will be empty – web.xml and index.jsp.

Now create you Maven Project Object Model file pom.xml in first-coffee/pom.xml

Now create your first-coffee/src/main/webapp/WEB-INF/web.xml

And finally your dynamic web page (first-coffee/src/main/webapp/index.jsp), where all your work be done.

To test your application, simply start the Maven built in web server, from your first-coffee directory.

Now open your web browser and enter the address http://localhost:8080/first-coffee/.

If you want to continue to further evolve this simple example, you can leave the jetty server running and simply refresh you web server, after saving your changes.

Getting Started with Apache Camel and Prepare for Apache ServiceMix Deployment

2010-07-01T03:29:00.000+02:00

Apache Camel is dream framework for any developers that is confronting with any type of integration task. What makes Apache Camel so great is:

Testability. It is design from the beginning to be a framework that going to support Test Driven Development. With this follows a fast development cycle, since all code can be debugged and executed from a simple JUnit test case.
Solves the two foremost problem that an integrator faces:
Seamless protocol crossing, i.e. no coding for fetching data from e.g. HTTP and forwarding it to JMS.
Default implementation of Enterprise Integration Pattern (http://www.eaipatterns.com/toc.html) that is easy to extend and configure. If you are not familiar with EIP, I recommend you to take the time and read the EIP homepage or if you do not want to miss a thing read the complete book written by Hophe and Woolf (http://www.amazon.com/Enterprise-Integration-Patterns-Designing-Deploying/dp/0321200683).

The next best thing is that Apache Camel is a POJO based solution, which means that it can be deployed and ran in any deployment environment:

Standalone Java Application
Web Container
J2EE Container

When talking of deployment and integration the most common question is. What about ESB? And this is also when Apache Camel shines. Apache Camel is fully supported by Apache Camel parent project Apache ServiceMix, that supports the industry standard Java Business Integration standard. The JBI specification has been criticized about being a slow way of developing integration software and in many aspect that is true, but with Apache Camel as core developing framework that is no longer true.

The reason to select an ESB platform to deploy your integration software is:

Management. The ESB platform is specially design to manage integration programs.
Redundancy and Scalability. A good ESB platform is specifically design to handle these issues when the load and uptime requirements increases.

But one thing, that in my opinion, the Apache Camel homepage lack is good starting example of showing the above strength. So lets get started with NOT writing a production code example, but instead lets write a JUnit test case that you can debug, then you can continue of writing your production code.

In the below example I will also take into account that one day, you might want or NOT take the next step and move your Apache Camel code into a full blown ESB environment.

Lets first look at your Maven pom.xml.

To read more about all configuration options for the above endpoints, see http://camel.apache.org/components.html

An Apache Camel route can also be configured in a XML file, which is the natural choice since you want things to configurable and not static defined in a Java class, but more about in my next blog.

Problem Running Eclipse on Ubuntu 10.04 (Lucid Lynx)

2010-06-28T08:42:00.000+02:00

I have been using Ubuntu for some time and it is really a great OS, but it is amazing why it is always Eclipse that brings the most headache when upgrading Ubuntu. For a couple a days ago I upgraded to Ubuntu 10.04, and everything works smoothly until I started Eclipse 3.5 SR1, with bug fixes I have previously described.

http://magnus-k-karlsson.blogspot.com/2009/11/problem-running-eclipse-in-ubuntu-910.html

This time the solution was to upgrade to Eclipse 3.5 SR 2 (Galileo), without the above bug fix. But thereafter m2eclipse gave me some problem, but now it seams to work after reinstalling m2eclipse and following the guideline in

http://m2eclipse.sonatype.org/installing-m2eclipse.html

“Note about 0.9.8 Workspace Incompatibility: If you are using m2eclipse 0.10.0 with a workspace that contains projects created under m2eclipse 0.9.8, you must remove the workspaceState.ser file. The workspaceState.ser file is located within the workspace directory in $workspacedir/.metadata/.plugins/org.maven.ide.eclipse/workspaceState.ser. If you remove this file, m2eclipse 0.10.0 will regenerate it as needed.”

Getting Starting with Google Web Toolkit, GWT, Development

2010-06-25T03:29:00.002+02:00

To get started first install appropriate plug-in for your IDE, in this article we will use Eclipse, but there are other great plug-in for other IDE as well.

Eclipse GWT plugin
http://code.google.com/eclipse/docs/download.html

One of the biggest difference between GWT 1.* and 2.* is the ability to debug and run your GWT application without the need to render/compile it. Now you can directly run/debug your GWT Java code without the time consuming compile step. But to do this you first need to install a plug-in to your web browser.

GWT Development Mode plugin for Firefox, IE and Safari
http://groups.google.com/group/google-web-toolkit/msg/51c5a09630ac61dc

After restarting Eclipse and your Web browser you are now ready to start developing. Begin with creating a new project and select Google → Web Application Project.

Enter project details. In this article we will not create a Google App Engine Application, which is a platform for writing cloud application for the Google cloud platform. To read more about Google App Engine, visit http://code.google.com/appengine/.

After finishing creating your project. Lets fire it up and start debug the complete GWT project. The GWT team has already configured a default debug goal. So simple press the debug icon in the Eclipse toolbar.

Now is a URL presented in the Eclipse Console output View. Right click on that URL and select Copy. Paste the URL in your web browser.

Now lets set a breakpoint in your application and the enter a name in your browser and click submit. And now you are debugging your first GWT application.

Administrating JBoss MBean From the Command Line Using twiddle

2010-04-18T23:13:00.000+02:00

In production environment you usually monitor and administrate the JBoss Application Server through ssh and command line and this is adequate when starting, stopping and reading logs, but when you want to inspect, see status and change MBean values, the command line alternative is quite limited and since the MBean architecture is central in JBoss one really wants to use the JMX-console. The JMX-console is not the most user friendly tool, but has improved with JBoss 5 and the Web Console.

But there is an alternative if you want (or must) stick with the command line alternative – twiddle. The twiddle tool is not new and has been around since JBoss 4.3. And here follows a short walk through by examples.

To print out help information use:

Here you see the most imported commands: info, get, invoke and setattrs.

To get attribute and operation info:

To get attribute value:

To invoke an operation:

How To Remove Automatically Started Programs in Ubuntu 9.10 Karmic Koala

2010-03-24T00:51:00.000+01:00

I while ago I blogged about how to setup Apache mod_proxy as a reverse proxy and I installed Tomcat and Apache Web Server with Synaptic Package Manager. The Synaptic Package Manager worked flawless as usual, but it left me with one problem. The Tomcat Server did start automatically every time I booted Ubuntu, this is typically not wanted on a developer laptop, since you probably also are using some other Java Container that is default using port 8080.

Before we dive into how to remove the auto start in Ubuntu, lets first see how things are configured to be automatically started. As you know the start scripts are located in the

And to make programs autostart then there are soft links in the

There are several /etc/rc catalogs, and here follows the extract from one of mine catalog.

So one obvious option would be to directly delete all the soft links in these catalogs, but this is error prone and not recommended, but also it exists a tool to do exactly this – update-rc.d.

Now is Tomcat no longer automatically started when booting Ubuntu.

Using JAX-WS in a Web Archive, as a Servlet, Running on JBoss 5.1

2010-02-28T08:36:00.000+01:00

In my previous blog I showed how to get started with JAX-WS in a EJB archieve, in this blog I will show you how to do the same thing, but in a web archive instead, as a Servlet. If you think about it, the two different approaches ends with the same result – a Servlet that answer HTTP request with SOAP content.

Now lets create a simple web archieve with Maven archetype plugin.

Now lets add EJB dependency and JBoss Maven plugin that will do our deployment work.

Then we continue with our Web Service class.

Not that we don't need to define a interface. Then we write our web.xml, that points to our concrete Web Service class.

Finally we need to add the JBoss specific web deployment descriptor. Note the location of the file – src/main/webapp/META-INF/jboss-web.xml, i.e. not in the WEB-INF directory, beside the web.xml.

Now we are ready to build and deploy our archieve

Then we start our JBoss server and opens a web browser pointing to http://localhost:8080/ws-web/personServiceBean?wsdl and checks that the web service is working. Instead of building a web service client by hand, we use the soapUI tool.

Now soapUI has created us a testcase that we can double click and click the green play button on.

How To See Expiration Date and other Information of a p12 File (PKCS12).

2010-02-25T20:00:00.000+01:00

Sooner or later your client or server certificate will expire and it will be nice to update that before it really happens, but to do that you need to know how to get that information. In this blog I will show you how to do that in a Linux environment with openssl, that is a typical scenario when the certificate is located on a remote Linux server that you access with ssh.

First thing to do is to convert the p12 file (PKCS12 format) to X509 format, to do so we use the openssl command.

When prompted enter the password. Now is the content printed out, find out which CN (Common Name) that is for the server, typically it is the dns name of the server. After located the certificate then copy everything between the below start and end tag,

Past the copied content into a file with prefix .crt. If you were on a Windows system you could now simple double click the crt-file and the information of the certification would be display, but here we will continue using openssl. To use openssl, use the below command using the file name of the file you pasted the certificate into.

Now is the expiration date printed among other information.

Configure Apache Web Server as Reverse Proxy in front of a Tomcat or J2EE Container

2010-02-21T23:41:00.000+01:00

One production like scenario when using SSL or load balancing is to use a Apache Web Server in front of a Java Web Container or J2EE Container. There are two ways to make the Apache Web Server and the behind Java container – mod_proxy or mod_jk. In this blog I will show you how to use the mod_proxy alternative, acting as a reverse proxy. I will also use Ubuntu to show you how easy there is to install software on Ubuntu with Synaptic Package Manager.

The first thing to do is to install Apache Web Server and the Tomcat Container.

After installing the above software you can use the apache2ctl command to view the active sites configuration

or you can also list the files in /etc/apache2/sites-enabled

Before continue you can also check that everything is working by open a web browser and open http://localhost/ (Apache Web Server) and http://localhost:8080/ (Tomcat)

Now we go ahead and creating a new virtual host that is going to act as reverse proxy.

After creating the new site we need to link it from sites-enabled, either use ln -s or you can use the apache tool – a2ensite.

With the configuration in place, you need to separate the virtual host in customapp and default. For a locale environment you can separate them by using different IP – 127.0.0.1 and your computer IP.

The last thing before restarting the Apache Web Server is to install proxy and proxy_http modules you can do that with the Apache tool a2enmod

And finally you need to restart the Apache Web Server.

Getting Started with JBoss Web Serivce using JAX-WS on JBoss 5.1 using Maven, OpenEJB and eviware soapUI

2010-02-18T03:12:00.000+01:00

The easiest way to get started with writing Web Service is using Java API for XML Web Service, JAX-WS. The downside with this is that the creation of the WSDL file is automatic, and that is not the preferred way of writing cross platform independent web service. If that is your design goal, you should handwrite the WSDL, i.e. contract first. But if you know that the only clients are going to be Java client, than automatically generating the WSDL could be fine.

A good practice when writing all kind of code, is to make the code testable and also make it testable outside the container. To achieve that I will use OpenEJB, if have never heard or used OpenEJB and you are writing EJB 3.0 applications, it is definitely worth the time to check it out.

Lets start with writing a standard Stateless EJB.

src/main/resources/META-INF/ejb-jar.xml

src/main/resources/META-INF/jboss.xml

pom.xml

Now lets test our EJB with OpenEJB. The first thing we need to do, is to add the OpenEJB dependency to our pom.xml

Then we write our JUnit test case.

After verifying that our Stateless Session Bean is working, we now continue to deploy it to the JBoss container.

We start our JBoss container and checks that the EJB is successfully deployed.

Now lets add Web Service support to our EJB.

Now lets write our JUnit test case, to test our web service outside the JBoss container.

Before running the testcase we need to update our pom.xml with a concrete web service implementation.

After running the testcase from withing Eclipse, we can now be confident that we our is executing as expected. Now lets deploy our EJB to the JBoss container.

If you have stopped the JBoss, then restarted and verify that everything is looking healthy in the server log. Verify that the web service is working by firing up a web browser and go to http://localhost:8080/jbossws-example/HelloServiceBean?wsdl, to verify that you see the wsdl file.

Instead of writing a web service client, we are going to use a good test tool for testing web service – eviware soapUI. Start the soapUI and then select new project.

Viewing/Monitoring your Log4j Generated Log File with Chainsaw

2010-02-17T22:27:00.000+01:00

Chainsaw is a open source tool for viewing and/or monitoring Log4j generating system. But the documentation on the homepage lack some explanation how to get started. To begin with maybe the simplest scenario, to view a log4j generated log file. The first thing one might misunderstand is that you need to defines a new configuration file for Chainsaw, so just pointing to your log4j.xm configuration file is not enough. Lets start with a example.

And the configuration file for Chainsaw.

Before we open Chainsaw lets write a small test program, that generates some log post, so we have something to view.

Now lets open Chainsaw. When first starting Chainsaw you are prompted to define a Receiver. Here we select our configuration file.

After selecting our Chainsaw configuration file, Chainsaw opens our log file in a new tab.

You might have already noticed the different formatting of logFormat attribute, compared with the Log4j and it is a question to me why they have done that. You can read more about the format in the LogFilePatternReceiver Javadoc.

Sending Log Errors with Log4j and SMTPAppender

2010-02-14T01:12:00.000+01:00

Log4j comes with several Appenders and if you like to send mail notification if severe errors occur the you will be pleased to see, that Log4j comes with a SMTPAppender, but there are some pitfalls when using the SMTP appender:

The SMTP apppender does not out of the box support a different SMTP port.
Using secure connection, such as SSL or TLS.
The derived standardized method setThreshold is ignored, and replaced with TriggeringEventEvaluator class.

Configure SMTP appender to use a different port, than the default 25
If your mailserver is configured to answer on a different port than the default 25 for SMTP, you need to configure the underlying javax.mail.Session property "mail.smtp.port". But when looking at the API for SMTPAppender you see no set method for that. What to do? Writing you own extended log4j class? No, that is not neccessary. If you look at the source code of SMTPAppender, you see the following in the createSession():

These means that SMTPAppender is reading system properties, which means you can add the following argument when starting you application.

This is a not gracefefully way, and sometimes also not applicable, because you are not in charge of the deployment environment. And what happens when you have two different application hosted on the same server, that wants to use different ports?
There is also the oppurtunity to do it programmatically:

This has also drawbacks. For examaple if your application is a J2EE application or a web application your code is not the main start class. You can of course always write a boot strap class, but what happens when you have several bootstrap classes, then things starts to get more hard to overlook for a more junior programmer.

Another way if you have problems settings the System Property is to create a class that implements the interface org.apache.log4j.spi.TriggeringEventEvaluator and there set the system properties and then in your log4j properties or xml file override the default EvaluatorClass for SMTPAppender. This is a little hacky, but it will get the work done and it keeps your code clean from log4j configuration code that should in the first place be placed in the log4j configration file.

Also what is lacking is, if you are deploying to a container you might want to define your java.mail.Session properties in the container and then bind them to JNDI, then it should be nice if Log4j could read these property from JNDI, but that is not possible.

Using Secure Connection
The next problem comes when your mailserver uses secure connection as TLS or SSL, then you need to add the following javax.mail.Session properties:

Bellow follows the source code for the example.

Java Generics Example Strategy Pattern

2010-02-01T18:55:00.000+01:00

With Java Generics Java has continued its path to make it's language more strong typed, with comparison to all new dynamic language where they have thrown out strong typing. But Java Generics can also be hard to understand and one of the best example to show the main benefit with it is the strategy pattern. Lets start to look of a example.

If we were using Java JDK 1.4 we have to do down-casting in the concrete strategy classes, but with Generics that is not necessary.

The Strategy Context/Client

The Strategy itself

And the extended Data classes

And the extended Strategy

And our test class.

Maven Reporting with Cobertura, Dashboard, Change Report, FindBugs and PMD

2010-01-30T13:10:00.008+01:00

I have been using maven coberture plugin before but it has one unimplemented function, aggregate cobertura report from multiple module. This can be solved by sonar and dashboard maven plugin, but Sonar requires that is run on a server, i.e. that you have a continuous integration server, but in some cases you have not got there and still is building your application locally than you can use the maven Dashboard plugin.

The parent pom.xml

The jar module pom.xml

How to handle XML Schema Version?

2009-12-14T23:37:00.000+01:00

Use the Schema verison attribute.
Pros:

Simple

Cons:

No XML Schema enforcement when stepping version and version number is concealed for user.

Recommendation:

Do no use.

Change the Schema location and keep the namespace.
Pros:

Good för maintaining backward compability. No depending XML files needs to be altered, simply upgrade implementing jar.

Cons:

Cannot tell from the XML file which implementing jar version is used.

Recommendation:

Use this technique to handle minor version upgrade.

Example:
http://camel.apache.org/schema/spring/camel-spring-1.6.X.xsd, in version 1.6.0-1.6.3 is the same targetNamespace used.

Change the Schema location and the namespace.
Pros:

Forces the user to upgrade the client code, when stepping version. Hard versioning control, no chanse to make misstake.

Cons:

No seamless upgrade. Upgrade will cost.

Recommendation:

Use this when stepping major version.

For you using JAXB, is it a good reminder that the namspace versionnumber is direclty reflected in the package name. So when uppgrading and if the depending generated code has changed namespace, i.e. package name will the depending code not compile. This can be a advantage since it will directly be apparent where in your code you have the dependencies.

XML Schema Design Pattern - Handling Versioning and Reuse

2009-12-14T22:29:00.000+01:00

In my last project I have been working with service orientated integration and ESB, in such an architecture the domain model is represented with a canonical model of a XML schema. There several way you can design your schema which I will describe bellow, but what is more imported is the implication it has on:

Level of possibility to reuse your canonical model in different service.
Level of possibility to handle different version of same service.
Level of possibility to split your canonical data model into bit of pieces and process them in parallel.

Before laying out the different patterns I will explain different definition that I will use when evaluating the different patterns

Definition:
Root element – the first element a XML must contain. If a schema contains several root element it is possible to slice the XML document into several new XML document.

Global element – the elements that directly comes after the root element, possibly elements are 'element', 'complexType' and 'simpleType'.

Local element – nested element inside global element.

Russian Doll Example

Pros:

One root element, good for encapsulation.
All elements are local and encapsulated.

Cons:

No reuse of elements.
Easier to get started with.

Example Book-RussianDoll-v1.0.0.xsd

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
     targetNamespace="http://ns.msc.se/examples/book-russiandoll/v1_0_0"
     xmlns:russ="http://ns.msc.se/examples/book-russiandoll/v1_0_0" 
     elementFormDefault="qualified">
 
 <xs:element name="book">
  <xs:complexType>
   <xs:sequence>
    <xs:element name="Title" type="xs:string" />
    <xs:choice>
     <xs:element name="AuthorList" minOccurs="0" maxOccurs="unbounded">
      <xs:complexType>
       <xs:sequence>
        <xs:element name="Author">
         <xs:complexType>
          <xs:sequence>
           <xs:element name="givenName" type="xs:string" />
          </xs:sequence>
         </xs:complexType> 
        </xs:element>
       </xs:sequence>
      </xs:complexType>
     </xs:element>
    </xs:choice>
   </xs:sequence>
  </xs:complexType>
 </xs:element> 
 
</xs:schema>

Salami Slide
Pros

Many root elements, the XML file can be sliced into numerous ways.
All elements are global, which allows reuse in other Schemas.

Cons

Does not encapsulate and hide the schema.
Usage of namespaces are almost a most, which makes usage more complex.

Example Book-SalamiSlice-v1.0.0.xsd

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
     targetNamespace="http://ns.msc.se/examples/book-salamislice/v1_0_0"
     xmlns:salv1_0_0="http://ns.msc.se/examples/book-salamislice/v1_0_0" 
     elementFormDefault="qualified">

 <xs:element name="book">
  <xs:complexType>
   <xs:sequence>
    <xs:element ref="salv1_0_0:Title" />
    <xs:element ref="salv1_0_0:AuthorList" />
   </xs:sequence>
  </xs:complexType>
 </xs:element>

 <xs:element name="Title" type="xs:string" />

 <xs:element name="AuthorList">
  <xs:complexType>
   <xs:sequence>
    <xs:element ref="salv1_0_0:Author" minOccurs="0" maxOccurs="unbounded" />
   </xs:sequence>
  </xs:complexType>
 </xs:element>

 <xs:element name="Author">
  <xs:complexType>
   <xs:sequence>
    <xs:element ref="salv1_0_0:GivenName" />
    <xs:element ref="salv1_0_0:Surname" />
   </xs:sequence>
  </xs:complexType>
 </xs:element>
 
 <xs:element name="GivenName" type="xs:string" />
 
 <xs:element name="Surname" type="xs:string" />
 
</xs:schema>

When generating code via JAXB, wee can see that several classes are annotated with the @XmlRootElement. This says that we have several possible root element.

In the next example we show how to handle version and extending previous schema version.

Example Book-SalamiSlice-v1.0.1.xsd

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
     targetNamespace="http://ns.msc.se/examples/book-salamislice/v1_0_1"
     xmlns:salv1_0_0="http://ns.msc.se/examples/book-salamislice/v1_0_0"
     xmlns:salv1_0_1="http://ns.msc.se/examples/book-salamislice/v1_0_1" 
     elementFormDefault="qualified">
 
 <xs:import namespace="http://ns.msc.se/examples/book-salamislice/v1_0_0" schemaLocation="Book-SalamiSlice-v1.0.0.xsd" />

 <xs:element name="book">
  <xs:complexType>
   <xs:sequence>
    <xs:element ref="salv1_0_1:Title" />
    <xs:element ref="salv1_0_1:Category" />
    <xs:element ref="salv1_0_0:AuthorList" />
   </xs:sequence>
  </xs:complexType>
 </xs:element>
 
 <xs:element name="Title">
  <xs:simpleType>
   <xs:restriction base="xs:string">
    <xs:minLength value="3" />
   </xs:restriction>
  </xs:simpleType>
 </xs:element>
 
 <xs:element name="Category" type="xs:string" />
 
</xs:schema>

Venetian Blind

Pros:

Only one root element, good for encapsulation.
All element are global, which allows reuse in other Schemas.

Cons:

Usage of namespaces are almost a most, which makes usage more complex.

Example Book-VenetianBlind-v1.0.0.xsd

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
     targetNamespace="http://ns.msc.se/examples/book-venetianblind/v1_0_0"
     xmlns:ven="http://ns.msc.se/examples/book-venetianblind/v1_0_0" 
     elementFormDefault="qualified">

 <xs:element name="Book">
  <xs:complexType>
   <xs:sequence>
    <xs:element name="Title" type="ven:TitleType" />
    <xs:element name="AuthorList" type="ven:AuthorListType" />
   </xs:sequence>
  </xs:complexType>
 </xs:element>
 
 <xs:simpleType name="TitleType">
  <xs:restriction base="xs:string">
  </xs:restriction>
 </xs:simpleType>

 <xs:complexType name="AuthorListType">
  <xs:sequence>
   <xs:element name="Author" type="ven:AuthorType" minOccurs="0" maxOccurs="unbounded" />
  </xs:sequence>
 </xs:complexType>
 
 <xs:complexType name="AuthorType">
  <xs:sequence>
   <xs:element name="GivenName" type="ven:GivenNameType" />
   <xs:element name="Surname" type="ven:SurnameType" />
  </xs:sequence>
 </xs:complexType>
 
 <xs:simpleType name="GivenNameType">
  <xs:restriction base="xs:string">
  </xs:restriction>
 </xs:simpleType>

 <xs:simpleType name="SurnameType">
  <xs:restriction base="xs:string">
  </xs:restriction>
 </xs:simpleType>
 
</xs:schema>

Example Book-VenetianBlind-v1.0.1.xsd

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
     targetNamespace="http://ns.msc.se/examples/book-venetianblind/v1_0_1"
     xmlns:ven1_0_0="http://ns.msc.se/examples/book-venetianblind/v1_0_0"
     xmlns:ven1_0_1="http://ns.msc.se/examples/book-venetianblind/v1_0_1" 
     elementFormDefault="qualified">

 <xs:import namespace="http://ns.msc.se/examples/book-venetianblind/v1_0_0" schemaLocation="Book-VenetianBlind-v1.0.0.xsd" />

 <xs:element name="Book">
  <xs:complexType>
   <xs:sequence>
    <xs:element name="Title" type="ven1_0_1:TitleType" nillable="true" />
    <xs:element name="Category" type="ven1_0_1:CategoryType" nillable="true" />
    <xs:element name="AuthorList" type="ven1_0_0:AuthorListType" />
   </xs:sequence>
  </xs:complexType>
 </xs:element>
 
 <xs:simpleType name="TitleType">
  <xs:restriction base="xs:string">
  </xs:restriction>
 </xs:simpleType>

 <xs:simpleType name="CategoryType">
  <xs:restriction base="xs:string">
   <xs:enumeration value="SPORT" />
   <xs:enumeration value="COOKING" />
   <xs:enumeration value="PROGRAMMING" />
  </xs:restriction>
 </xs:simpleType>
 
</xs:schema>

Conclusion
When starting of thinking of Schema one come to the conclusion that schema design is much like tradition OO design, where one must always consider if a properties and method should be hidden or exposed to other classes. The same yields for Schemas and in the real world one would scarcely use just one design pattern, but rather combine them.

Problem Running Eclipse in Ubuntu 9.10 Karmic Koala

2009-11-02T20:31:00.000+01:00

After upgrading to Ubuntu 9.10, Eclipse started to behave strangely. Button seams to be non-responsive, so I googled for a solution and came up with this link.

http://www.norio.be/blog/2009/10/problems-eclipse-buttons-ubuntu-910

Writing to Syslog with Log4J and Testing It on Ubuntu 9.04 Jaunty

2009-11-01T00:14:00.001+01:00

The preferred way to log in Linux is to write to the Syslog. For you that comes from the Windows world, Syslog is the equivalent for the Windows NT Event Log. Before you can ran the example below you need to enable Syslog Facility LOCAL1 on Ubuntu. The Facility can be looked as a filter and if you are running multiple programs on the same server, you might want to consider to let each program write to different Facility LOCAL[0-7].

To enable Facility LOCAL1 on Ubuntu 9.04 you first need to edit /etc/syslog.conf

>sudo gedit /etc/syslog.conf &

and add the following line

local1.*   /var/log/local1.log

But we are not done yet, since Log4J org.apache.log4j.net.SyslogAppender is using the underlying writer class org.apache.log4j.helpers.SyslogWriter that is using the java.net.DatagramPacket which is writing to the syslog remotely, we need to enable remote access to Syslog. We do that by changing:

>sudo gedit /etc/default/syslogd &

And changing the following:

SYSLOGD="-r"

Now we are done and we need to restarts the system log daemon, to make our changes take affect:

>sudo /etc/init.d/sysklogd restart

Finally we add the following configuration to our log4j.properties.

# configure the root logger
log4j.rootLogger=INFO, STDOUT, DAILY, SYSLOG_LOCAL1

# configure Syslog facility LOCAL1 appender
log4j.appender.SYSLOG_LOCAL1=org.apache.log4j.net.SyslogAppender
log4j.appender.SYSLOG_LOCAL1.threshold=WARN
log4j.appender.SYSLOG_LOCAL1.syslogHost=localhost
log4j.appender.SYSLOG_LOCAL1.facility=LOCAL1
log4j.appender.SYSLOG_LOCAL1.facilityPrinting=false
log4j.appender.SYSLOG_LOCAL1.layout=org.apache.log4j.PatternLayout
log4j.appender.SYSLOG_LOCAL1.layout.conversionPattern=[%p] %c:%L - %m%n

Maven2 Reference Literature

2009-11-01T00:14:00.000+01:00

For some time the best book on Maven2 was “Better Builds with Maven” which can be downloaded from http://www.maestrodev.com/better-build-maven, but now there is finally a more updated book, “Maven: The Definitive Guide“. Which is available from

http://www.sonatype.com/books/maven-book/reference/public-book.html

The Promising Standardized JSR 303 Bean Validation and Example of Usage

2009-11-01T00:13:00.000+01:00

For too long have the Java world lived without a standardized bean validation specification and soon will the final approval hopefully be approved (2 Nov 2009). What does this imply?

Better Domain Driven Design, by putting the shallow domain validation in the POJO where it belongs.
Hopefully we can finally get rid of Value Objects Pattern which is a dark heritage from the EJB 2.1 age and instead use domain POJO beans through out our architecture. There is of course exception to this rule, e.g. in service layer where the exposed model is totally different than the domain model or in a UI layer with heavy usage of line charts, there an OO model does not fit into a point orientation representation.

What is still to be proven is how the specification will fit into other framework, such as JPA, Apache Wicket or Spring Remoting. But one can rest ashore if one is using the standard validation model, the odds increase dramatically. And presumably will big framework such as Spring Framework and Apache Wicket adjust there framework to the standard.

Here follows a simple example of the usage of Bean Validation.

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

<modelVersion>4.0.0</modelVersion>
<groupId>se.msc.examples</groupId>
<artifactId>validation-domain</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>Validation :: Domain</name>
<url>http://www.msc.se/examples/validation</url>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<repositories>
<repository>
<id>repository.jboss.org</id>
<url>http://repository.jboss.org/maven2</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
</repositories>

<dependencies>
<!-- common logging library -->
<!-- version is depended on hibernate-annotations v3.4.0.GA -->
<!--
http://repo1.maven.org/maven2/org/hibernate/hibernate-annotations/3.4.0.GA/hibernate-annotations-3.4.0.GA.pom
-->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.4.2</version>
</dependency>
<!-- sun bean validation api -->
<dependency>
<groupId>javax.validation</groupId>
<artifactId>validation-api</artifactId>
<version>1.0.0.GA</version>
</dependency>
<!-- hibernate bean validation impl -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>4.0.0.GA</version>
</dependency>
<!-- test support -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.7</version>
<scope>test</scope>
</dependency>
</dependencies>

<build>
<defaultGoal>install</defaultGoal>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.6</source>
<target>1.6</target>
</configuration>
</plugin>
</plugins>
</build>

</project>

package se.msc.examples.validation.domain;

import java.io.Serializable;

import javax.validation.constraints.NotNull;
import javax.validation.constraints.Pattern;
import javax.validation.constraints.Size;

public class Person implements Serializable {
private static final long serialVersionUID = 1L;
private Long personId;
private String firstName;
@NotNull
@Size(min=1)
private String surname;
@NotNull
@Pattern(regexp=".+@.+\\.[a-z]+")
private String mail;

public Long getPersonId() {
return personId;
}

protected void setPersonId(Long personId) {
this.personId = personId;
}

public String getFirstName() {
return firstName;
}

public void setFirstName(String firstName) {
this.firstName = firstName;
}

public String getSurname() {
return surname;
}

public void setSurname(String surname) {
this.surname = surname;
}

public String getMail() {
return mail;
}

public void setMail(String mail) {
this.mail = mail;
}

}

package se.msc.examples.validation.domain;

import static org.junit.Assert.*;

import java.util.Set;

import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class PersonTest {
private Validator validator;
private Person person;

@BeforeClass
public static void oneTimeSetUp() throws Exception {  
}

@AfterClass
public static void oneTimeTearDown() throws Exception {
}

@Before
public void setUp() throws Exception {
validator = Validation.buildDefaultValidatorFactory().getValidator();
person = new Person();
person.setFirstName("Magnus K");
person.setSurname("Karlsson");
person.setMail("magnus.k.karlsson@domain.se");  
}

@After
public void tearDown() throws Exception {
}

private  void debugPrint(Set> violations) {
for (ConstraintViolation violation : violations) {
String propertyPath = violation.getPropertyPath().toString();
String message = violation.getMessage();
System.out.println("invalid value for: '" + propertyPath + "': " + message);
}  
}

@Test
public void testValidate_OK() throws Exception {
Set> violations = validator.validate(person);
assertTrue(violations.size() == 0);
debugPrint(violations);
}

@Test
public void testValidate_FAIL_MAIL() throws Exception {
person.setMail("magnus.k.karlsson@domain");
Set> violations = validator.validate(person);
assertTrue(violations.size() == 1);
debugPrint(violations);
}

@Test
public void testValidate_FAIL_SURNAME() throws Exception {
person.setSurname(null);
Set> violations1 = validator.validate(person);
assertTrue(violations1.size() == 1);
debugPrint(violations1);

person.setSurname("");
Set> violations2 = validator.validate(person);
assertTrue(violations2.size() == 1);
debugPrint(violations2);  
}

}

The resource bundle message ValidationMessages.properties

javax.validation.constraints.Null.message=must be null
javax.validation.constraints.NotNull.message=must not be null
javax.validation.constraints.AssertTrue.message=must be true
javax.validation.constraints.AssertFalse.message=must be false
javax.validation.constraints.Min.message=must be greater than or equal to {value}
javax.validation.constraints.Max.message=must be less than or equal to {value}
javax.validation.constraints.Size.message=size must be between {min} and {max}
javax.validation.constraints.Digits.message=numeric value out of bounds (<{integer} digits>.<{fraction} digits> expected)
javax.validation.constraints.Past.message=must be a past date
javax.validation.constraints.Future.message=must be a future date
javax.validation.constraints.Pattern.message=must match the following regular expression: {regexp}

References:
JSR 303: Bean Validation
http://jcp.org/en/jsr/detail?id=303

Article comparing JSR 303 Reference Implementation And Spring 2.5 Validation
http://blog.jteam.nl/2009/08/04/bean-validation-integrating-jsr-303-with-spring/

JSR 303 Reference Material
http://people.redhat.com/~ebernard/validation/

JSR 303 Specification Leads Emmanuel Bernard Blog
http://in.relation.to/Bloggers/Emmanuel

Integrate JSR 303 Bean Validation And ApacheWicket

2009-11-01T00:12:00.000+01:00

In my previous blog I was writing about the new promising standard JSR 303 Bean Validation. In this article I will write about JSR 303 Bean Validation and Apache Wicket. Let start with recapitulate the domain object Person and see how we used the Bean Validation annotation to annotate our property constraints.

package se.msc.examples.validation.domain;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Pattern;
import javax.validation.constraints.Size;

@Entity
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long personId;
@NotNull
@Size(min = 1, max = 250)
@Column(length = 250)
private String givenName;
@NotNull
@Size(min = 1)
@Column(length = 250)
private String surname;
@NotNull
@Pattern(regexp = ".+@.+\\.[a-z]+")
@Column(length = 250)
private String mail;

public Long getPersonId() {
return personId;
}

protected void setPersonId(Long personId) {
this.personId = personId;
}

public String getGivenName() {
return givenName;
}

public void setGivenName(String givenName) {
this.givenName = givenName;
}

public String getSurname() {
return surname;
}

public void setSurname(String surname) {
this.surname = surname;
}

public String getMail() {
return mail;
}

public void setMail(String mail) {
this.mail = mail;
}

}

This time I also have added sun's JPA annotation, because this is a domain object and sooner we want the domain objects to be persisted. We also the see that there is an overlap between the Bean Validation annotation and the JPA annotation. My approach to these is to use an open constraint approach for persistence and a narrowing/stricter definition with the Bean Validation for the domain layer. This way enables us to have a more flexible database, DBA would probably argue that this leads to bad data quality, but since we are building in validation directly in our domain object and writing small and easy to run unit test, to test these validation, there are no risk against bad data quality slipping through to the persistence layer. Actually we are protecting bad data to even reach the persistence layer long before, first in the presentation layer, but also we will use the same Bean Validation in the service layer. And all validation using the same code, the Bean Validation annotation, no more inventing the wheel over and over again in the different layers.

So how do we use the Bean Validation with the Apache Wicket? Well, there is no out-of-box integration, so I have written a few helper classes that will do that for us. These helper classes are actually worth using already how ever you will be using Bean Validation or not in your next project, because Apache Wicket is really to low-tech, like Swing, and when writing Apache Wicket classes from ground up requires you to write quite lengthy masses of code, this is not good. So lets start with our helper classes for writing org.apache.wicket.markup.html.form.Form.

package se.msc.examples;

import org.apache.wicket.markup.html.form.Button;
import org.apache.wicket.markup.html.form.Form;
import org.apache.wicket.markup.html.form.TextField;
import org.apache.wicket.model.CompoundPropertyModel;
import org.apache.wicket.model.LoadableDetachableModel;

public class FormBuilder<T> extends Form<T> {
private static final long serialVersionUID = 1L;
public static final String SUBMIT = "submit";

public FormBuilder(final String id, final T modelObject) {
super(id, new CompoundPropertyModel<T>(new LoadableDetachableModel<T>(
modelObject) {
private static final long serialVersionUID = 1L;

protected T load() {
return modelObject;
}
}));
}

public void addTextField(final String propertyName) {
TextField<T> textField = new TextField<T>(propertyName);
textField.add(new BeanValidator<T>(getModelObject(), propertyName));
add(textField);
}

public void addSubmitButton(final FormButtonListener<T> listener) {
final FormBuilder<T> parent = this;
add(new Button(SUBMIT) {
private static final long serialVersionUID = 1L;

public void onSubmit() {
parent.execSubmit(listener);
}
});
}

public Form<T> create() {
return this;
}

public void execSubmit(final FormButtonListener<T> listener) {
listener.onSubmit(getModelObject());
}

}

package se.msc.examples;

import java.util.Set;

import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;

import org.apache.log4j.Logger;
import org.apache.wicket.validation.INullAcceptingValidator;
import org.apache.wicket.validation.IValidatable;
import org.apache.wicket.validation.ValidationError;

public class BeanValidator<T> implements INullAcceptingValidator<T> {
private static final long serialVersionUID = 1L;
private static final Logger log = Logger.getLogger(BeanValidator.class);
private final Class<T> beanClass;
private final String propertyName;

@SuppressWarnings("unchecked")
public BeanValidator(final T beanObject, final String propertyName) {
this.beanClass = (Class<T>) beanObject.getClass();
this.propertyName = propertyName;
}

@Override
public void validate(IValidatable<T> validatable) {
log.info("validate... " + validatable.getValue());
ReflectionUtil<T> util = new ReflectionUtil<T>();
T beanObject = util.createInstance(beanClass);
util.setPropertyValue(beanObject, propertyName, validatable.getValue());
Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
Set<ConstraintViolation<T>> violations = validator.validateProperty(beanObject, propertyName);
for (ConstraintViolation<T> violation : violations) {
String propertyPath = violation.getPropertyPath().toString();
String message = violation.getMessage();
log.error("invalid value for: '" + propertyPath + "': " + message);

ValidationError validationError = new ValidationError();
validationError.setMessage(message);
validatable.error(validationError);
}  
}

@Override
public String toString() {
return "[BeanValidator beanObject='" + beanClass + "']";
}

}

Lets now see how we use it in our Apache Wicket controller class.

package se.msc.examples;

import org.apache.log4j.Logger;
import org.apache.wicket.PageParameters;
import org.apache.wicket.markup.html.WebPage;
import org.apache.wicket.markup.html.form.Form;
import org.apache.wicket.markup.html.panel.FeedbackPanel;

import se.msc.examples.validation.domain.Person;

public class PersonEditPage extends WebPage implements FormButtonListener<Person> {
private static final long serialVersionUID = 1L;
private static final Logger log = Logger.getLogger(PersonEditPage.class);
protected static final String FEEDBACK_PANEL = "feedbackPanel";
protected static final String PERSON_FORM = "personForm";
protected static final String GIVEN_NAME = "givenName";

public PersonEditPage(final PageParameters parameters) {
log.info("PersonPage...");
add(new FeedbackPanel(FEEDBACK_PANEL));
add(createForm(new Person()));
}

private Form<Person> createForm(Person person) {
FormBuilder<Person> builder = new FormBuilder<Person>(PERSON_FORM, person);
builder.addTextField(GIVEN_NAME);
builder.addSubmitButton(this);
return builder.create();
}

@Override
public void onSubmit(Person modelObject) {
log.info("onSubmit " + modelObject);
info("Successfully created '" + modelObject.getGivenName() + "'.");
}

}

And the accompanying html file

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd"
xml:lang="en" lang="en">
<head>
<title>Person Edit Page</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>

<div id="feedbackPanel" wicket:id="feedbackPanel">Feedback Panel</div>
<form id="personForm" wicket:id="personForm">
<fieldset style="width: 30em">
<legend>Person Edit</legend>
<table border="1" style="width: 100%">
<tr>
<td align="right">Given Name:</td>
<td><input id="givenName" wicket:id="givenName" type="text" style="width: 98%" /></td>
</tr>
<tr>
<td colspan="2" align="right">
<button id="submit" wicket:id="submit" type="submit">Submit</button>
</td>
</tr>
</table>
</fieldset>
</form>

</body>
</html>

Now lets write a simple test case to test our Apache Wicket validation.

package se.msc.examples;



import junit.framework.TestCase;



import org.apache.wicket.markup.html.form.Form;

import org.apache.wicket.markup.html.panel.FeedbackPanel;

import org.apache.wicket.util.tester.FormTester;

import org.apache.wicket.util.tester.WicketTester;



public class PersonEditPageTest extends TestCase {

private WicketTester tester;



@Override

public void setUp() throws Exception {

tester = new WicketTester(new WicketApplication());

tester.startPage(PersonEditPage.class);

tester.assertRenderedPage(PersonEditPage.class);

}



public void testLayout() throws Exception {

tester.assertComponent(PersonEditPage.FEEDBACK_PANEL,

FeedbackPanel.class);

tester.assertComponent(PersonEditPage.PERSON_FORM, Form.class);

}



public void testCreate_OK() throws Exception {

FormTester form = tester.newFormTester(PersonEditPage.PERSON_FORM);

form.setValue(PersonEditPage.GIVEN_NAME, "Magnus");

form.submit(FormBuilder.SUBMIT);



tester.assertRenderedPage(PersonEditPage.class);

tester.assertNoErrorMessage();

}



public void testCreate_GIVENNAME_FAIL() throws Exception {

FormTester form = tester.newFormTester(PersonEditPage.PERSON_FORM);

form.setValue(PersonEditPage.GIVEN_NAME, "");

form.submit(FormBuilder.SUBMIT);



tester.assertRenderedPage(PersonEditPage.class);

tester.assertErrorMessages(new String[] { "Field givenName is required." });



form = tester.newFormTester(PersonEditPage.PERSON_FORM);

form.setValue(PersonEditPage.GIVEN_NAME, " ");

form.submit(FormBuilder.SUBMIT);



tester.assertRenderedPage(PersonEditPage.class);

tester.assertErrorMessages(new String[] { "Field givenName is required." });  

}

}

How to Install Swedish Dictionary and Thesaurus for Open Office Writer

2009-10-19T21:12:00.002+02:00

If you have installed a English distribution of Ubuntu you have already Open Office installed, but with no Swedish dictionary or Thesaurus. Do this to install:

Open Office Writer.
Select Tools->Language->More Dictionaries Online...
Download the two wanted files Dictionary and Thesaurus. Now you have to oxt-files on your computer.
Select Tools->Extension Manager and click Add then select oxt-file.
Restart Open Office and from Tools->Language->For All Text->More. In the window select installed language for selected document.

Clearlook Theme for Ubuntu – Clearlooks OSX

2009-10-19T20:33:00.003+02:00

In the beginning I found it quite hard to find new themes, that was compatible with the standard Ubuntu way to install theme, i.e. from System->Preferences->Appearance.

But yesterday I found a nice OSX look that is not so grey as Mac OSX, it is also packaged in the standard Ubuntu installation way.

http://www.gnome-look.org/content/show.php/ClearlooksOSX?content=69487

How to Enable Code Completion and Syntax Control Against XML Schema with Eclipse

2009-10-19T20:14:00.005+02:00

When I was writing Apache Camel configuration XML files, I was frustrated over that I had no code completion or XML syntax check against Apache Camel Schema, but of source is that doable in Eclipse. Simple download the Schema to your computer and then open Eclipe:

Window->Preferences->XML->XML Catalog

Click on Add and File System and select the downloaded Schema.
Now you can right-click in your XML file and select Validate.

Presentation for "Efficient J2EE Development with JPA, EJB3, Wicket, Maven2 and JBoss 5"

2009-10-11T21:18:00.002+02:00

For some ago I held a presentation for "Efficient J2EE Development with JPA, EJB3, Wicket, Maven2 and JBoss 5" and here comes the material:

http://docs.google.com/fileview?id=0BxdWn5V3EudmNmRiNGEyZGMtMDFjZC00Zjg4LWJiYWEtODJmNDE1MGI5OTM5&hl=en

Presentation for "Integration solutions with agile framework and Enterprise Service Bus, ESB"

2009-10-11T20:56:00.002+02:00

Here comes the presentation for the "Integration solutions with agile framework and Enterprise Service Bus, ESB" seminar I held for some time ago.

http://docs.google.com/fileview?id=0BxdWn5V3EudmY2U3MGYxNGMtMGE0NS00NzhiLTk2Y2QtMDI4OWI5YTA4YTlk&hl=en

Getting rid of notification “Network service discovery disabled” in Ubunut 9.04

2009-09-29T19:41:00.005+02:00

After installing the latest Ubuntu I have haunted with the annoying notification “Network service discovery disabled. You current network has a .local domain, which is not recommended and incompatible with the Avahi network service discovery. The service has been disabled.”

First of all I have to google what Avahi is and found the following short summary here: https://help.ubuntu.com/community/HowToZeroconf

After that, I got rid of the notification message, by removing the below file and then starting the Avahi service, since some files where not properly auto-created during installation.

sudo rm /var/run/avahi-daemon/disabled-for-unicast-local
sudo /etc/ini.d/avahi-daemon start

After that I disabled the Avahi service, because I could not see any reason to autostart it when Ubuntu booted. You can disabled auto-services from System->Administration->Services. The last thing I did was to reboot and the problem was gone.

Firefox 3.5 brakes Eclipse 3.4

2009-08-24T21:26:00.003+02:00

In mine previous blog I was writing about how to install Firefox 3.5 on Ubuntu 9.04, but that also had some unwanted side effect - it broke the Eclipse 3.4 installation!! Read more about http://hello-world-2-0.blogspot.com/2009/08/firefox-upgrade-broke-eclipse.html.

Configure Log4J DailyRollingFileAppender with custom PatternLayout

2009-08-24T03:09:00.005+02:00

For some time I haven been planning to learn the mystic configuration of the org.apache.log4j.PatternLayout for Log4j and finally I have taken the time to do so.

c - The calling class name, if giving without precision is the fully qualified name returned.
C - The fully qualified class name.
d - The date of the logging request, can be formatted with java.text.SimpleDateFormat, i.e. %d{yyyy-MM-dd}
F - The name of the calling File.
l - The location information, same as %C%M(%F:%L). This can be slow.
L - The calling class line number
m - The logging message.
M - The calling class method.
n - The platform dependent line separator.
p - The logging Level.
r - The relative date in millisecond since application start.
t - The invoking thread.
[x|X] - the Message Diagnostic (MDC) information.

Now for some example. To be compliant with large open-source project such as Hibernate Annotation we use SLF4J as Logger interface. To use SLF4J, simply add the following to your Maven pom.xml

<dependency>

<groupId>org.slf4j</groupId>

<artifactId>slf4j-log4j12</artifactId>

<version>1.4.2</version>

</dependency>

And if we run 'mvn dependency:tree', we see that the artifact also contains the log4j.jar implementation.

[INFO] Scanning for projects...

[INFO] Searching repository for plugin with prefix: 'dependency'.

[INFO] ------------------------------------------------------------------------

[INFO] Building Log4J Test

[INFO]    task-segment: [dependency:tree]

[INFO] ------------------------------------------------------------------------

[INFO] [dependency:tree]

[INFO] se.msc.development:log4j-test:jar:1.0-SNAPSHOT

[INFO] +- org.slf4j:slf4j-log4j12:jar:1.4.2:compile

[INFO] |  +- org.slf4j:slf4j-api:jar:1.4.2:compile

[INFO] |  \- log4j:log4j:jar:1.2.13:compile

[INFO] +- javax.mail:mail:jar:1.4.1:compile

[INFO] |  \- javax.activation:activation:jar:1.1.1:compile

[INFO] \- junit:junit:jar:4.5:test

[INFO] ------------------------------------------------------------------------

[INFO] BUILD SUCCESSFUL

[INFO] ------------------------------------------------------------------------

[INFO] Total time: 4 seconds

[INFO] Finished at: Mon Aug 24 03:05:27 CEST 2009

[INFO] Final Memory: 12M/144M

[INFO] ------------------------------------------------------------------------

And here follows an example of how to use SLF4J in your code.

package se.msc.log4j;

import org.junit.Test;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Log4JTest {
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
private static final Logger log = LoggerFactory.getLogger(Log4JTest.class);

//import org.apache.log4j.Logger;
//private static final Logger log = Logger.getLogger(Log4JTest.class);

@Test
public void testFoo() throws Exception {
log.info("Info log message.");
log.error("Fatal log message.", new NullPointerException("Null pointer exceptopn."));
}

}

An the log4j configuration file log4j.properties

# configure the root logger
log4j.rootLogger=INFO, STDOUT, DAILY

# configure the console appender
log4j.appender.STDOUT=org.apache.log4j.ConsoleAppender
log4j.appender.STDOUT.Target=System.out
log4j.appender.STDOUT.layout=org.apache.log4j.PatternLayout
log4j.appender.STDOUT.layout.conversionPattern=%d{yyyy-MM-dd HH:mm:ss.SSS} [%p] %c:%L - %m%n

# configure the daily rolling file appender
log4j.appender.DAILY=org.apache.log4j.DailyRollingFileAppender
log4j.appender.DAILY.File=/tmp/log4j/log4jtest.log
log4j.appender.DAILY.DatePattern='.'yyyy-MM-dd
log4j.appender.DAILY.layout=org.apache.log4j.PatternLayout
log4j.appender.DAILY.layout.conversionPattern=%d{yyyy-MM-dd HH:mm:ss.SSS} [%p] %c:%L - %m%n

and when running the JUnit test:

2009-08-24 03:00:47.775 [INFO] se.msc.log4j.Log4JTest:18 - Info log message.
2009-08-24 03:00:47.783 [ERROR] se.msc.log4j.Log4JTest:19 - Fatal log message.
java.lang.NullPointerException: Null pointer exceptopn.
at se.msc.log4j.Log4JTest.testFoo(Log4JTest.java:19)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41)
at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28)
at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:73)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:46)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:180)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:41)
at org.junit.runners.ParentRunner$1.evaluate(ParentRunner.java:173)
at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28)
at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31)
at org.junit.runners.ParentRunner.run(ParentRunner.java:220)
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:45)
at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:460)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:673)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:386)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:196)

And now I final word about the DatePattern for the org.apache.log4j.DailyRollingFileAppender:

log4j.appender.DAILY.DatePattern='.'yyyy-MM-dd-a

Rolls over at midnight each day, as is the expected behaviour of a rolling log.

Bundle a Common Jar Into EJB Jar with Maven Plugin maven-ejb-plugin

2009-08-19T10:09:00.004+02:00

Yesterday I had some problem with packing an EJB3 jar with Maven plugin maven-ejb-plugin. The problem seemed quite common. To bundle a common jar dependency into an EJB jar, but after reading the documentation for the maven-ejb-plugin at http://maven.apache.org/plugins/maven-ejb-plugin/, it seemed clear that the plugin lacked this capability. After several hour of failure I ran into a workaround . Instead of configure the maven-ejb-plugin I used the maven-dependency-plugin to copy the desired dependency jar into the target/classes directory and then configure maven-dependency-plugin to run before the package phase.

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-ejb-plugin</artifactId>
<configuration>
<generateClient>false</generateClient>
<ejbVersion>3.0</ejbVersion>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<executions>
<execution>
<id>copy-dependencies</id>
<phase>process-classes</phase>
<goals>
<goal>copy-dependencies</goal>
</goals>
<configuration>
<includeGroupIds>se.msc.development</includeGroupIds>
<includeArtifactIds>common</includeArtifactIds>
<outputDirectory>${project.build.outputDirectory}</outputDirectory>
</configuration>
</execution>
</executions>
</plugin>

And if you need to add the common.jar to the classpath in the MANIFEST file add the following configuration to maven-ejb-plugin.

<archive>
<manifest>
<addclasspath>true</addclasspath>
</manifest>
<manifestfile>${project.build.outputDirectory}/META-INF/MANIFEST.MF</manifestfile>
</archive>

Installing Firefox 3.5 on Ubunut 9.04 – the Jaunty Jackalope

2009-08-11T11:49:00.002+02:00

After several crashes with Firefox 3.0x I decided to install the new Firefox 3.5, since the new version is managed with Synaptic Package Manager everything went smoothly, but with one gotcha. Do not remove the old Firefox, otherwise will panel shortcut and menu item be removed and when clicking on html files will nothing happens. Instead do the following:

sudo apt-get install firefox-3.5 firefox-3.5-gnome-support

Redirect the firefox link to the new version:

sudo rm /usr/bin/firefox
sudo ln -s /usr/bin/firefox-3.5 /usr/bin/firefox

Effective Unit Testing EJB 3.0 with OpenEJB

2009-07-29T02:06:00.003+02:00

In my latest project we used EJB 3.0 and Maven2. And as any good programmer I wanted to have good code quality, which means good unit test test coverage, but my expectation on how to achieve this in an efficient manner was quite low, since mine previous experience with EJB 2.1 did not include any good testing experience. Even if coding EJB 3.0 has been greatly simplified, the fact still remains that the enterprise bean has still to be deployed before it can be tested. Of course can one program such that the logic is in a POJO rather directly in the bean itself, but to really be sure it is working the enterprise bean has to be deployed in a container, to be testable. So I started looking at different Maven plugin such as, jboss-maven-plugin and cargo-maven2-plugin, but then came across OpenEJB, which is really the salvation if you are developing EJB 3.0 and want good testing possibility. OpenEJB enable unit testing of enterprise beans as any POJO class! Lets look at some examples.

public class UserServiceSLSBTest {
private static final String EXPECTED_USERNAME_1 = "fornamn.1.efternamn@domain.com";
private static final String EXPECTED_USERNAME_2 = "fornamn.2.efternamn@domain.com";
private static final String EXPECTED_USERNAME_3 = "fornamn.3.efternamn@domain.com";
private Context ctx;

@BeforeClass
public static void oneTimeSetUp() {
}

@AfterClass
public static void oneTimeTearDown() {
}

@Before
public void setUp() throws Exception {
Properties props = new Properties();
props.setProperty(Context.INITIAL_CONTEXT_FACTORY,
"org.apache.openejb.client.LocalInitialContextFactory");

props.put("blogUnmanaged", "new://Resource?type=DataSource");
props.put("blogUnmanaged.JtaManaged", "false");
props.put("blogUnmanaged.JdbcDriver", "com.mysql.jdbc.Driver");
props.put("blogUnmanaged.JdbcUrl", "jdbc:mysql://localhost:3306/blog");
props.put("blogUnmanaged.username", "root");
props.put("blogUnmanaged.password", "");
// TODO fix properties hibernate.hbm2ddl.auto=create-drop

ctx = new InitialContext(props);
}

@After
public void tearDown() {
}

private UserServiceLocal createUserService() throws Exception {
Object obj = ctx.lookup(UserServiceSLSB.class.getSimpleName() + "Local");

assertNotNull(obj);
assertTrue(obj instanceof UserServiceLocal);
return (UserServiceLocal) obj;
}

@Test
public void testCreateUser() throws Exception {
UserServiceLocal userService = createUserService();

User user = new User();
user.setUsername(EXPECTED_USERNAME_1);
user.setPassword(EXPECTED_USERNAME_1);
user.setRoles(Roles.ADMIN);

userService.storeUser(user);
}
}

And the Stateless Session Bean

@Stateless
public class UserServiceSLSB implements UserServiceLocal {
private static final Logger log = LoggerFactory.getLogger(UserServiceSLSB.class);
@PersistenceContext(name = "blog-ejb", unitName = "blog-ejb")
protected EntityManager em;
@Resource
private SessionContext context;

@Override
public User findUserByUsername(String username) {
log.info("findUserByUsername username='" + username + "'...");
Query q = em.createQuery("SELECT u from User as u where u.username=:username");
q.setParameter("username", username);
List list = q.getResultList();
return (list.size() > 0) ? (User) list.get(0) : null;
}

private void checkExistingUser(User user) throws DuplicateException {
User existingUser = findUserByUsername(user.getUsername());
if (existingUser != null)
throw new DuplicateException("Duplicate " + user);
}

@Override
public void storeUser(User user) throws CredentialException, DuplicateException {
log.info("storeUser " + user + "...");
checkExistingUser(user);
if (user.getUserId() == null)
em.persist(user);
else
em.merge(user);
}
}

And the SLSB local interface.

@Local
public interface UserServiceLocal {

public User findUserByUsername(String username);

public void storeUser(User user) throws CredentialException, DuplicateException;
}

And in the pom.xml simply add the dependency to OpenEJB and you are ready to go.

<dependency>
<groupId>org.apache.openejb</groupId>
<artifactId>openejb-core</artifactId>
<version>3.1.1</version>
<scope>test</scope>
</dependency>

Playing Commercial DVD with Ubuntu Jaunty Jackalope 9.04

2009-07-29T01:40:00.001+02:00

I previously wrote a blog about how to play commercial DVD with Ubuntu Hardy Heron 8.10 Intrepid Ibex, but here comes an update how it is done with the latest Ubuntu.


sudo /usr/share/doc/libdvdread4/install-css.sh

Why Previous Java Web Framework Have Failed and Why Apache Wicket Will Succeed.

2009-07-22T16:54:00.002+02:00

There exists numerous Java web framework (e.g. Struts, JSF, Spring MVC, etc.) and most of them are build upon the Model-View-Controller pattern, but though they have been used in numerous successful project, the Java community still produces new Java web framework. Why is that? According to me the previous Java web framework have several flaws:

The JSP technique is messy and clutters down the view page, maybe not for simple pages, but definitely for more complex pages.
The round trip when developing JSP pages is long since JSP pages can not be viewed, without first compiling them and running them in a web container. This severely slows down the project . This is especially true when one is fixing layout issues.
Web and JSP developer have different code base. This also slows down the project productivity, since when the web team ships new code or fixes, the JSP developer must copy past that into different JSP code.
Verbose XML configuration, is something the entire Java community is trying to get away from via Annotation and better default values. For example look at the EJB or Spring developing.
It is hard and verbose to unit test and even harder to maintain.

Though these many flaws there has not been any good alternative around to develop Java web solution, but now I would say the missing link is found – Apache Wicket.

The Apache Wicket architecture differs in two major way.

It does not use JSP technology for coding Views, instead it uses simple HTML and extend it with attributes.
You create components (TextField, CheckBox, etc.) in the Controller and add behavioral via Listener classes, such as in Swing.

These two major differences make a huge different:

Web and View developer use the same code base.
No need to compile and run the View in a container, simply open the View in a web browser and watch differences.
Easy to write unit test code.

Before going through an example, lets first take a brief overview over the main Wicket classes. Component are simple Java classes with supporting HTML markup.
Each Components holds a Model that is a simple Java class with data.

What is here imported is that the default Model are stateful and most example for Wicket uses the default model. This is unfortunate because that is not best practice, because stateful objects consume memory and make the application less scalable. The two most imported classes two use to make the application stateless is


      IModel usersModel = new LoadableDetachableModel() {
          protected Object load() {
              return WicketApplication.get().getUserService().getUsers();
          }
      };

and


      new BookmarkablePageLink(“newUser”, UserEditPage.class);

and if you need to pass data use Link with as little data as possible.


              Link view = new Link("editUser", itemList.getModel()) {
                  public void onClick() {
                      setResponsePage(new UserEditPage(user.getUserId()));
                  }
              };

Now look how easy and clean the unit test is:


public class UserEditPageTest extends TestCase {
 protected static final Logger log = Logger.getLogger(UserEditPageTest.class);
 private WicketTester tester;

 public void setUp() {
  tester = new WicketTester(new WicketApplication());
 }

 private void setUpNewUserEditPage() {
  tester.startPage(UserEditPage.class);
  tester.assertRenderedPage(UserEditPage.class);
 }

 public void testLayout() {
  setUpNewUserEditPage();

  tester.assertComponent(UserEditPage.FEEDBACK_PANEL, FeedbackPanel.class);
  tester.assertComponent(UserEditPage.USER_FORM, Form.class);
 }

 public void testNewUser() {
  setUpNewUserEditPage();

  FormTester form = tester.newFormTester(UserEditPage.USER_FORM);
  form.setValue(UserEditPage.USERNAME, "kalle.stropp@fake.com");
  form.setValue(UserEditPage.PASSWORD, "validpassword");
  form.select(UserEditPage.ROLES, 0);
  form.submit(FormBuilder.BUTTON_SAVE);

  tester.assertRenderedPage(UserListPage.class);
  tester.assertNoErrorMessage();
 }
}

And here follows the rest of the code:


public class UserEditPage extends TemplatePage implements ButtonListener, IChoiceRenderer {
 private static final long serialVersionUID = 1L;
 protected static final String FEEDBACK_PANEL = "feedbackPanel";
 protected static final String USER_FORM = "userForm";
 protected static final String USER_ID = "userId";
 protected static final String USERNAME = "username";
 protected static final String PASSWORD = "password";
 protected static final String ROLES = "roles";
 protected static final Logger log = Logger.getLogger(UserEditPage.class);

 public UserEditPage() {
     setModel(new CompoundPropertyModel(new LoadableDetachableModel() {
   private static final long serialVersionUID = 1L;

   protected Object load() {
             return new User();
         }
     }));
     init(false);
 }

 public UserEditPage(final long userId) {
     setModel(new CompoundPropertyModel(new LoadableDetachableModel() {
      private static final long serialVersionUID = 1L;
      
         protected Object load() {
             User user =  WicketApplication.get().getUserService().loadUser(userId);
             user.setPassword(null); // hide current password
             return user;
         }
     }));
     init(true);
 }
 
   protected String getPageTitle() {
    return "userEditPage.title";
   }
 
 public void init(boolean readOnly) {
  add(new FeedbackPanel(FEEDBACK_PANEL));
  add(createForm(readOnly));
 }

 public Form createForm(boolean readOnly) {
  FormBuilder builder = new FormBuilder(USER_FORM, getModel());
  builder.addLabel(USER_ID);
  builder.addTextField(USERNAME, true, 30, readOnly);
  builder.addPasswordTextField(PASSWORD);
  User user = (User) builder.getModelObject();
  builder.addDropDownChoice(ROLES, Arrays.asList(user.getRoles().getValues()), this);
  builder.addSubmitButton(this);
  return builder.create();
 }

 @Override
 public void onSubmit(Object modelObject) {  
  log.info("onSubmit " + modelObject);
  WicketApplication.get().getUserService().storeUser((User) modelObject);
       setResponsePage(UserListPage.class);  
 }

 @Override
 public Object getDisplayValue(Object object) {
       return ((Roles) object).getRole();
 }

 @Override
 public String getIdValue(Object object, int index) {
  return ((Roles) object).getRole();
 }
}

And the HTML


 <html >
 <head > </head >
 <body >

 <wicket:extend >
 
  <div wicket:id="feedbackPanel" >Feedback Panel </div > 
  
  <form wicket:id="userForm" >
  <fieldset style="width:250px;" >
   <legend > <wicket:message key="userEditPage.userForm" >User Form </wicket:message > </legend > 
   <table >
    <tr >
     <td align="right" > <wicket:message key="userEditPage.userId" >UserId </wicket:message >: </td >
     <td > <span wicket:id="userId" id="userId" >1 </span > </td >
    </tr >
    <tr >
     <td align="right" > <wicket:message key="userEditPage.username" > <u >U </u >sername </wicket:message >: </td >
     <td > <input wicket:id="username" type="text" name="username" accesskey="u" / > </td >
    </tr >
    <tr >
     <td align="right" > <wicket:message key="userEditPage.newPassword" >New  <u >p </u >assword </wicket:message >: </td >
     <td > <input wicket:id="password" type="password" name="password" accesskey="p" / > </td >
    </tr >
    <tr >
     <td align="right" > <wicket:message key="userEditPage.roles" > <u >R </u >oles </wicket:message >: </td >
     <td > <select wicket:id="roles" > </select > </td >
    </tr >   
    <tr >
     <td colspan="2" align="right" >     
      <button wicket:id="save" type="submit" accesskey="s" > <wicket:message key="userEditPage.save" > <u >S </u >ave </wicket:message > </button >
     </td >
    </tr >  
   </table >
  </fieldset >
     </form >

 </wicket:extend >

 </body >
 </html >

Good Java Open-Source Summary Site

2009-07-05T09:59:00.001+02:00

Sometimes you come across good sites that you want to share with others. And today it happened I came across a good site that summaries a lot of Java open-source project. Which is a good starting page if you are looking for new Java library, for your new Java project. Enjoy!

http://java-source.net/

Thunderbird Lightning 0.9 on Ubuntu 9.04 (Jaunty Jackalope)

2009-05-06T07:57:00.002+02:00

Yesterday I upgraded to Ubuntu 9.04, every thing went smoothly as always with Ubuntu. The day before I did a new installation of Windows XP and what a pain it was! I have to manually install literally every drivers – chipset, graphic, network, etc. And after every install you did have to restart. But when installing Ubuntu everything just works, but when doing the upgrade I did discover one thing. You should not install Lightning 0.9 by downloading the xpi-file and from Thunderbird install the add-ons, but instead use synaptic.


sudo apt-get install lightning-extension

And if you are still using Ubuntu 8.1 you should install libstdc++5


sudo apt-get install libstdc++5

For more details of the bug read:

https://bugs.launchpad.net/ubuntu/+source/thunderbird/+bug/278853

Frukostseminarium Integrationsresa från lättviktigt ramverk till fullskalig standardiserad Enterprise Service Bus (ESB)

2009-04-15T12:39:00.002+02:00

Den 29 april kommer jag att hålla frukostseminarium om Apache Camel, Enterprise Integration Pattern och Apache ServiceMix på MSC kontor. Seminariumet är riktat till utvecklare och projektledare och kommer innehålla rikligt med demos, så om du är intresserad att lära dig mera om de olika integrationslösningar, anmäl dig då till magnus.k.karlsson@msc.se.

Mer information finns på http://www.msc.se/tjanster/utbud-it-seminarier/it-konsulter-Integrationsresa_fran_lattviktigt-ramverk_till_fullskalig_standardiserad_Enterprise_Service_Bus_ESB.html.

SOA by Examples

2009-03-06T13:29:00.003+01:00

SOA is a buzz word that have been round for some time, but when you search for information about SOA it is hard to find hands on information what SOA really is and also examples of SOA. The lack of concrete example is a problem for us practical people which tend to learn new thing by examples and not read abstract theories about new technology. We do that but not before we got a god grasp of what we are learning. It is with that background I decided to write this blog.

Before going through examples, let us look what does SOA promises us, i.e. the goals of SOA:
The reuse of existing system, when building new application.

So how do we do that?
Encapsulate existing system with a fronting API and build the rest of the functionality as reusable services/components.

Enough with theory, now lets take some examples.

In this example the business case is to create a new application that can place customer orders, but with the criteria to reuse existing back-end solutions.

The SOA solution is built of the following reusable block

Basic Data Service - CRUD operations.
Composed Services - business logic.
Process Services – complex business logic.

Another example is a unified patience journal system.
An additional example could be Package Tour Operation containing the following services:

Flight Booking
Hotel Booking
Car Rental
Event Booking.

What is imported when talking about SOA is not to get stuck which techniques to use, but to focus on which service to use and what to fill them with, so they are reusable.

Enterprise Integration Diagram for Apache ServiceMix, Camel and Petal

2009-02-28T21:27:00.005+01:00

One of the challenge when doing integration job with an ESB solution is to visualize it. If you are using Eclipse rescue is on the way - Eclipse Enterprise Integration Designer, STP.

The Eclipse STP project implement, some of the most imported pattern of the Enterprise Integration Pattern.

The project is still in incubation and there are some problem to run it, even if you follow the installation instruction from the STP site.

Installation

Download Eclipse Ganymede SR1 Enterprise edition.
Start Eclipse and open Help → Software Updates...
Select Ganymede → SOA → STP Designer, see snapshot. and install.
After restart, close Eclipse and download patch from http://webui.sourcelabs.com/eclipse/issues/240077
Extract the zip file to eclipse/plugins folder and start Eclipse.

Creating Integration Patterns Diagram

Create a pattern project, e.g. a simple Java project.
Create New and Other and select Integration Patterns Diagram.
At the time being is unfortunately only ServiceMix and Petal, supported, so select ServiceMix.
End the guide and finish.

After that you are set to create diagrams.

Clustering and CAP Theorem

2009-02-27T02:47:00.002+01:00

When designing an application for clustering one should first be aware of the CAP (Consistency, Availability and Partitioning) theorem. The theorem states that you can only have two of the three CAP properties at the same time.

The Consistency means that all users see the same set of data, even when data updated or deleted. This is normally achieved with storing data to a database and using transactions.

Availability is achieved through replicating data, so that data is always available even in case of failure.

The last, Partitioning, means that the system is partitioning tolerant, i.e. the system holds when it is distributed over several servers and machines.

So which one should go? Well when building highly loaded applications as Google or Amazon the natural answer is Consistency, because letting the system not be available during failure or being not responsive during high load is not a options. This is quite interesting because most programmers are raised with the idea of using a database as a foundation for an application. And this idea must now go. Or? Well it is not so black and white.

The main key of building clustered application is twofold:

Asynchronous communication. E.g. Amazon has a separate service displaying what books other people has also bought. Failure of this service should not hinder the rest of the page to be rendered.
Brake down your application and analyze each part individually according to CAP properties. Does payment must be consistent? Probably. Does user information needs to be consistent. Probably not. Etc.

After you analyzed your application into different clustering functions you keep these data separated, because they will be deployed differently and independently.

So to achieve an High Availability and Partitioned Tolerant application is through scaling out, I.e. using more machines and using:

Stateless data, i.e. the applications server only holds request data.
Replicate read intensive data through a master/slave setup.
Caching data.
Sharding database, i.e. using multiple databases and manually decide which tables goes into which database.

Hibernate Search Example

2009-02-22T12:08:00.005+01:00

In my previous blog I was writing about Hibernate Search in general, but in this blog I will show you code examples of using Hibernate Search.

The preferred and easiest way to get started is to use Maven2, if you are not able to use Maven2 then please download the relevant jar file.


<project xmlns="http://maven.apache.org/POM/4.0.0"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
       http://maven.apache.org/maven-v4_0_0.xsd">

<modelVersion>4.0.0</modelVersion>
<groupId>se.msc</groupId>
<artifactId>hibernatesearch</artifactId>
<version>0.0.1-SNAPSHOT</version>
<repositories>
 <repository>
  <id>repository.jboss.org</id>
  <name>JBoss Maven Repository</name>
  <url>http://repository.jboss.org/maven2</url>
  <layout>default</layout>
 </repository>
</repositories>
<dependencies>
 <!-- For Test -->
 <dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.5</version>
  <scope>test</scope>
 </dependency>
 <!-- Hibernate Core -->
 <dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-core</artifactId>
  <version>3.3.1.GA</version>
 </dependency>
 <!-- Hibernate Annotation -->
 <dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-annotations</artifactId>
  <version>3.4.0.GA</version>
 </dependency>
 <!-- Hibernate Annotation uses SLF4J -->
 <dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-log4j12</artifactId>
  <version>1.5.2</version>
 </dependency> 
 <!-- Hibernate EntityManager -->
 <dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-entitymanager</artifactId>
  <version>3.4.0.GA</version>
 </dependency>
 <!-- Hibernate Validator
 <dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-validator</artifactId>
  <version>3.0.0.ga</version>
 </dependency> --> 
 <!-- Hibernate Search -->
 <dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-search</artifactId>
  <version>3.1.0.GA</version>
 </dependency>
 <!-- Hibernate Search 3part Lib -->
 <!-- Solr's Analyzer Framework -->
 <dependency>
  <groupId>org.apache.solr</groupId>
  <artifactId>solr-common</artifactId>
  <version>1.3.0</version>
 </dependency>
 <dependency>
  <groupId>org.apache.solr</groupId>
  <artifactId>solr-core</artifactId>
  <version>1.3.0</version>
 </dependency>
 <dependency>
  <groupId>org.apache.lucene</groupId>
  <artifactId>lucene-snowball</artifactId>
  <version>2.4.0</version>
 </dependency>
 <!-- MySQL JDBC connector -->
 <dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.6</version>
 </dependency>
</dependencies>
<build>
 <plugins>
  <plugin>
   <groupId>org.apache.maven.plugins</groupId>
   <artifactId>maven-compiler-plugin</artifactId>
   <configuration>
    <source>1.6</source>
    <target>1.6</target>
   </configuration>
  </plugin>
 </plugins>
</build>
</project>

In this example I will be using Hibernate Core, Hibernate Annotation and Hibernate Search. I will not use Hibernate EntityManager, but using EntityManager instead of Session is and easy thing to do and will not impact the concept or code significantly.

Lets start with configure our Hibernate Core with hibernate.cfg.xml.


<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
   "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
   "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
<session-factory>
 <property name="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</property>
 <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
 <property name="hibernate.connection.url">
  jdbc:mysql://localhost:3306/test?createDatabaseIfNotExist=true&amp;useUnicode=true&amp;characterEncoding=utf-8
 </property>
 <property name="hibernate.connection.username">root</property>
 <property name="hibernate.connection.password"></property>
 <property name="hibernate.hbm2ddl.auto">create-drop</property> <!-- update -->

 <!-- Hibernate Search -->
 <!-- org.hibernate.search.store.FSDirectoryProvider -->
 <!-- org.hibernate.search.store.RAMDirectoryProvider for test -->
 <property name="hibernate.search.default.directory_provider">
  org.hibernate.search.store.RAMDirectoryProvider
 </property>
 <property name="hibernate.search.default.indexBase">
  /home/magnus/tmp/lucene/indexes
 </property>  

 <!-- Mapped classes -->
 <mapping class="se.msc.hibernatesearch.domain.Person" />
</session-factory>
</hibernate-configuration>

The Hibernate Search comes with sensible default values and there is actually only two values that needs configuring the directory provider and the base directory of the index files.

In this example I will be using JUnit as start class and since unit tested class are run over and over again I will for consistency use an in-memory index in combination with drop and create the database schema. This way I will always get a clean start whenever restarting the JUnit text.

To make our example complete here is the log4j.properties file.


# Root logger option
log4j.rootLogger=INFO, stdout

# Log native SQL
log4j.logger.org.hibernate.SQL=debug
log4j.logger.org.hibernate.bind=debug

# Direct log messages to stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

To be able to use Hibernate from JUnit we need the popular a HibernateUtil.


public class HibernateUtil {

private static final SessionFactory sessionFactory;

static {
 try {
  AnnotationConfiguration conf = new AnnotationConfiguration();
  sessionFactory = conf.configure().buildSessionFactory();
 } catch (Throwable ex) {
  throw new ExceptionInInitializerError(ex);
 }
}

public static Session getSession() throws HibernateException {
 return sessionFactory.openSession();
}
}

Now lets start with annotating our domain class. For simplicity I will only use one class here.


@Entity
@Table(name = "PERSON")
@Indexed
public class Person implements Serializable {

private static final long serialVersionUID = 1L;

@Id
@Column(name = "PERSON_ID", updatable = false)
@GeneratedValue(strategy = GenerationType.IDENTITY)
@DocumentId
private Long id = null;

@Column(name = "FIRSTNAME", nullable = false, length = 250)
@Field(index = Index.TOKENIZED, store = Store.YES)
private String firstname = "";

@Column(name = "BIRTHDATE", nullable = false)
@Field(index = Index.UN_TOKENIZED, store = Store.YES)
@DateBridge(resolution = Resolution.DAY)
private Date birthdate = new Date();

public Person() {
}

public Person(String firstname, String birthdate)
  throws IllegalArgumentException {
 setFirstnameFromInput(firstname);
 setBirthdateFromInput(birthdate);
}

public Long getId() {
 return id;
}

protected void setId(Long id) {
 this.id = id;
}

public String getFirstname() {
 return firstname;
}

public void setFirstname(String firstname) {
 this.firstname = StringUtil.setEmptyStringAsNull(firstname);
}

public void setFirstnameFromInput(String firstname) {
 this.firstname = StringUtil.setEmptyStringAsNullAndTrim(firstname);
}

public Date getBirthdate() {
 return birthdate;
}

public void setBirthdate(Date birthdate) {
 this.birthdate = DateUtil.setTodayAsNull(birthdate);
}

public void setBirthdateFromInput(String birthdate)
  throws IllegalArgumentException {
 this.birthdate = DateUtil.setTodayAsNullAndParse(birthdate);
}

public String toString() {
 return "Person {" + "id=" + id + ", firstname='" + firstname
   + "', birthdate='" + DateUtil.format(birthdate) + "'}";
}
}

There is not much to it. We use @Indexed to mark the class searchable, @DocumentId for primary key, @Field for simple properties and @DateBride for properties that need transformation, remember that Lucene only works with strings.

All Hibernate Search annotation are documented in org.hibernate.search.annotations

There is only two annotation that need further explanation:

index (Index.TOKENIZED | Index.UN_TOKENIZED)
Tokenized split the text into words (Tokens) and removes insignificant words. See example.

Untokenized leaves the text unchanged.

store (Store.YES | Store.NO)
Both options indexed the field, but Store.YES writes the field to Lucene index file and makes it available via Luke. But the main difference is that now one can utilize projection which means you can avoid even touching the database, that is the benefit we are looking for when writing high speed search application. The main drawback when using project is that raw Object, containing String value, are returned, instead of domain object graphs.

Using Store.YES should be the preferred way whenever you want high performance, and if you need to further manipulate the object, simple do a database round trip and grab the persisted domain object via the primary key.

Another drawback of projection is that you can only index simple properties and on-to-one (embedded) object, but not other many relations. This is due of difference in the object mode between Lucene and Hibernate.


public class HibernateTemplate {

public Object execute(HibernateCallback action) throws HibernateException {
 Session session = null;
 Transaction tx = null;
 Object object = null;
 try {
  session = HibernateUtil.getSession();
  tx = session.getTransaction();
  tx.begin();
  object = action.execute(session);
  tx.commit();
 } catch (HibernateException e) {
  if (tx != null && tx.isActive())
   tx.rollback();
  throw e;
 } finally {
  if (session != null)
   session.close();
 }
 return object;
}

public void saveOrUpdate(final Object entity) throws HibernateException {
 execute(new HibernateCallback() {

  @Override
  public Object execute(Session session) throws HibernateException {
   session.saveOrUpdate(entity);
   return null;
  }
 });
}

public List find(final String query) throws HibernateException {
 return (List) execute(new HibernateCallback() {

  @Override
  public Object execute(Session session) throws HibernateException {
   return session.createQuery(query).list();
  }
 });
}

public List findWithFullText(String query, String field,
  final Class entity) throws HibernateException, ParseException {

 QueryParser parser = new QueryParser(field, new StandardAnalyzer());
 final org.apache.lucene.search.Query lucQuery = parser.parse(query);

 return (List) execute(new HibernateCallback() {

  @Override
  public Object execute(Session session) throws HibernateException {
   FullTextSession ftSess = Search.getFullTextSession(session);
   return ftSess.createFullTextQuery(lucQuery, entity).list();
  }
 });

}

public List findWithFullTextAndProjection(String query, String field,
  final Class entity) throws HibernateException, ParseException {

 QueryParser parser = new QueryParser(field, new StandardAnalyzer());
 final org.apache.lucene.search.Query lucQuery = parser.parse(query);

 return (List) execute(new HibernateCallback() {

  @Override
  public Object execute(Session session) throws HibernateException {
   FullTextSession fTS = Search.getFullTextSession(session);
   FullTextQuery fTQ = fTS.createFullTextQuery(lucQuery, entity);
   fTQ.setProjection("id", "firstname", "birthdate");
   return fTQ.list();
  }
 });

}
}

public interface HibernateCallback {

public Object execute(Session session) throws HibernateException;
}

public class SessionTest {

private static final Person[] INIT_DATA = new Person[] {
  new Person("Magnus", "1974-01-01"),
  new Person("Bertil", "1973-02-02"),
  new Person("Klara", "1972-03-03") };

private static final String FIELD = "firstname";

private static final Class ENTITY = Person.class;

HibernateTemplate temp = new HibernateTemplate();

private void printPersonResult(Person[] persons) {
 System.out.println("Number of hits: " + persons.length);
 for (Person person : persons) {
  System.out.println(person);
 }
}

private void printObjectResult(List res) {
 System.out.println("Number of hits: " + res.size());
 for (Object row : res) {
  Object[] objects = (Object[]) row; 
  for (Object o : objects)
   System.out.println(o);
 }
}

@Test
public void testSaveAll() throws Exception {
 for (Person person : INIT_DATA)
  temp.saveOrUpdate(person);
}

@Test
public void testFindAll() throws Exception {
 List res = temp.find("from Person");
 Assert.assertEquals("Testing find all.", 3, res.size());
 printPersonResult(res.toArray(new Person[0]));
}

@Test
public void testFullText() throws Exception {
 String query = "firstname:Magnus";
 List res = temp.findWithFullText(query, FIELD, ENTITY);
 Assert.assertEquals("Testing firstname search.", 1, res.size());
 printPersonResult(res.toArray(new Person[0]));
}

@Test
public void testFullText2() throws Exception {
 String query = "birthdate:19720303";
 List res = temp.findWithFullText(query, FIELD, ENTITY);
 Assert.assertEquals("Testing birthdate search.", 1, res.size());
 printPersonResult(res.toArray(new Person[0]));
}

@Test
public void testFullTextProjection() throws Exception {
 String query = "firstname:Magnus OR birthdate:19730202";
 List res = temp.findWithFullTextAndProjection(query, FIELD, ENTITY);
 Assert.assertEquals("Testing search projection.", 2, res.size());
 printObjectResult(res);
}
}

Hibernate Search

2009-02-20T01:03:00.002+01:00

In my last project I worked with Apache Lucene doing full-text/free-text search. I was quite impress of the Lucene library and what it was capable of and the speed it was executing the search. After that I was thrill to look at the Hibernate Search project that unite the popular ORM library Hibarnate and Apache Lucene and this is what I concluded.

Using the Database Free-Text Capability
The full-text feature is not new and several popular databases already implement that feature, as Oracle DB, Microsft SQL Server and MySQL, but the problem with this are:

You cannot use HQL, but must use native SQL, i.e. your solution will not be portable.

But the greatest problem is scalability. Most of the tier of an server solution can easily be clustered, but the database is normally not deployed in that way, since its primary task is to upright hold atomicity. Normally you mirroring a database for fail-over, but not clustering it. And since full-text search can be very CPU and memory intensive doing full-text search directly against a database is not the best way.

SQL shortcoming
But there also other problems that SQL poorly addresses.

First when searching a text one is not interested of all the “glue"-words, e.g. a, the, over, under, but merely noun and verbs. The same thing goes for the query. This analyzing is not part of SQL where query are based on the same order and all words, that the query contains.

Another importing feature of a rich text-search library is handling of words with the same root and meaning, e.g. save, saving, saved. This should a good search-text library take into account.

To make a search library appreciated, it should also understand typos, it should have a more phonetic approach.

The last, but not the least, is returning search result sorted by relevance. Relevance is often defined as:

If a query contain multiple word, search result where the same word order is more resembled, should have a higher rank.
If a query contain multiple word, search result with the most word match frequntly, should have a higher rank.
If the query contains typos, the better resembles, the higher rank.

When NOT to use Hibernate Search
Even if Lucene is great there are some time, when you do not want to use it. These cases are when you want to search after a specific column, e.g. date, integer column or when you want to wild card search a specific word, then you are better off with SQL queries. This is of course natural when you think about it since these are not free-text field, merely singular value columns.

All this does Apache Lucene promise, but then why Hibernate Search, what does it offer? The problem between Lucene and hibernate is twofold:
Hibernate uses a structured domain model with association, etc., but where Lucene stores indexed in a flat hierarchy.
How to handle synchronization between Hibernate ACID CRUDE operation and the Lucene Index. Once updating the database one expects the index also be updated.

Remove Gnome Globalmenu

2009-02-19T21:24:00.005+01:00

I have been playing around with making Ubuntu look like Mac OSX, and when doing so I installed gnome2-globalmenu. Before the latest version there where no synaptic package available so one was left with manually compile and install the applet by hand. This worked and there are several guides written to guide you, but the problem arise when you want to uninstall it. I have been search the web but found only one forum discussion in german how to completely uninstall the gnome global menu.


First remove the applet and the environment variable GTK_MODULES.

After doing this normally one think you should be done, but NO you are not. Every time you start an application you get the error message.


Gtk-Message: Failed to load module "globalmenu-gnome": 
libglobalmenu-gnome.so: cannot open shared object file: No such file or 
directory

To get rid of this, do the following:


Open gconf-editor, press alt+f2 and then run.
Disable globalmenu-gnome

Make Ubuntu 8.10 Intrepid Look Like Mac OSX

2009-02-14T02:19:00.003+01:00

There are numerous site describing how to make Ubuntu look like Mac OSX, but must site that I have come across are quite buggy. And even the home page for the Google Global Menu is not correct. But yesterday I came across I really good web page that works and maybe even more imported have to uninstall the theme.

http://maketecheasier.com/turn-your-ubuntu-intrepid-into-mac-osx-leopard/2009/01/08

And if you are annoyed with the close, minimize and maximize (metacity) buttons you can change that with the following.


Open gconf-editor, press alt+f2 and then run.


Edit the key: app → metacity → general


Set the button_layout to: menu:close,minimize,maximize

And a last that is forgotten is that Mac4Lin comes with themes and plugins for firefox and thunderbird. These packages are located in Mac4Lin directory and under Mozilla.

Java Concurrency: How to Share Data Between Threads.

2009-02-11T13:52:00.004+01:00

One of challenging thing of writing multi thread safe application is to share data between different threads. The problem is twofold:

Visibility, i.e. one reading thread must see the latest value that another thread writes to.
Atomicity, e.g. one thread increment a shared class variable must be consistent with another thread setting the same class variable to a new value.

The simplest case is when one class variable is not depending on its previous state/value. A typical example is a boolean value that is explicit set and does not make use of its previous value.


public class Worker {

private volatile boolean working = false;

private long workCount = 0L;

public boolean isWorking() {
return working;
}

public void startWorking() {
working = true;
work();
}

public void stopWorking() {
working = false;
}

private void work() {
while (working) {
 ++workCount;
}
}
}

In this example we do not use synchronization, but instead we use volatile. What volatile do is force the JVM to store the variable value in memory, instead of local registers that each thread otherwise read and writes from.

What is imported to not forget about volatile it does not upright hold Atomicity, so if the class variable was depending on it's previous state/value, this implementation would not be thread safe. Instead one should use one of the classes in java.util.concurrent.atomic package.

Java Concurrency

2009-01-22T00:48:00.000+01:00

Writing a thread safe application is a challenging task, but with Java 1.5 and 1.6 a lot of the plumbing infrastructure has been moved into the Java language. But before looking at these new feature, one must first be able to write thread safe classes. Writing thread safe classes is most about sharing object's state in a safe way. That can be achieved in four ways:

Use Thread Confinement, that is to ensure that data is only accessed by one thread at a time. Examples of that are:

Swing Event Dispatch Thread, that is accessed via the javax.swing.SwingWorker
java.sql.Connection that is retrieved from a server application pool.

Use Read-Only data.

Make object thread safe.

java.util.concurrent.atomic.AtomicLong

java.util.concurrent.ConcurrentHashMap

java.util.concurrent.ConcurrentLinkedQueue

java.util.concurrent.CopyOnWriteArrayList is the concurrent replacement of . java.util.Collections.synchronizedList(), but should only be used when iteration is far more common than modification. The reason is that copying arrays becomes very costly when the size of the list grows.

Guard object.

synchronized methods

Intrinsic Lock: Using private class variable to synchronize blocks in methods.

If you are not depending of the previous value of a variable, you can get away of adding volatile to the class variable. Volatile ensures that the most recent values are always visible between different threads memory areas. Using volatile can simplify implementing thread safety, but beware that volatile only guarantee visibility, not Atomicity.

Now to show all the goodies that the latest Java comes with. If you want to move out one task of a code that could be done asynchronously, you need a Producer-Consumer. The Producer is the original code and the asynchronously task is put in the Consumer.


public class Producer implements Runnable {

 private final File root;

 private final BlockingQueue queue;

 public Producer(String path, BlockingQueue queue) {
  this.root = new File(path);
  this.queue = queue;
 }

 @Override
 public void run() {
  for (File file : root.listFiles()) {
   if (file.isFile()) {
    readHeadOfFile(file);
   }
  }
  System.out.println("Finished producing!");
 }

 public void readHeadOfFile(File file) {
  System.out.println("Reading '" + file.getName() + "'...");
  BufferedReader reader = null;
  try {
   reader = new BufferedReader(new FileReader(file));
   queue.add(reader.readLine());
  } catch (IOException e) {
   System.out.println("Failed to read '" + file.getAbsolutePath() + "'. " + e.getMessage());
   Thread.currentThread().interrupt();
  } finally {
   closeQuitly(reader);
  }
 }
 
 public void closeQuitly(Reader reader) {
  if (reader != null) {
   try {
    reader.close();
   } catch (IOException e) {
   }
  }
 }
}

public class Consumer implements Runnable {

 private final BlockingQueue queue;

 public Consumer(BlockingQueue queue) {
  this.queue = queue;
 }

 @Override
 public void run() {
  try {
   while (true) {
    String str = queue.take();
    System.out.println("Consuming '" + str + "'.");
   }
  } catch (InterruptedException e) {
   System.out.println("Consumer interrupted!");
   Thread.currentThread().interrupt();
  }
 }
}

public class ProducerConsumerTest {

 private final ExecutorService pool = Executors.newFixedThreadPool(10);

 private final BlockingQueue queue = new LinkedBlockingQueue();
 
 @Before
 public void setUp() {

 }

 @After
 public void tearDown() {
  pool.shutdown(); // Disable new tasks from being submitted
  try {
   System.out.println("Wait 30s for existing tasks to terminate...");
   if (!pool.awaitTermination(30, TimeUnit.SECONDS)) {
    System.out.println("Cancel currently executing tasks");
    pool.shutdownNow();  
    // Wait a while for tasks to respond to being cancelled
    if (!pool.awaitTermination(60, TimeUnit.SECONDS))
     System.err.println("Pool did not terminate");
   }
  } catch (InterruptedException ie) {
   // (Re-)Cancel if current thread also interrupted
   pool.shutdownNow();
   // Preserve interrupt status
   Thread.currentThread().interrupt();
  }
 }

 @Test
 public void test() {
  try {
   pool.execute(new Producer("/home/magnus/documents/", queue));
   pool.execute(new Consumer(queue));
  } catch (Exception e) {
   e.printStackTrace();
   pool.shutdown();
  }
 }
}

Examples of applicable scenarios are:

Moving logic operation out from the IO code.

Moving logging code out of the logic code.

Another convenient function is a Latch. I used it when writing a test harness and wanted to make sure all the test threads were released at the same time and then wait for them to finish, before exiting the test harness.
See java.util.concurrent.CountDownLatch API for a good example.

If you want a reusable Latch, then look at java.util.concurrent.CyclicBarrier. I used that one when doing calculation that should take place every time unit. See the API for a good example.

One of the best thing that comes out of the box are all the Thread Pools:

java.util.concurrent.Executors.newFixedThreadPool

java.util.concurrent.Executors.newCacheThreadPool

java.util.concurrent.Executors.newSingleThreadPool. Good because if single thread goes down a new one is automatically started.

java.util.concurrent.Executors.newScheduledThreadPool

Firefox freezes when oping grails.org

2009-01-20T10:18:00.000+01:00

I had my first real bad experience with Ubuntu when I was looking at the grails project. The Firfox web browser totally hanged when opened grails.org. I have google around but could not directly find any solution to this problem, but yesterday I found a bug report about it. It is the nvidia graphical drivers that is not working properly. To fix this install a newer nvidia driver:


sudo apt-get install nvidia-180-kernel-source nvidia-180-modaliases nvidia-glx-180

This will remove the old drivers:


nvidia-177-kernel-source
nvidia-glx-177

After installation reboot and after login should "Hardware Drivers" dialog appear and prompt you to grant that restricted drivers be used. Select the new nvidia 180 drivers.

https://bugs.launchpad.net/ubuntu/+source/nvidia-graphics-drivers-177/+bug/289964

Removing White Spaces in File Name

2009-01-02T04:16:00.000+01:00

Sometimes when you are transferring files to or from different devices or even computer running different OS, using spaces in file names can cause problems. Therefore I wrote this little script that removes white spaces from all the files in a given directory.


#!/bin/sh
for f in *; do mv "$f" `echo $f | tr --delete ' '`; done

Using Different Date and Time Format in Thunderbird

2009-01-02T04:13:00.000+01:00

If you are running a non-localized Ubuntu installation, but going crazy on the America date and time format in Thunderbird, then you should use this script to start Thunderbird. The script alter the date and time format to yyyy-MM-dd.


#!/bin/sh
export LC_TIME=en_DK.utf8
/usr/bin/thunderbird $*

Playing Commercial DVD with Ubuntu

2009-01-02T01:53:00.000+01:00

Like Adobe Flash and proprietary media formats cannot be distributed with Ubuntu since they are not open source, but playing commercial DVD on Ubuntu is not hard. Simply install the below script and you will be able to play commercial DVD.


sudo /usr/share/doc/libdvdread3/install-css.sh

Once the scripts has finished simply insert a DVD and Totem player will automatically be launch. One downside with Totem player is it is not handling DVD menu very well, actually you could say it does not handle it at all. A better choice is then using VLC for playing DVD.


sudo apt-get install vlc

Building Standalone Application with Maven2

2009-01-01T16:51:00.000+01:00

If you are building standalone application in Java, Maven is your friend when packing your application, There are two way to let Maven package your application, either as a single jar with all your dependencies jar.


 <plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-assembly-plugin</artifactId>
  <configuration>
   <descriptorRefs>
    <descriptorRef>jar-with-dependencies</descriptorRef>
   </descriptorRefs>
  </configuration>
 </plugin>

One advantage if you choose to do this way is if you need to sign your application jar. This is needed if you are building a Java Web Start client and you need more access than connecting back to the server. To read more about have Maven signing your jar read http://maven.apache.org/plugins/maven-jar-plugin/usage.html.
But if you choose to go this way, make sure that all license agreement are shipped with your one single jar.

Another way is to let Maven package your source code only and then referring the dependent jar file from the MANIFEST file.


 <plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-jar-plugin</artifactId>
  <configuration>
   <archive>
    <manifest>
     <addClasspath>true</addClasspath>
     <mainClass>se.msc.adapter.Main</mainClass>
     <classpathPrefix>lib/</classpathPrefix>
    </manifest>
   </archive>
  </configuration>
 </plugin>

Listening on Internet Radio with Ubuntu

2009-01-01T16:09:00.002+01:00

Listening on Internet Radio while programming is a must, but the common player with Ubuntu, Rythmbox Music Player, does not have many preinstalled internet radio stations. Of course is there way to fix this, the below site shows you have to add the popoular swedish internet radio stations radioseven.se to Rythmbox.

http://henrikan.wordpress.com/2008/02/29/svenska-internetradiokanaler-for-rhythmbox/

But a better player that have SHOUTcast search engine preinstalled, which is the same search engine that ships with Winamp, is StreamTuner. The SHOUTcast search engine can almost find any internet radio station that will satisfy almost all music flavor.

And as always Ubuntu shine when it comes to install new programs.

sudo apt-get install streamtuner streamripper

Maven2 Goodies

2008-12-20T02:58:00.001+01:00

Here is a short summary of good Maven2 goodies that I have came across.

The imported dependencies are located at the Central Maven2 Repository: http://repo1.maven.org/maven2/

Archetypes
The simplest way to start a new project is to use an archetype. To browse available archetypes go to http://docs.codehaus.org/display/MAVENUSER/Archetypes+List

Plugin
One good thing about Maven except the standirezed directore structure is all the plugin to maven.

List of all Maven Internal Plugins: http://maven.apache.org/plugins/
External Plugin Search Page: http://mvnrepository.com/

To list available goals for a plugin:


mvn help:describe -Dplugin=jaxb2

To list available configurations for a plugin:


mvn help:describe -Dplugin=jaxb2 -Dfull

Source and Javadoc
How to add source files and javadoc to maven project:


mvn dependency:sources

And when to generate eclipse project


mvn eclipse:eclipse -DdownloadSources=true -DdownloadJavadocs=true

Name convention for source and javadoc resources:


foo-1.0.jar (or whatever artifact is referred to in the pom.xml)
foo-1.0-sources.jar (optional, jar containing java sources)
foo-1.0-javadoc.jar (optional, jar containing javadocs)

Dependency
When using Maven the number of dependencies tends to grow and after a while there is no way to tell if a jar file is really needed, but there is, use the below command to resolve unuzed dependency. On caution is that some jar file are not directly referenced from the code, but rather dynamically loaded during runtime. I have seen that these are not always correctly resolved, so always test your system after removing a dependency.

 
mvn dependency:resolve
...
[WARNING] Unused declared dependencies found:
[WARNING]    javax.xml.bind:jaxb-api:jar:2.1:compile
[WARNING]    com.sun.xml.bind:jaxb-impl:jar:2.1.9:compile
...


mvn dependency:tree
...
[INFO] [dependency:tree]
[INFO] se.msc:xml:jar:0.0.1-SNAPSHOT
[INFO] +- junit:junit:jar:4.5:test
[INFO] +- javax.xml.bind:jaxb-api:jar:2.1:compile
[INFO] |  +- javax.xml.stream:stax-api:jar:1.0-2:compile
[INFO] |  \- javax.activation:activation:jar:1.1:compile
[INFO] \- com.sun.xml.bind:jaxb-impl:jar:2.1.9:compile
...

Eclipse Maven Integration - m2eclipse
If you are developing with eclipse and using Maven2 you should use m2eclipse plugin.

Some times when creating new workspace the central maven repository disappear, you experience that when getting zero find result, when adding a new depency. To fix that open View 'Maven Index' and add the central maven repository.

Building Standalone with Maven2
If you are building a standalone app and want to run it from the command line, and you want to get all dependencies classpath, execute the following command.


mvn dependency:build-classpath

JMX, MBeans, jconsole, VisualVM och Spring MBean

2008-10-25T00:23:00.000+02:00

Java Management Extension (JMX) är enkelt sätt att managera produktionssatt kod. Dels man kan inspektera property värden, men även anropa exponerade metoder och slutligen skicka och ta emot event. För exponera metoder/klasser använder man MBeans. Det finns fem MBeans:

Statiska MBeans:

Standard MBeans
MXBeans (J2SE 5/6)

Dynamiska MBeans:

Dynamic MBeans
Model MBeans
Open MBeans

Statiska MBeans

Standard MBeans

Standard MBeans är den enklaste MBean typen och bygger på att man använder fördefinierade namnsättningar på sina klasser (introspection).


package se.msc.jmx;

public interface CalculatorMBean {

   public int getMemory();
 
   public void setMemory(int memory);
 
   public int add(int x, int y);
 
   public int divide(int x, int y);
}


package se.msc.jmx;

public class Calculator implements CalculatorMBean {

   private int memory;
 
   public int getMemory() {
       return memory;
   }
 
   public void setMemory(int memory) {
       this.memory = memory;
       System.out.println("New memory=" + memory);
   }
 
   public int add(int x, int y) {
       return x + y;
   }
 
   public int divide(int x, int y) {
       return x / y;
   }
}


package se.msc.jmx;

import java.lang.management.ManagementFactory;

import javax.management.MBeanServer;
import javax.management.ObjectName;

public class Bootstrap {

   public static void main(String[] args) throws Exception {
       MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
     
       mbs.registerMBean(new Calculator(), 
           new ObjectName("se.msc.jmx:type=Calculator"));

       System.out.println("Running...");
       Thread.sleep(Long.MAX_VALUE);
   }
}

Kompilera koden och start sedan:

java se.msc.jmx.Bootstrap

Starta sedan jconsole:

jconsole

och dubbelklicka se.msc.jmx

Bild 1. Attribut

Bild 2: Metoder

MXBeans

MXBeans skiljer sig inte mycket från Standard MBeans utan tillkom för att adressera brister i Standard implementationen:

Interface och implementation måste ligga i samma paket.
Man behöver inte följa namnstandard längre utan kan använda annotation - @MXBean.
Man kan nu använda enum (Open Types)

Intressant är också att JRE tillhandahåller en hel del MXBeans, t.ex. GarbageCollectorMXBean och ThreadMXBean, se java.lang.management för komplett lista.

Dynamiska MBeans

Skillnaden mellan statiska och dynamiska MBeans är att dynamiska MBeans exponerar sina attribut och metoder i runtime och är inte hårt satta som i det statiska fallet.

Nyheter i J2SE 6

I J2SE 6 så har det inte tillkommit så mycket för JMX, men en stor skillnad på verktyg sidan är VisualVM. VisualVM är en sammanslagning av:

jconsole – JMX console för Java SE 5/6
jstat – JVM statistik monitoreringsverktyg
jstack – stack trace för java processer
jinfo – konfiguration av java processer
jmap – minnesanvändning av java processer

Spring och JMX

Spring Framework gör livet enklare (som vanligt) för JMX utvecklare och om du redan använder Spring i ditt projekt, så rekommenderar jag varmt att använda Spring JMX. Det Spring JMX erbjuder:

Exponering av vanliga klasser (icke JMX klasser) som MBeans
Enklare notifieringshantering.
Rikare metadata via annotering

Se Spring JMX http://static.springframework.org/spring/docs/2.0.x/reference/jmx.html för fullständig dokumentation.

Referenser:

Bugg i JMX local JMX registry: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6754672

J2SE 6 JMX Guide: http://java.sun.com/javase/6/docs/technotes/guides/jmx/

Remote Monitoring and Management: http://java.sun.com/j2se/1.5.0/docs/guide/management/agent.html#remote

Maven2, m2eclipse och Nexus

2008-10-23T06:16:00.000+02:00

För er som fortfarande använder Ant som byggstöd, borde kolla Maven2. Maven2 är ett komplett byggverktyg, fast med tre skillnader:

Det har inbyggt stöd för Code Lifecycle, vilket innebär om ska bygga ett projektet ska koden gå igenom alla livscyklar upp till package. Detta tänkande är väldigt uppfostrande och innebär att innan man kodat klart en komponent ska man även ha skrivet testfall, och dessa testfall ska gå igenom innan man skeppar en jar.

Validate → Generate Source → Generate Resource → Compile → Test → Package → Install → Deploy

Nästa är att Maven2 Project Object Model, POM, blir väldigt kompakt om man använder de fördefinierade katalogstrukturer, vilket innebär om en ny utvecklare ska sättas in i projektet och är bekant med Maven2, genast kommer att hitta i projektkatalogerna, men också veta hur han eller hon bygger eller testar kod utan att detta är dokumenterat.

Sist men inte minst, finns de flesta tänkbara plugins till Maven2, som kommer med vettiga defaultvärden, vilket leder till att de flesta plugins fungerar out-of-the-box.

Men ett byggverktyg blir inte komplett om det inte finns bra IDE stöd och för eclipse är det m2eclipse. M2eclipse har genomgått stora förändringar de senaste 8 månader då 6 personer på heltid arbetat med m2eclipse plugin. För att enklast installera m2eclipse, så använder man Eclipse Software Update och anger:

http://m2eclipse.sonatype.org/update-dev/

I större organisationer där man vill dela byggda moduler eller där säkerhetspolicys begränsar användare att vara direkt uppkopplad mot Internet finns Nexus. Nexus blir den repository som man användare frågar efter moduler, istället för att direkt gå till Maven2 centrala repository.

Sist men inte minst så behöver man inte längre komma ihåg vilka archetypes det finns för Maven2, alla tillgängliga finns direkt sökbara via m2eclipse, då man skapar nytt Maven2 projekt innefrån Eclipse.

Apache Camel presentation av Bruce Snyder på Colorado Software Summit 2008

2008-10-23T03:45:00.000+02:00

I måndags var jag på en riktig bra presentation av Bruce Snyder (http://softwaresummit.com/2008/speakers/snyder.htm) som presenterade Apache Camel. Camel erbjuder implementation av alla pattern som Gregor Hohpe och Bobby Woolf beskriver I Enterprise Integration Pattern, men det som är fascinerade är hur enkelt det är att använda Camel.

För att implementera Content-Based Router, dvs. beroende på innehåll i XML-fil från ActiveMQ (JMS) meddelande så skickar man det vidare till olika kataloger på disk.


 RouteBuilder builder = new RouteBuilder() {
public void configure() {
 from("activemq:topic:Quotes").choice()
     .when(xpath("/order/item = ‘paper’")).to("file://orders/paper")
     .otherwise().to("file://orders/other");
     }
 };

Och för att implementera Message Filer, som här filtrerar mha XPath XML-fil på disk och skickar vidare till ActiveMQ.


public class MyRouteBuilder extends RouteBuilder {
   public void configure() {
       from("file://orders").
           filter().xpath("/quote/product = ‘widget’").
               to("mqseries:WidgetQuotes");
   }
}

Och för Message Translator, som här transformerar XML-fil på disk och skickar transformerad XML till HTTP.


public class MyRouteBuilder extends RouteBuilder {
   public void configure() {
     from("file://incoming”).
       to("xslt:se/msc/mytransform.xsl").
         to("http://outgoing.msc.se/foo");
   }
 }

Komplett lista över alla Integration Pattern, finns på http://www.enterpriseintegrationpatterns.com/toc.html. Vad också värt att notera är att man definerat ikoner för de flesta pattern, så om man skall modulera flöde i sitt projekt, så behöver man inte tänka på hur man skall representera mönstren.

Om inte detta redan har övertygat dig att använda Camel, så kolla in listan över de protokoll, som de stödjer out-of-the-box, http://activemq.apache.org/camel/components.html, saknar du något protokoll?

Att gå från Windows till Ubuntu 8.04 på Dell Latitude D830

2008-10-21T14:36:00.000+02:00

För ett tag sedan så gick jag över till att enbart köra Ubunut på min lapptopp och de svårigheter jag hade tänkte jag skriva om nedan.

Till och börja med så vill jag säga till er alla som funderar att gå över till Linux, välj Ubuntu, det av två anledningar. Dels så kan man först testa att köra Ubuntu utan att installera den (Live CD) och för det andra, så fungerade det mesta direkt, utan strul med drivrutiner eller att behöva konfigurera inställningar till dödsdagar för att nå en acceptabel nivå.

I mitt fall så hittade Ubuntu alla mina hårdvaror och konfigurerade dem till vettiga standardvärden - Helt otroligt! Så varför denna artikel? Jo, några saker kom inte med i en standardinstallation.

1. Dubbla skärmar.
Installera nvidia-settings: sudo apt-get install nvidia-settings
För att ändra, kör: sudo nvidia-settings

2. Blutooth
Börja med att kontrollera om den blåa Bluetooth lampan lyser. Om inte kontrollera att skjutreglaget till vänster på datorn är satt till >>. Lyser lampan nu? Om inte måste man aktivera Bluetooth från windows. Start Windows och dubbelklicka på trash icon nere till höger, välj sedan settings och därifrån klicka på on-knappen under settings. Nu kan du gå tillbaka till Ubuntu.

Installera sedan alla BlueZ (the Bluetooth Stack) komponenter. Enklast från Synaptic Package Manager. Sök efter alla komponenter bluez-* och installera dessa.

Starta Bluetoot service: /etc/init.d/bluetooth start

Kontrollera konfiguration: hciconfig

Konfigurera: gedit /etc/bluetooth/hcid.conf


#
# HCI daemon configuration file.
#

# HCId options
options {
    # Automatically initialize new devices
    autoinit yes;

    # Security Manager mode
    #   none - Security manager disabled
    #   auto - Use local PIN for incoming connections
    #   user - Always ask user for a PIN
    #
    security auto;

    # Pairing mode
    #   none  - Pairing disabled
    #   multi - Allow pairing with already paired devices
    #   once  - Pair once and deny successive attempts
    pairing multi;

    # Default PIN code for incoming connections
    passkey "1234";

        # PIN helper
        #pin_helper /etc/bluetooth/pin-helper;
}

# Default settings for HCI devices
device {
    # Local device name
    #   %d - device id
    #   %h - host name
    name "%h-%d";

    # Local device class
    class 0x000100;

    # Default packet type
    #pkt_type DH1,DM1,HV1;

    # Inquiry and Page scan
    iscan enable; pscan enable;
    #discovto 0;

    # Default link mode
    #   none   - no specific policy
    #   accept - always accept incoming connections
    #   master - become master on incoming connections,
    #            deny role switch on outgoing connections
    lm accept;

    # Default link policy
    #   none    - no specific policy
    #   rswitch - allow role switch
    #   hold    - allow hold mode
    #   sniff   - allow sniff mode
    #   park    - allow park mode
    lp rswitch,hold,sniff,park;
}

Start om bluetooth service: /etc/init.d/bluetooth restart

Du kan nu kolla dina inställningar: hciconfig -a

Slå nu på din mobiltelefon eller annan bluetoot device och sök efter den: hcitool scan

Koppla sedan ihop dem via: hcitool inq

Du kan nu kolla förbindelse genom att pinga MAC-adressen, mha l2ping.

Det enklaste sättet sedan att föra över bilder från en mobiltelefon är att göra det från mobiltelefonen.

4. Kalender med Lightner plugin för Thunderbird

Om du inte redan har installerat thunderbird, gör så: sudo apt-get install thunderbird

För att lightner skall fungera, måste du installera: sudo apt-get install libstdc++5

Installera sedan plugin till thunderbird via thunderbird Tools | Adds-on. Inte via synaptic package manager!