twit88.com » design pattern

Java: Refactoring Methods

admin — Wed, 05 Nov 2008 16:55:25 +0000

Here are the guidelines that we follow to refactor the methods in one of the legacy Java application, simplified from Martin Fowler refactoring book.

Rename a method to server its purpose
Add a parameter to the method if it is required
Remove a parameter if it is not required
Separate query from modifier and let each method does it own function
Parametize method to consolidate different methods into one
Replace parameter with method so that your don’t use parameter to determine the execution
Preserve whole object to pass it as parameter
Replace a parameter with a method
Introduce parameter object to group parameters together
Remove setter method if it is not used
Hide the method if it is not used
Replace constructor with factory method
Encapsulate downcast. Now with JDK 5 and above we can make use of generic features
Replace error code with exception.
Replace exception with tests.

Free .NET Enterprise Books

admin — Wed, 08 Oct 2008 02:23:14 +0000

.NET Enterprise Solutions … Software Engineers on their way to Pluto

.NET Enterprise Solutions … Best Practices for the Connoisseur

.NET Enterprise Solutions … Interoperability for the Connoisseur

Downloadable here

Java: Refactor Code by Introducing NULL Object

admin — Sun, 05 Oct 2008 16:37:30 +0000

This is from the Refactoring book by Martin Fowler.

In our code we always need to check if a object is null, and depending on it, different actions are taken.

E.g. for the following code

if (subscriber == null) {
      ratePlan = defaultRatePlan;
} else {
        ratePlan = subscriber.getRatePlan();
}

The rationale is that if in our code we always need to check for NULL value for an object, it is good that we create a NULL object for the value object.

For the above code example, I can create a NullSubscriber object in this case.

  
public class NullSubscriber extends Subscriber {
  
    …
  
    public boolean isNull() {
        return true;
    }
  
    public RatePlan getRatePlan(){
        return defaultRatePlan;
    }
}

The NULL object extends Subscriber and implements the isNull method. Subscriber class also implements the isNull method and a static factory method to create the NULL object.

   1: public class Subscriber {

   2:     private RatePlan ratePlan;

3:

   4:     protected Subscriber() {

5:

   6:     }

   7:     public RatePlan getRatePlan() {

   8:         return ratePlan;

   9:     }

10:

  11:     public void setRatePlan(RatePlan ratePlan) {

  12:         this.ratePlan = ratePlan;

  13:     }

14:

  15:     public boolean isNull() {

  16:         return false;

  17:     }

18:

  19:     static Subscriber newNull() {

  20:         return new NullSubscriber();

  21:     }

22:

  23: }

In the class that return Subscriber object, I need to modify it to return the NULL subscriber if the object is null

public Subscriber getSubscriber() {
    if (subscriber == null) return Subscriber.newNull();
    return subscriber;
}

As you can see, the behavior is now moved to the NULL object. So the checking for null can now be removed.

if (subscriber == null) {
    ratePlan = defaultRatePlan;
} else {
   ratePlan = subscriber.getRatePlan();
}
  
// For the above can be simplified to
ratePlan = subscriber.getRatePlan();

Now I can assign the rate plan directly.

Java: Create Immutable Object using Builder Pattern

admin — Sun, 31 Aug 2008 15:34:31 +0000

To create immutable Java object, we should use the Builder Pattern, as described in Effective Java. This is the pattern I normally used now for immutable class.

public class Person {
    private final String name;
    private final int age;
    private final String email;
    private final String mobileNo;
  
  
    public String getName() {
        return name;
    }
  
    public int getAge() {
        return age;
    }
  
    public String getEmail() {
        return email;
    }
  
    public String getMobileNo() {
        return mobileNo;
    }
  
    public static class Builder {
        // Mandatory
        private final String name;
        private final int age;
  
        // Optional
        private String email;
        private String mobileNo;
  
  
        public Builder(String name, int age) {
            this.name = name;
            this.age = age;
        }
  
        public Builder email(String email) {
            this.email = email;
            return this;
        }
  
        public Builder mobileNo(String mobileNo) {
            this.mobileNo = mobileNo;
            return this;
        }
  
        public Person build(){
            return new Person(this);
        }
    }
  
    private Person(Builder builder){
        name = builder.name;
        age = builder.age;
        email = builder.email;
        mobileNo = builder.mobileNo;
    }
  
  
    public static void main(String[] args){
        Person person = new Person.Builder(“jason”,28).email(“jason@hotmail.com”).mobileNo(“1234567890″).build();
  
        System.out.println(person.getName());
        System.out.println(person.getAge());
        System.out.println(person.getEmail());
        System.out.println(person.getMobileNo());
    }
}

Person class constructor is declared as private
Person class properties cannot be set directly.
A Builder is used to create the Person instance
Mandatory properties are part of the Builder constructor arguments
Fluent interface is used in the Builder class

Design of a Java Application Framework Part 2 - DAO Layer using Hibernate

admin — Tue, 05 Aug 2008 16:28:14 +0000

This is the sequel of my previous post on the AppFuse source code, a good MVC framework. Thanks to Matt Raible and the team for this wonderful framework.

By reading the code, I can understand the framework better in order to use it correctly.

For AppFuse, for the data access layer you can use Hibernate, iBATIS or JPA. Here I am going through the Hibernate code.

All the DAO interface shall implement the GenericDao interface.

 
/**
 * Generic DAO (Data Access Object) with common methods to CRUD POJOs.
 *
 * Extend this interface if you want typesafe (no casting necessary) DAO’s for your
 * domain objects.
 *
 * @param  a type variable
 * @param  the primary key for that type
 */
public interface GenericDao  {
 
    /**
     * Generic method used to get all objects of a particular type. This
     * is the same as lookup up all rows in a table.
     * @return List of populated objects
     */
    List getAll();
 
    /**
     * Generic method to get an object based on class and identifier. An
     * ObjectRetrievalFailureException Runtime Exception is thrown if
     * nothing is found.
     *
     * @param id the identifier (primary key) of the object to get
     * @return a populated object
     * @see org.springframework.orm.ObjectRetrievalFailureException
     */
    T get(PK id);
 
    /**
     * Checks for existence of an object of type T using the id arg.
     * @param id the id of the entity
     * @return - true if it exists, false if it doesn’t
     */
    boolean exists(PK id);
 
    /**
     * Generic method to save an object - handles both update and insert.
     * @param object the object to save
     * @return the persisted object
     */
    T save(T object);
 
    /**
     * Generic method to delete an object based on class and id
     * @param id the identifier (primary key) of the object to remove
     */
    void remove(PK id);
    
    /**
     * Gets all records without duplicates.
     * Note that if you use this method, it is imperative that your model
     * classes correctly implement the hashcode/equals methods
     * @return List of populated objects
     */
    List getAllDistinct();
    
 
    /**
     * Find a list of records by using a named query
     * @param queryName query name of the named query
     * @param queryParams a map of the query names and the values
     * @return a list of the records found
     */
    List findByNamedQuery(String queryName, Map queryParams);
}

In this interface, common CRUD methods are defined. The interface accepts 2 parameters, which is the type variable and the PK for that type.

And GenericDaoHibernate class implements GenericDao interface

(more…)

Design of a Java Application Framework Part 1 - Model Layer

admin — Sun, 03 Aug 2008 16:42:06 +0000

I have been using AppFuse in several projects. It is a excellent framework which implemented a proper MVC architecture.

In order to better understand the framework, I spent sometime browsing through the source code.

In Part I of this articles I am going to show you the model layer.

For all the model classes in AppFuse, it has to extends BaseObject, which has the abstract methods toString, equals and hashCode. Note that BaseObject implements Serializable

 
/**
 * Base class for Model objects. Child objects should implement toString(),
 * equals() and hashCode().
 */
public abstract class BaseObject implements Serializable {    
 
    /**
     * Returns a multi-line String with key=value pairs.
     * @return a String representation of this class.
     */
    public abstract String toString();
 
    /**
     * Compares object equality. When using Hibernate, the primary key should
     * not be a part of this comparison.
     * @param o object to compare to
     * @return true/false based on equality tests
     */
    public abstract boolean equals(Object o);
 
    /**
     * When you override equals, you should override hashCode. See “Why are
     * equals() and hashCode() importation” for more information:
     * http://www.hibernate.org/109.html
     * @return hashCode
     */
    public abstract int hashCode();
}

All model classes shall extends BaseObject and have Java annotation to include additional information on the class and the properties relating to database.

E.g. for User model class

(more…)