Useful Java Development setup instructions for Ubuntu

https://help.ubuntu.com/community/EclipseIDE

Lumosity and Physical Exercise

I am a subscriber of Lumosity, it is a website which has a wonderful set of small games designed to improve and test memory, attention and other cognitive functions.

I have found that whenever I exercise a bit, I get a jump in my scores!!

I know this is well known, but experiencing this for myself vs just reading about it are two different things. Now that I KNOW that exercise helps, this is a nice little feedback loop for me to pull myself up these winter days and hit the Gym more often

Ubuntu: Problem during "gem install" - /usr/bin/ruby1.8 extconf.rb

If you get this when installing sqlite3-ruby:

biju@ubhome:~$ sudo gem install sqlite3-ruby
Building native extensions.  This could take a while...
ERROR:  Error installing sqlite3-ruby:
 ERROR: Failed to build gem native extension.

/usr/bin/ruby1.8 extconf.rb
extconf.rb:1:in `require': no such file to load -- mkmf (LoadError)
 from extconf.rb:1


Gem files will remain installed in /var/lib/gems/1.8/gems/sqlite3-ruby-1.2.5 for inspection.
Results logged to /var/lib/gems/1.8/gems/sqlite3-ruby-1.2.5/ext/sqlite3_api/gem_make.out

Then solution gleaned from Google is to run:

biju@ubhome:~$ sudo apt-get install ruby1.8-dev

If it says:

biju@ubhome:~/notes$ sudo gem install sqlite3-ruby
Building native extensions.  This could take a while...
ERROR:  Error installing sqlite3-ruby:
 ERROR: Failed to build gem native extension.

/usr/bin/ruby1.8 extconf.rb
checking for fdatasync() in -lrt... yes
checking for sqlite3.h... no

Then solution is to run:

biju@ubhome:~/notes$ sudo apt-get install libsqlite3-dev

"sudo gem install sqlite3-ruby" should just run with these libraries in place.

If you see the following while starting the rails application:

./script/../config/../vendor/rails/railties/lib/initializer.rb:259:in `require_frameworks': no such file to load -- openssl (RuntimeError)
 from ./script/../config/../vendor/rails/railties/lib/initializer.rb:133:in `process'
 from ./script/../config/../vendor/rails/railties/lib/initializer.rb:112:in `send'
 from ./script/../config/../vendor/rails/railties/lib/initializer.rb:112:in `run'

then run:

sudo apt-get install libopenssl-ruby

Scala Maven projects with multiple source folders

I had a need on a recent scala based maven project to be able to support multiple source folders - to hold the scala and java source and tests separately."Build Helper" Maven plugin perfectly fit this need, the following is a sample pom.xml configured using this plugin:

There are two sources - src/main/java holding the java code, and src/main/scala holding the scala code

and two test sources - src/test/java, src/test/scala.

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>org.bk</groupId>
<artifactId>trainroute</artifactId>
<version>1.0-SNAPSHOT</version>
<build>
    <sourceDirectory>src/main/scala</sourceDirectory>
    <testSourceDirectory>src/test/scala</testSourceDirectory>
    <plugins>
        <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <source>1.6</source>
                <target>1.6</target>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.scala-tools</groupId>
            <artifactId>maven-scala-plugin</artifactId>
            <executions>
                <execution>
                    <goals>
                        <goal>compile</goal>
                        <goal>testCompile</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <scalaVersion>${scala.version}</scalaVersion>
            </configuration>
        </plugin>
  <plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>build-helper-maven-plugin</artifactId>
    <version>1.3</version>
    <executions>
      <execution>
        <id>add-source</id>
        <phase>generate-sources</phase>
        <goals>
          <goal>add-source</goal>
        </goals>
        <configuration>
          <sources>
            <source>src/main/java</source>
          </sources>
        </configuration>
      </execution>
      <execution>
        <id>add-test-source</id>
        <phase>generate-sources</phase>
        <goals>
          <goal>add-test-source</goal>
        </goals>
        <configuration>
          <sources>
            <source>src/test/java</source>
          </sources>
        </configuration>
      </execution>
    </executions>
  </plugin>        
    </plugins>
</build>
<dependencies>
    <dependency>
        <groupId>org.scala-lang</groupId>
        <artifactId>scala-library</artifactId>
        <version>${scala.version}</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>${junit.version}</version>
        <scope>test</scope>
    </dependency>
</dependencies>
<properties>
    <scala.version>2.7.6</scala.version>
    <junit.version>4.6</junit.version>
</properties>

<repositories>
    <repository>
        <id>scala-tools.org</id>
        <name>Scala-tools Maven2 Repository</name>
        <url>http://scala-tools.org/repo-releases</url>
    </repository>
</repositories>
<pluginRepositories>
    <pluginRepository>
        <id>scala-tools.org</id>
        <name>Scala-tools Maven2 Repository</name>
        <url>http://scala-tools.org/repo-releases</url>
    </pluginRepository>
</pluginRepositories>
</project>

Spring Web Services - How to - Article contributed to Javalobby - http://java.dzone.com/articles/spring-ws-how

Spring Webservices encourages a contract first, message oriented approach to creating Webservices. The underlying details are completely under developer control starting from the contract to the marshalling/unmarshalling details to the endpoint handling the request.

Let us start by an example of a simple service to expose as a webservice - call it the MemberService. MemberService exposes one operation “Get Member Details” which returns the details of a member/person, given an identifier.

Creating the contract:

The Contract/WSDL for this service is fairly simple. Let us start by defining the messages and type :

01.<xsd:schema targetNamespace="http://bk.org/memberservice/" elementFormDefault="qualified">

02. <xsd:complexType name="MemberDetailType">

03. <xsd:sequence>

04. <xsd:element name="name" type="xsd:string" />

05. <xsd:element name="phone" type="xsd:string" />

06. <xsd:element name="city" type="xsd:string" />

07. <xsd:element name="state" type="xsd:string" />

08. xsd:sequence>

09. xsd:complexType>

10. <xsd:element name="MemberDetailsRequest">

11. <xsd:complexType>

12. <xsd:sequence>

13. <xsd:element name="id" type="xsd:string" />

14. xsd:sequence>

15. xsd:complexType>

16. xsd:element>

17. <xsd:element name="MemberDetailsResponse">

18. <xsd:complexType>

19. <xsd:sequence>

20. <xsd:element name="memberdetail" type="ms:MemberDetailType" />

21. xsd:sequence>

22. xsd:complexType>

23. xsd:element>

24.xsd:schema>

MemberRequest message comprises of an id to represent the requested members identifier

MemberResponse message comprises of MemberDetail type to represent the details of a member.

A sample payload over the wire would look like this:

1.xml version="1.0"?>

2.<ms:MemberDetailsRequest xmlns:ms="http://bk.org/memberservice/">

3. <ms:id>SAMPLEms:id>

4.ms:MemberDetailsRequest>

and a sample response:

1.<ms:MemberDetailsResponse xmlns:ms="http://bk.org/memberservice/">

2. <ms:memberdetail>

3. <ms:name>testnamems:name>

4. <ms:city>testcityms:city>

5. <ms:phone>testphonems:phone>

6. <ms:state>teststatems:state>

7. ms:memberdetail>

8.ms:MemberDetailsResponse>

The sample request and response can be easily generated by using a tool like SOAP UI –

Creating an Endpoint:

A Spring-WS endpoint processes the XML message and produces the XML response. Spring provides different Endpoints based on how the XML is to be handled. If you wish to handle raw xml you have the option of implementing AbstractDom4jPayloadEndpoint, AbstractDomPayloadEndpoint, AbstractJDomPayloadEndpoint etc, based on how the raw xml needs to be handled. If you wish to handle the XML message as an object representation then you can implement the AbstractMarshallingPayloadEndpoint, which is what I will be using for this example along with JIBX as the XML binding framework for its ease of use and performance.

01.package org.bk.memberservice.endpoint;

02.

03.import org.bk.memberservice.message.MemberDetailsRequest;

04.import org.bk.memberservice.message.MemberDetailsResponse;

05.import org.bk.memberservice.service.MemberManager;

06.import org.bk.memberservice.types.MemberDetail;

07.import org.springframework.ws.server.endpoint.AbstractMarshallingPayloadEndpoint;

08.

09.public class GetMemberDetailsEndpoint extends

10. AbstractMarshallingPayloadEndpoint {

11.

12. private MemberManager memberManager;

13.

14. protected Object invokeInternal(Object requestObject) throws Exception {

15. MemberDetailsRequest request = (MemberDetailsRequest) requestObject;

16. MemberDetail memberDetail = memberManager.getMemberDetails(request

17. .getId());

18. MemberDetailsResponse response = new MemberDetailsResponse(memberDetail);

19. return response;

20.

21. }

22.

23. public void setMemberManager(MemberManager memberManager) {

24. this.memberManager = memberManager;

25. }

26.}

The structure of the Endpoint is very simple, it takes an Object which can be cast to MemberDetailsRequest a holder for the request, and the response is returned as an instance of MemberDetailsResponse, a holder for the response details.

Writing the Object/XML binding:

So we now have the endpoint to process the take in the request Message, process it and respond. The only missing piece is how to transform the raw request xml over the wire to the MemberDetailsRequest object, and on the way back to transform the MemberDetailsResponse object back to XML. This is where Springs Object/XML mapping support comes in. Spring Object/XML mapper provides a simple abstraction over the popular Java XML binding stacks like JAXB, Castor, JiBX, Xstream. In the current example, we will start by defining the binding file for JiBX:

01.xml version="1.0" encoding="UTF-8"?>

02.<binding>

03. <mapping name="MemberDetailsRequest"

04. class="org.bk.memberservice.message.MemberDetailsRequest">

05. <namespace prefix="ms" uri="http://bk.org/memberservice/" default="all"/>

06. <value name="id" field="id" />

07. mapping>

08.

09. <mapping name="MemberDetailsResponse"

10. class="org.bk.memberservice.message.MemberDetailsResponse">

11. <namespace prefix="ms" uri="http://bk.org/memberservice/" default="all"/>

12. <structure name="memberdetail" field="memberDetail"

13. class="org.bk.memberservice.types.MemberDetail">

14. <value name="name" field="name" />

15. <value name="city" field="city" />

16. <value name="phone" field="phone" />

17. <value name="state" field="state" />

18. structure>

19. mapping>

20.binding>

JiBX requires a compile step with the above binding file, this is very easily wired using Maven as the build tool.

Putting it together:

So now all the pieces are in place -

To direct the request to the appropriate endpoint, Spring-WS requires a custom servlet to be set up:

01.<servlet>

02. <servlet-name>memberserviceservlet-name>

03. <servlet-class>org.springframework.ws.transport.http.MessageDispatcherServletservlet-class>

04. <init-param>

05. <param-name>contextConfigLocationparam-name>

06. <param-value>classpath:/applicationContext-memberservice.xmlparam-value>

07. init-param>

08.servlet>

09.

10.<servlet-mapping>

11. <servlet-name>memberserviceservlet-name>

12. <url-pattern>/services/*url-pattern>

13.servlet-mapping>

This would direct all requests starting with serivces/* to be handled by Spring-WS.

The MessageDispatcherServlet would look for a Spring bean with id of “payloadMapping” to direct the incoming XML to an appropriate endpoint, for the example the bean entry is the following:

01.<bean id="payloadMapping"

02. class="org.springframework.ws.server.endpoint.mapping.PayloadRootQNameEndpointMapping">

03. <property name="endpointMap">

04. <map>

05. <entry key="{http://bk.org/memberservice/}MemberDetailsRequest"

06. value-ref="getMemberDetailsEndpoint" />

07. map>

08. property>

09.bean>

Essentially a request with MemberDetailsRequest as the element will be directed to getMemberDetailsEndpoint which is :

1. <bean id="getMemberDetailsEndpoint" class="org.bk.memberservice.endpoint.GetMemberDetailsEndpoint">

2. <property name="marshaller" ref="marshaller" />

3. <property name="unmarshaller" ref="unmarshaller" />

4. <property name="memberManager" ref="memberManager" />

5.bean>

The Endpoint needs the marshaller and unmarshaller to be injected to transform the request XML to request object and the response object to response XML. These are created as follows:

01. "marshaller" class="org.springframework.oxm.jibx.JibxMarshaller">

02. name="targetClass"

03. value="org.bk.memberservice.message.MemberDetailsResponse" />

04.

05.

06. "unmarshaller" class="org.springframework.oxm.jibx.JibxMarshaller">

07. name="targetClass"

08. value="org.bk.memberservice.message.MemberDetailsRequest" />

09.

Exposing the Webservice WSDL:

Since the WSDL was created from scratch, to expose this pre-canned wsdl requires a bit more configuration with Spring:

1.<bean id="MemberDetailsRequest"

2. class="org.springframework.ws.wsdl.wsdl11.SimpleWsdl11Definition">

3. <property name="wsdl" value="classpath:/memberservice.wsdl" />

4.bean>

Now, when the request comes in for the URI /memberservice/MemberDetailsRequest.wsdl, Spring-WS would serve out the static memberservice.wsdl.

This completes the Webservice implementation. It can be further enhanced to handle the Exception scenarios, Security etc which is an exercise for another day.

The complete example can be run using the attached maven enabled code, which will download all dependencies, and can be run using the following command:

mvn jetty:run

Conclusion:

Spring-WS provides a compelling way to create a webservice with a contract first approach. The amount of code appears extensive, however there is clean separation of the contract defined by the WSDL and the implementation, thus being able to change underlying implementation without affecting the contract.

Font configuration in Ubuntu Jaunty Jackalope

This is the font configuration that has worked extremely well for me in my Dell Inspiron laptop:

1. Font size of 9 across the board


2. Entries in ~/.fonts.conf file, based on the recommendations from the following post -
http://www.kilobitspersecond.com/2009/04/17/ubuntu-font-hinting-you-a-cautionary-tale/:

<fontconfig>
  <match target="font">
      <edit mode="assign" name="antialias">
          <bool>true</bool>
      </edit>
      <edit mode="assign" name="hinting">
          <bool>true</bool>
      </edit>
      <edit mode="assign" name="hintstyle">
          <const>hintslight</const>
      </edit>
      <edit mode="assign" name="lcdfilter">
          <const>lcdlegacy</const>
      </edit>
      <edit mode="assign" name="rgba">
          <const>none</const>
      </edit>
  </match>
</fontconfig>

3. The fonts within firefox looked extremely tiny at the end of this exercise. This was improved by installing Microsoft Core fonts :

sudo apt-get install msttcorefonts gsfonts-x11

Grails - Musings

I have long observed Grails passively, rejoiced that there is now a web framework in Java that does not require jumping through hoops to get a basic setup working. Free time has been a bit of a constraint through 2008, so I never got enough time to spend exploring Grails.

When I heard about the release of Grails 1.1 Beta 2, around Christmas time, I decided I had enough of a free time during the holidays to actually start learning Grails.

A good tutorial that I started following is a Grails Web Album tutorial by John Leach - It is a fairly complex application about creating an online photo album. I was easily able to follow the tutorial and at the end was amazed by how simple it was to create a working application. A great thing about the tutorial is that an equivalent Rails version is also available at John Leach's site, that allowed me to compare and contrast Rails with Grails. I am already fairly proficient in Rails, so one thing that stood out in Grails for me was that specifically for the Web Album application, all the image manipulation libraries were available right within Java, whereas the Rails version required using RMagick, which is fairly difficult to configure on a Windows XP box.

 

My conclusion is fairly simple - Both Grails and Rails are compelling Web frameworks, both have a fairly flat learning curve and the underlying languages(Groovy, Ruby) are delightful and fun to learn and use. I very much intend to continue exploring both Grails and Rails.