Franklin Garcia Tech

What we can learn from spaghetti sauce

noreply@blogger.com (fr4gus) — Fri, 05 Sep 2008 20:13:00 +0000

I found this talk, from Malcolm Gladwell very inspiring:

AlphaGrip Ergonomic Keyboard Review

noreply@blogger.com (fr4gus) — Tue, 02 Sep 2008 21:53:00 +0000

As PC Gamer and Coder, the consequencies of using a keyBOARD and MICE during all these years had finally appeared. My right wrist hurts after hours of been in front of my computer, and get worst, after hours and hours of playing video games (Mi name is Franklin and I'm WoWcoholic)

After using for months a wirst supporter, trying to mitigate the symptoms of my carpal tunnel syndrome, I realize that I had to attack the problem from its source.... the keyboard and the mice. So I stated a little research looking for the most ergonomic devices in the market. May be the causality (I know Morpheus... there is no such thing as fate) or the causality (hmmm may be the Merovingian was right), my brother send my this URL: http://www.alphagrips.com. Not sure why he did it... may be because I'm a compulsive shopper, but the thing is that I found what I was looking... actually more than what I was looking for.

I did some research on reviews and what the AlphaGrip has been doing, and when I felt confortable with the review I took the decision of trying one of those keyboards... eh gamepads... ehh keypads. The last week I received my AlphaGrip Keybard/Trackball, and after a week of using it I want to share with you my impressions.

At the first look, you can be impressed with how it looks. You can think its a gamepad and not a keyboard. With only 48 keys it can perform almost all the actions you could do with a standard 101 keys keyboard. It doesn't weight too much, so I was able to hold it all work day. It has a pause button in some how like a lock button, so no other keys will react if you press them, neither the trackball. I can guarantee this keyboard if fully ergonomic, my fingers fits on the keys without put my hands in any weird position.

Learning to type again is a little frustating, since I know I can type faster in a standard keyboard. But after using it for some days, I feel I'm getting faster and accurate when typing. This make me remember when I started to type in the a regular keyboard, and I think it took me longer with it.

But not everything is good with this keyboard... whell I like to name it keypad, since is not a "board". Holding the keypad requires to hold it with all your hand, so after using it for several minutes makes your hand sweat. Some of its keys are really sensitive, while others are a little hard to press. Also, when typing, you can press more than one key accidentally (just with the keys that should be managed with your thumbs), but nothing to be worried with more practice.

I was quite impressed with the trackball. This mice replacement is really comfortable and has really good response. I tried it with World of Warcraft and I feel I could play with it without problems. On day-by-day work, the trackball is very good, and requires less practice that I thought.

If you are looking for a ergonomic 2-in-1 keyboard and you have $100 burning in your pocket this is a good option.

I'll give my final score after two months of using, and see if I finally was able to use it.

SOSE 1.0 Beta 1 Released

noreply@blogger.com (fr4gus) — Wed, 30 Apr 2008 20:15:00 +0000

I'm happy to announce that SOSE has been released as Beta 1. This has been a personal project for 1 year. I developed this tool in my last job, for helping us process transactional information between legacy and our Java systems. Now I created this project at SourceForge.net.

Simple Object String Extractor (previously called Parsernate) is a tool for plain-text messages processing, that contains information that can be stored as property values in a Java class.

Let's see an example:

Where the first 4 characters represents an application ID, the next 15 characters the Firstname, the other 15 characters represents the Lastname, then 9 characters for a personal ID, other 9 characters for phone number and the lasta 20 characters for Job Title.

So typically, you could use the famous String.subString() method, and get all those values and set it in a Java object for application porpouses... but if you have to set more than one message type, the work makes more complicated. And this gets worst if you have to make updates on your code in order to handle message changes.

Now imagine you need to work with the ISO 8583 and parse several messages, well may be SOSE is for you.

When I did this library on the first time, I did a lot of type handling and I divided the property in three groups: Simple, Complex and Container properties. The Simple properties were Java primitives as class properties. Complex properties, refers to property class that are User-made classes. And the last one are Container properties, that can be List or Maps.

Since Java 5 release and above, I did a lot of changes on my code, so right now, and for this beta , I'm just handling simple and complex properties. I'll probably release a new one with this functionality soon. I also want to provide a documentation about how to use it and create a web page (at the first time hosted at SourceForge) for this.

SOSE is available at SourceForge: http://sourceforge.net/projects/sose/

Class and Generics

noreply@blogger.com (fr4gus) — Tue, 29 Apr 2008 15:00:00 +0000

Well, I was working in a Java library I'm developing and I found a little issue(may be lack of knowledge) using Class and Generics together. I'm not sure if could be a better solution, I hope to find it soon.

As you know, from Java 5 and above, the Class class now has a generic parameter, so now it is Class<T>. I have a method with the following contract:

Before Generics:

public Object getObject(String source);

With Generics:

public T getObject(String source);

Where the basic idea is convert the String into an Object. I don't know which kind of object is until Runtime, so I used to use the following code:


// Getting an instance of the object
Class classDefinition = Class.forName( className );
Object result = classDefinition.newInstance();

But now with generics I would like to use them and change my code to this:


// Getting an instance of the object
Class<T> classDefinition = Class.forName( className );
T result = classDefinition.newInstance();

receiving an error from the compiler, since Class<capture-of ?>

is not equals to Class

<T>

. So the only fast and not fancy solution is cast it (LOL so why generics??).


// Getting an instance of the object
Class<T> classDefinition = (Class<T>) Class.forName( className );
T result = classDefinition.newInstance();

My code works, but I would like to not use the down-casting. I'll be digging about this and update this post as soon I find the solution. Comments about this are welcome.

D-Day: The Spring Experience

noreply@blogger.com (fr4gus) — Thu, 13 Dec 2007 04:08:00 +0000

I'm really excited to be here in Hollywood, Florida, attending The Spring Experience Conference at the Westing Diplomat Hotel.

During the registration, we received our ID and also a gift set that has a back-pack, a binder, and a T-Shirt. At the end of the day we received also a Rob Johnson "bubble-head".

After a delicious dinner, Rod Johnson (the man behind Spring Framework) talked about what should we expect from this conference. He started to talk about how SpringSource is growing. He also remarked his vision of Spring as the best way instead JavaEE. I can agree with that sentence when talking about non-distributable web applications. I know that in so many ways, EJBs are ugly, but they have a nice side, they are distributable.

He also talked about the new products available in the Spring Portfolio:

Spring Security (one of the topic I'm interested to). Basically, the Spring Security 2.0 is meant to replace Acegi Security. One of the biggest changes is the configuration, now is shorter and easier.

Spring Web Service 1.0. Again, meant to do web services easy.

Spring IDE. Stand-alone / add-on for Eclipse to make Spring development smooth, offering also a graphical tool to configure Spring.

Rob also mentioned how software development companies are choosing Spring instead other solutions like JavaEE pointing that the community is the one in charge to decide what is the path to follow based on real requirements, instead of a "committee".

Looks like SpringSource (Interface21) is aiming the framework to become an Open Source integration tool for developers providing new growing technologies and adding new features based on what the community needs. A good example is Annotations that is being used to configure Spring, if you don't want to use the XML style.

I can't wait for tomorrow and attend so interesting presentations.

Setting up proxy for Android Emulator

noreply@blogger.com (fr4gus) — Tue, 20 Nov 2007 16:26:00 +0000

I think this information could be useful, is available at Android Group, but is difficult to find as messages there are growing, and the search could retrieve you a lot of messages related. So I want to paste here a message by Jason Chen that explains how to do it:

Here's how you can specify a proxy server for the Android browser.

1) Connect to the emulator using the "adb shell" command
2) Once you have a prompt, issue the following command:

sqlite3 /data/data/com.google.android.providers.settings/databases/
settings.db "INSERT INTO system
VALUES(99,'http_proxy',':');"

where and should be
replaced by the IP or hostname and port number, respectively, for the
proxy server you're using. (The command should be on one line.)

*Note*: you may need to restart the emulator for the change to be
recognized by the browser.

While in "adb shell", you can check to see if your proxy was added
correctly by issuing the following:

sqlite3 /data/data/com.google.android.providers.settings/databases/
settings.db "SELECT * FROM system"

If things worked correctly, you should see something like:

To remove the proxy setting, issue the following command via "adb
shell":

sqlite3 /data/data/com.google.android.providers.settings/databases/
settings.db "DELETE FROM system WHERE _id=99"

A first look of Android

noreply@blogger.com (fr4gus) — Fri, 16 Nov 2007 22:21:00 +0000

OpenAlliance recently released an “early look” edition of its Android platform. Android is a set of software for mobile devices: an operating system, middleware and mobile applications. Built on the open Linux kernel, it utilizes a custom virtual machine called Dalvik. OpenAlliance hasn’t yet released the SDK code, but promises to “open it” in the future. The SDK provides a phone emulator, debugging tools and sample code.

Read More

Mocking ACEGI security users

noreply@blogger.com (fr4gus) — Mon, 12 Nov 2007 16:41:00 +0000

In one of my projects I had to test some features, using JUnit and JMock. The features that I had to test were based on roles assigned to an already logged user. I realized that I have to populate the SecurityContextHolder with some dummy user data to be able to test. Based on ACEGI Security source code of some tests I could find a solution for that (actually is the test case for BasicProcessingFilter class).

This is the code:


public class MyAcegiTest{

 Mockery context = new Mockery();
 private BasicProcessingFilter filter = new BasicProcessingFilter();

 @Before
 public void init() throws Exception{
   // Cleaning any previous information on SecurityContextHolder
   SecurityContextHolder.clearContext()
 
   // Using in-memory DAO
   InMemoryDaoImpl dao = new InMemoryDaoImpl();  
   UserMapEditor editor = new UserMapEditor();
 
   // the user jsmith will have two roles, Manager and User, you can use whatever you need here.
   editor.setAsText("jsmith=jsmith,ROLE_MANAGER,ROLE_USER,enabled\r\n");
   dao.setUserMap((UserMap)editor.getValue());
   DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
   provider.setUserDetailsService(dao);

   ProviderManager manager = new ProviderManager();
   manager.setProviders(Arrays.asList(new Object[] {
     provider
   }));
   // The mock for ApplicationEventPublisher is at the end of this class
   manager.setApplicationEventPublisher(new MockApplicationEventPublisher());
   manager.afterPropertiesSet();
 
   // Setting up the filter
   filter.setAuthenticationManager(manager);
   filter.setAuthenticationEntryPoint(new BasicProcessingFilterEntryPoint());
 
 }

 @Test
 public void mytest() throws Exception{
   // The token represents as if the user has used a basic authentication form to log in.
   String token = "jsmith:jsmith";
 
   //Creating a mock request
   MockHttpServletRequest request = new MockHttpServletRequest();
 
   // Filling the request with the necesary headers and properties
   request.addHeader("Authorization", "Basic " + new String(Base64.encodeBase64(token.getBytes())));
   request.setServletPath("/test.do");
   request.setMethod("POST");
   request.setSession(new MockHttpSession());

   //Here is where the magic is done. Checks the login information (on Authorization header)
   //and populates the SecurityContextHolder with the user information creating the Authentication object
   //, so you can use SecurityContextHolder.getContext().getAuthentication() after this line
   filter.doFilter(request, response, new MockFilterChain());
 
 
 
 }

 private class MockApplicationEventPublisher implements ApplicationEventPublisher{

   public MockApplicationEventPublisher(){}

   public void publishEvent(ApplicationEvent event){}

 }

}

How to use: JSON-RPC for Java

noreply@blogger.com (fr4gus) — Fri, 08 Jun 2007 15:30:00 +0000

Why write about this?

Basically you can find all the information needed on JSON-RPC official site (http://oss.metaparadigm.com/jsonrpc/). But when I started to use the tutorial I realized that there is more information needed if you are a newbie using remoting technology. I'm not saying tutorial is not complete, If you follow the tutorial you will get the results expected, but you aren't going to understand what really happen and what you can modify to fit you project requirements. Actually I'll probably write more of these "how-to's" when I start to mix frameworks, API's etc; mixes that you probably will find in real world projects. So this little explanation about how to use JSON-RPC is the official tutorial but I'm adding what I'm think should be explained too and is not present in the original.

What is JSON-RPC for Java

JSON-RPC-Java is a key piece of Java web application middleware that allows JavaScript DHTML web applications to call remote methods in a Java Application Server without the need for page reloading (now referred to as AJAX). It enables a new breed of fast and highly dynamic enterprise Web 2.0 applications (using similar techniques to Gmail and Google Suggests).

From: http://oss.metaparadigm.com/jsonrpc/

Requirements

* ant 1.6 or later (to build)

* A Java Servlet container (such Apache Tomcat, the Tomcat service in JBoss, etc.).

Setup you environment:

* You will need to have configured Java Development Kit and your Servlet container

* Download JSON-RPC-Java at http://oss.metaparadigm.com/jsonrpc/download.html. The zip file will contain the JAR Library that will be part of your app library and a javascript file needed in your client side files.

Configuring web.xml

You need to configure the JSON-RPC servlet that will handle all the request from the client side. You just should add the following configuration into your web.xml

    
  <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
  "http://java.sun.com/dtd/web-app_2_3.dtd">
  <web-app>
     <servlet>
         <servlet-name>com.metaparadigm.jsonrpc.JSONRPCServlet</servlet-name>
         <servlet-class>com.metaparadigm.jsonrpc.JSONRPCServlet</servlet-class>
     </servlet>
     <servlet-mapping>
         <servlet-name>com.metaparadigm.jsonrpc.JSONRPCServlet</servlet-name>
         <url-pattern>/JSON-RPC</url-pattern>
     </servlet-mapping>
  </web-app>

Registering your services.

When we talk about services we are talking about Java Object. Any object with public methods are candidate to be a service. In a multi-tier application the service layer will have the objects that we want to expose to the presentation layer.

For this tut, we are going create a POJO called test.jsonrpc.TestService (OMG what a original name!!!). This service will return a string with server date and will receive the format you need that date.


package test.jsonrpc;

   public class TestService{
     public String getHello(){
        return "Hello friend!";
     }
      public String getRandomValue(int seed){
        Integer value = Integer.valueOf( (int)( Math.random() * (double) seed) );
        return value.toString();
     }
   }

In order to expose your services using JSON-RPC, you need to register them in somewhere. There are two ways to register your objects (as you will see at the end is the same ;) ).

In both case, you are going to use the JSONRPCBridge. The JSONRPCBridge holds references to exported objects and decodes and dispatches method calls to them. This means: if you need a object service (register or invoke) JSONRPCBridge is the man.

Registering objects via JSP:

Get a reference of JSONRPCBridge

...
  <jsp:useBean id="JSONRPCBridge" scope="session"
  class="com.metaparadigm.jsonrpc.JSONRPCBridge" />
  ...

Get a reference of the object you want to register

...
  <jsp:useBean id="testService" scope="session"
   class="test.jsonrpc.TestService" />
...

Registerint the object. The first parameter is the id what you want to register and the second parameter is the:

 ...
  <% JSONRPCBridge.registerObject("testService", testService); %>
...

Registering via Servlet

Basically is the same thing, except you have to use pure java code:

  
   ...
   // Find the JSONRPCBridge for this session or create one
   // if it doesn't exist. Note the bridge must be named "JSONRPCBridge"
   // in the HttpSession for the JSONRPCServlet to find it.
   HttpSession session = request.getSession();
   JSONRPCBridge json_bridge = null;
   json_bridge = (JSONRPCBridge) session.getAttribute("JSONRPCBridge");
   if(json_bridge == null) {
     json_bridge = new JSONRPCBridge();
     session.setAttribute("JSONRPCBridge", json_bridge);
   }
   ...
   json_bridge.registerObject("testService", new test.jsonrpc.TestService() );
   ...

For this tutorial we are going to use the JSP version for registering java objects.

Using your service on JavaScript:

Now that you have your service exposed through JSON-RPC is time to use it on a web page. We need to add the following code

on your web page.

 <script type="text/javascript" src="jsonrpc.js">

With the JSON-RPC distribution file, there is a javascript file called jsonrpc.js. You need to add it to your web project. In the above code, we are assuming the javascript file is at the same folder than the web page.

In order to invoke you service you need a JSON-RPC client on your JavaScript code. You get it creating a new JSONRpcClient.

 jsonrpc = new JSONRpcClient("JSON-RPC");

The following code creates two functions and creates a JSONRpcClient reference when the pages is loading.

 <script type="text/javascript" >
  function onLoad()
  {
    jsonrpc = new JSONRpcClient("JSON-RPC");
  }
 
  function test1()
  {
    var text1 = document.getElementById("text");
    var result = jsonrpc.testService.getHello();
    alert("The server replied: " + result);
    text1.value = result;
  }
 
  function test2()
  {
    var text2 = document.getElementById("text2");
    var result = jsonrpc.testService.getRandomValue(5);
    alert("The server replied: " + result);
    text2.value = result;
  }
 
</script>

When you want to invoke a service method you should use the following sentence:

jsonrpc.<registered name>.<methodname>( <parameters if apply> );

In our example, the methods test1 and test2 use the jsonrpc

 var result = jsonrpc.testService.getHello();
var result = jsonrpc.testService.getRandomValue(5);

JSON-RPC is really easy to use for a project:

You just need to add the necesary libraries on your WEB-INF/lib folder

Configure the JSON-RPC Servlet on web.xml

Add the jsonrcp.js javascript file

Create a JSONRpcClient on JSP you want to invoke your service

Use JSONRpcClient reference to invoke it.

How to use: Hibernate 3

noreply@blogger.com (fr4gus) — Mon, 28 May 2007 22:26:00 +0000

What it's Hibernate

Hibernate is an object/relational mapping tool for Java environments. The term object/relational mapping (ORM) refers to the technique of mapping a data representation from an object model to a relational data model with a SQL-based schema.

Requirements

Download and unpack the Hibernate distribution from the Hibernate website.
Make sure you have JDK 5.0 installed.

Set up your environment

Set up your classpath:

Copy all Hibernate3 core and required 3rd party library files (see lib/README.txt in Hibernate distribution folder).

A simple mapping

Suppose we want to persist the following JavaBean class:

package events;
import java.util.Date;

public class Event {
private Long id;
private String title;
private Date date;
public Event() {}

public Long getId() {
   return id;
}
private void setId(Long id) {
   this.id = id;
}
public Date getDate() {
   return date;
}
public void setDate(Date date) {
   this.date = date;
}
public String getTitle() {
   return title;
}
public void setTitle(String title) {
   this.title = title;
}
}

The basis structure of a mapping file looks like this:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
   "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>

[...]
</hibernate-mapping>

Between the two hibernate-mapping tags, include a class element:

<hibernate-mapping>
<class name="events.Event" table="EVENTS">
  ...
</class>

</hibernate-mapping>

Now, we must map the primary key and the rest of the properties (this will be event.hbm.xml file):

<hibernate-mapping>
<class name="events.Event" table="EVENTS">
    <id name="id" column="EVENT_ID">
        <generator class="identity"/>
    </id>

    <property name="date" type="timestamp" column="EVENT_DATE"/>
    <property name="title" type="string" column="TITLE"/>
</class>
</hibernate-mapping>

With the <id>tag, you map the object property with the table primary key. The <generator> tag, define the generation strategy for that primary key and must match with the defined in the table. The generator class can be: identity, sequence, assigned as the common choices. For other generator class please refer to the hibernate documentation.

The <property> tag define the rest of columns mapped with the respectively object attribute.

When a key is composite, we must use the <composite-id> tag as the following example, where a person in an event can have a position in a room:

package events;

public class SeatPosition {
private SeatPositionPK id;
// properties
private int color;
// Accessor methods for all properties, private setter for 'id'
}

The definition of the primary key class:

package events;


public class SeatPositionPK {
// composite key properties
private int room;
private int seat;

// Accessor methods for all properties
}

The mapping file will looks like:

<hibernate-mapping>
<class name="events.SeatPosition" table="SEAT_POSITION">
    <composite-id name="id" type="events.SeatPositionPK" column="id">
        <key-property name="room" column="ROOM" type="integer"/>

        <key-property name="seat" column="SEAT" type="integer"/>
    </composite-id>
    <property name="color" type="integer"/>
</class>
</hibernate-mapping>

Maping Associations

A database will have more than "simple" tables and you will need map different kinds of relationship between tables.

Many-To-Many

Given the following class definition

package events;

public class Person {
private Long id;
private int age;
private String firstname;
private String lastname;

public Person() {}


// Accessor methods for all properties, private setter for 'id'
}

And the following given mapping file (for person, Person.hbm.xml):

<hibernate-mapping>
<class name="events.Person" table="PERSON">
    <id name="id" column="PERSON_ID">
        <generator class="identity"/>
    </id>

    <property name="age"/>
    <property name="firstname"/>
    <property name="lastname"/>
</class>
</hibernate-mapping>

Suppose that a person can participate in one or more events, so we must add a collection that contains Event objects in a Person instance.

public class Person {
// Properties definition
...

private Set events = new HashSet();

public Set getEvents() {
    return events;
}
public void setEvents(Set events) {
    this.events = events;
}
}

And the mapping file change like this:

<hibernate-mapping>
<class name="events.Person" table="PERSON">
    <id name="id" column="PERSON_ID">

        <generator class="identity"/>
    </id>
    <property name="age"/>
    <property name="firstname"/>
    <property name="lastname"/>

<set name="events" table="PERSON_EVENT">

    <key column="PERSON_ID"/>
    <many-to-many column="EVENT_ID" class="events.Event"/>
</set>
</class>
</hibernate-mapping>

We have mapped the database schema:

    _____________        __________________
|             |      |                  |       _____________
|   EVENTS    |      |   PERSON_EVENT   |      |             |
|_____________|      |__________________|      |    PERSON   |
|             |      |                  |      |_____________|
| *EVENT_ID   | <--> | *EVENT_ID        |      |             |
|  EVENT_DATE |      | *PERSON_ID       | <--> | *PERSON_ID  |
|  TITLE      |      |__________________|      |  AGE        |
|_____________|                                |  FIRSTNAME  |
                                              |  LASTNAME   |
                                              |_____________|

If you want to do a bidirectional relationship, where from a event you can get the event participants. First, add a collection of participants to the Event Event class:

private Set<Person> participants = new HashSet<Person>();
public Set<Person> getParticipants() {
return participants;
}


public void setParticipants(Set<Person> participants) {
this.participants = participants;
}

Now map this side of the association too, in Event.hbm.xml.

<set name="participants" table="PERSON_EVENT" inverse="true">
<key column="EVENT_ID"/>
<many-to-many column="PERSON_ID" class="events.Person"/>
</set>

One-To-Many

If a person can have one or more email addresses:

private Set<String> emailAddresses = new HashSet();
public Set<String> getEmailAddresses() {
return emailAddresses;
}


public void setEmailAddresses(Set<String> emailAddresses) {
this.emailAddresses = emailAddresses;
}

The mapping of this Set:

<set name="emailAddresses" table="PERSON_EMAIL">
<key column="PERSON_ID"/>
<element type="string" column="EMAIL_ADDR"/>
</set>

Look at the updated schema:

  _____________        __________________
|             |      |                  |       _____________
|   EVENTS    |      |   PERSON_EVENT   |      |             |       ______________
|_____________|      |__________________|      |    PERSON   |      |              |
|             |      |                  |      |_____________|      | PERSON_EMAIL |
| *EVENT_ID   | <--> | *EVENT_ID        |      |             |      |______________|
|  EVENT_DATE |      | *PERSON_ID       | <--> | *PERSON_ID  | <--> |  *PERSON_ID  |
|  TITLE      |      |__________________|      |  AGE        |      |  *EMAIL_ADDR |
|_____________|                                |  FIRSTNAME  |      |______________|
                                            |  LASTNAME   |
                                            |_____________|

One-To-One

Suppose you want to know who the owner of a specific vehicle is:

public class Vehicle {
private String id;
private String model;
private String brand;
private int year;
private Person owner;

public Vehicle(){}
// Accessor methods for all properties, private setter for 'id'
}

The mapping file (Vehicle.hbm.xml) will be like:

<hibernate-mapping>
<class name="events.Vehicle" table="VEHICLE">
    <id name="id" column="VEHICLE_ID">

        <generator class="identity"/>
    </id>
    <property name="brand"/>
    <property name="year"/>
    <property name="model"/>

<one-to-one name="owner" class="Person" constrained="true"/>

</class>
</hibernate-mapping>

Configuring Hibernate

After known how to map JavaBeans with database tables its time to make this mapping works. First than all, we must specify how Hibernate will connect to the database. The principal configuration file is hibernate.cfg.xml, and this is an example:

<?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="connection.driver_class">org.hsqldb.jdbcDriver</property>
    <property name="connection.url">jdbc:hsqldb:hsql://localhost</property>
    <property name="connection.username">sa</property>

    <property name="connection.password"></property>

    <property name="connection.pool_size">1</property>

    <property name="dialect">org.hibernate.dialect.HSQLDialect</property>

    <property name="current_session_context_class">thread</property>

    <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>

    <property name="show_sql">true</property>

    <property name="hbm2ddl.auto">create</property>

    <mapping resource="events/Event.hbm.xml"/>
    <mapping resource="events/Person.hbm.xml"/>
    <mapping resource="events/SeatPosition.hbm.xml"/>

</session-factory>

</hibernate-configuration>

It's time to load and store some objects, but first we have to complete the setup with some infrastructure code. We have to startup Hibernate. This startup includes building a global SessionFactory object and to store it somewhere for easy access in application code. A SessionFactory can open up new Session's. A Session represents a single-threaded unit of work, the SessionFactory is a thread-safe global object, instantiated once.

We'll create a HibernateUtil helper class which takes care of startup and makes accessing a SessionFactory convenient. Let's have a look at the implementation:

package util;
import org.hibernate.*;
import org.hibernate.cfg.*;

public class HibernateUtil {

private static final SessionFactory sessionFactory;

static {
    try {
        // Create the SessionFactory from hibernate.cfg.xml
        sessionFactory = new Configuration().configure().buildSessionFactory();
    } catch (Throwable ex) {
        // Make sure you log the exception, as it might be swallowed
        System.err.println("Initial SessionFactory creation failed." + ex);
        throw new ExceptionInInitializerError(ex);
    }
}
public static SessionFactory getSessionFactory() {
    return sessionFactory;
}

}

The hibernate configuration file (hibernate.cfg.xml) must be in the root of the application classpath. Every mapping file must be with its respective class. This is an example of application structure for the whole example that we have been working on:

+ lib
<Hibernate and third-party libraries>

+scr
hibernate.cfg.xml
+events
      Event.java
      Event.hbm.xml
      Person.java
      Person.hbm.xml
      SeatPosition.java
+classes    // it’s a copy of src, but with binary files (except xml of course)
hibernate.cfg.xml
+events
      Event.class
      Event.hbm.xml
      Person.class
      Person.hbm.xml
      SeatPosition.class

Loanding and storing object

Now, the following example show how to use the session object. Remember that on N-Layer Application the persistence layer will use the services of sessionFactory and session objects.

package events;
import org.hibernate.Session;

import java.util.Date;
import util.HibernateUtil;

public class EventManager {

public static void main(String[] args) {
    EventManager mgr = new EventManager();

    if (args[0].equals("store")) {
        mgr.createAndStoreEvent("My Event", new Date());
    }

    HibernateUtil.getSessionFactory().close();
}

private void createAndStoreEvent(String title, Date theDate) {
    Session session = HibernateUtil.getSessionFactory().getCurrentSession();          
    session.beginTransaction();

    Event theEvent = new Event();
    theEvent.setTitle(title);
    theEvent.setDate(theDate);

    session.save(theEvent);

    session.getTransaction().commit();
}


}

Querying

Another important functionality that hibernate provide, beside persist objects, it’s the querying capabilities. Hibernate provide a cross-platform language, very similar than SQL named Hibernate Query Language (HQL). For programmatic query creation, Hibernate supports a sophisticated Criteria and Example query feature (QBC and QBE). You may also express your query in the native SQL of your database, with optional support from Hibernate for result set conversion into objects.

Executing Queries

HQL and native SQL queries are represented with an instance of org.hibernate.Query. This interface offers methods for parameter binding, result set handling, and for the execution of the actual query. You always obtain a Query using the current Session:

List cats = session.createQuery(
"from Cat as cat where cat.birthdate < ?")
.setDate(0, date)
.list();

List mothers = session.createQuery(
"select mother from Cat as cat join cat.mother as mother where cat.name = ?")
.setString(0, name)
.list();

List kittens = session.createQuery(
"from Cat as cat where cat.mother = ?")
.setEntity(0, pk)
.list();

Cat mother = (Cat) session.createQuery(
"select cat.mother from Cat as cat where cat = ?")
.setEntity(0, izi)
.uniqueResult();]]

Query mothersWithKittens = (Cat) session.createQuery(
"select mother from Cat as mother left join fetch
other.kittens");
Set uniqueMothers = new HashSet(mothersWithKittens.list());

Bind Parameters

Methods on Query are provided for binding values to named parameters or JDBC-style ? parameters. Contrary to JDBC, Hibernate numbers parameters from zero. Named parameters are identifiers of the form :name in the query string. The advantages of named parameters are:

named parameters are insensitive to the order they occur in the query string
they may occur multiple times in the same query
they are self-documenting

//named parameter (preferred)
Query q = sess.createQuery("from DomesticCat cat where cat.name = :name");
q.setString("name", "Fritz");
Iterator cats = q.iterate();

//positional parameter
Query q = sess.createQuery("from DomesticCat cat where cat.name = ?");
q.setString(0, "Izi");
Iterator cats = q.iterate();

//named parameter list
List names = new ArrayList();
names.add("Izi");
names.add("Fritz");
Query q = sess.createQuery("from DomesticCat cat where cat.name in (:namesList)");
q.setParameterList("namesList", names);
List cats = q.list();

Summary

Hibenate it’s a object/relational mapping tool, for object persisting and querying.
The mapping from an object to a table is defined in a xml file, usually one file per class.
The hibernate configuration is keeped in hibernate.cfg.xml file.
<class> tag defines which object will map an table.
<id> tag defines which object property will map the table primary-key.
<property> tag defines all non-primary-key attributes of the object.
<composite-id> is used, when the table that will be mapped, have a composite primary key. To use this tag, you must define a helper class that wraps all the attributes that compound the primary key.
<many-to-many> tag defines a collection that will hold the 1-n relationship from one direction in a N-M relationship between tables. For a bidirectional link, you must define a many-to-many tag in the other class.
<one-to-many> tag defines a collections that will hold the 1-n relationship between two tables.
<one-to-one> tag defines a object that will hold the link for a 1-1 relationship between two tables.
For specific queries, you can use the createQuery service from session object, and obtain an org.hibernate.Query object. Its recommended use the HQL, but its possible use native SQL.

External Links

Parts of this HOW-TO had been extracted from: http://www.hibernate.org/hib_docs/v3/reference/en/html/index.html

Hibernate composite keys with XDoclet

noreply@blogger.com (fr4gus) — Tue, 15 May 2007 15:30:00 +0000

The XDoclet documentation is not cleaver about composite keys. It only shows which annotation must be used (composite-id), but doesn't show where the "key-property" annotation must be placed. After several test I could realize that you should put the key-property in the class that will be used as composite key.


/**
* @hibernate.class table="parent"
*/
public class Parent{
private ParentId id;
private String name;
public void setId(Parent Id){..}
/**
* @hiberante.composite-id
*/
public ParentId getId(){...}
public void setName(String name){...}
/**
* @hibernate.property column="name" type="string"
*/
public String getName(){...}
}
public class ParentId{
private Integer personId;
private Integer code;
public void setPersonId(Integer p){...}
/**
* @hibernate.key-property column="person_id" type="integer"
*/
public Integer getPersonId(){...}
public void setCode(Integer c){...}
/**
* @hibernate.key-property column="code" type="integer"
*/
public Integer getCode(){...}
}

A second blog?

noreply@blogger.com (fr4gus) — Tue, 08 May 2007 19:51:00 +0000

Yes, I know, could be a little weird to have two blogs, but, I have two identities, one here... in the real world, the other one in the cyber world.

I just want to share my experiences developing (right now in Java) software, what obstacles I found and how I solved them. Post relevant information about PC's and general development.

I'll "migrate" some posts that I have in my Windows Live Blog (Live Spaces), to start sharing :).

If you want to see my "dark" side (when you get the another blog you will understand) just click here.

Franklin Garcia