The developer squad :: Full resources for software architects and developers

Free Source Code Management Hosting With SVN

2010-07-07T11:29:00.000-07:00

A common task to accomplish in order to manage a software project and its source code, release cycle, features, bugs and team work in a proper way is to have a source code management system (SCM) such as those based on GIT, CVS or Subversion (SVN). Sometimes the project must start very quickly and there is not enough time to install and configure a SCM by yourself, so you have several alternatives in the web, some of them are for free and for some others you have to pay accordingly to the size of the project, team members or features available. We have found an alternative that can match the features that you are looking for small projects that have to start right away, it's called Unfuddle, we are using it for a small startup company and it have worked like a charm. You can try it out at www.unfuddle.com

How to use PHP CLI in windows?

2010-07-03T02:22:00.000-07:00

PHP Cli allows you to execute PHP scripts in a system shell and enables you to interact with it sending parameter values. An example of its usage is Bake (from CakePHP), with it you can create web applications with Model View Controller pattern in a snap only with a database you defined before. The only thing you would need to do in a XAMPP installation is to add the absolute path to the PHP installation to the PATH environment variable through My Computer->Properties->Advanced Settings->Environment variables. My PATH environment variable looks like:

C:\Sun\SDK\bin;C:\Program Files\Nmap\;C:\spring-roo-1.0.0.RELEASE\bin;%MAVEN_HOME%\bin;%MYSQL_HOME%\bin;%CATALINA_HOME%\bin;%ANT_HOME%\bin;C:\xampp\php

How to create a generic Dao with Hibernate and Spring Framework

2010-07-01T17:35:00.000-07:00

When you are designing web applications a common problem to solve is the DAO (Data Access Object) layer. The simpler way to implement a DAO layer with Hibernate in seconds is to use some of the classes that are provided with Hibernate such as HibernateTemplate. HibernateTemplate class simplifies the data access operations when using Hibernate and provides an easy way to handle Hibernate Session objects .The following diagram shows in UML what is the rationale behind this implementation.

Image 1. UML diagram for a generic DAO.

The solution proposed in this article is based on Spring Framework 2.5 and Hibernate 3.2.x. Let's begin with a business model class called Person, its objects (instances) are going to be used and obtained from a database like Oracle, MSSQL, or whatever JDBC compliant database
.

Listing 1. Java Implementation of the business model class.

public class Person {
      private Long id;
      private String name;
      private int age;
      public Person() {
      }
      public void setAge(final int age) {
            this.age = age;
      }
      public void setId(final Long id) {
            this.id = id;
      }
      public void setName(final String name) {
            this.name = name;
      }
      public int getAge() {
            return age;
      }
      public Long getId() {
            return id;
      }
      public String getName() {
            return name;
      }
}

Listing 2. Hibernate XML Mapping.





<?xml version="1.0" encoding="ISO-8859-1"?>
DOCTYPE hibernate-mapping
PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping default-access="field" default-cascade="save-update">
    <class name="Person" table="Person">
        <id column="ID" name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <property name="age"/>
    </class>
</hibernate-mapping>

Next, we have to define the GenericDao interface where we are going to declare CRUD (Create, Retrieve, Update and Delete) operations. This interface is declared with one Generic Type, that is a template for the Business Model class (for example a Person class).

Listing 3. Generic DAO Interface.

public interface GenericDao {
     public void save(T entity);
     public void delete(T entity);
     public void update(T entity);
     public T findById(Serializable id);
     public List findAll();
     public void deleteById(Serializable id);
     public int count();
     public List findByExample(T exampleObject);
}

After doing this, you will need to implement this GenericDao interface in order to bring the specific HibernateGenericDAO implementation of the CRUD methods. We extend HibernateDaoSupport because it provides some useful functions such as a exception translation hierarchy, and we declare HibernateGenericDAO as abstract because we are not interested in creating instances of this class (we are interested in creating specific business model classes DAO instances).

Listing 4. GenericDAO implementation in Hibernate.

public abstract class HibernateGenericDAO extends HibernateDaoSupport implements GenericDao {
    protected Class persistentClass = getDomainClass();
    protected abstract Class getDomainClass();
    public void save(final T entity) {
        getHibernateTemplate().save(entity);
    }
    public void delete(final T entity) {
        getHibernateTemplate().delete(entity);
    }
    public void update(final T entity) {
        getHibernateTemplate().update(entity);
    }
    @SuppressWarnings("unchecked")
    public T findById(final Serializable id) {
        return (T) getHibernateTemplate().get(this.persistentClass, id);
    }
    @SuppressWarnings("unchecked")
    public List findAll() {
        return getHibernateTemplate().find("from " + this.persistentClass.getName() + " o");
    }
    public void deleteById(final Serializable id) {
        T obj = this.findById(id);
        getHibernateTemplate().delete(obj);
    }
    @SuppressWarnings("unchecked")
    public int count() {
        List list = getHibernateTemplate().find("select count(*) from " + persistentClass.getName() + " o");
        Long count = list.get(0);
        return count.intValue();
    }
    @SuppressWarnings("unchecked")
    public List findByExample(final T exampleObject) {
        return getHibernateTemplate().findByExample(exampleObject);
    }
}

After creating the last class the only thing that you will need is to create the specific business model DAO class, in our case PersonDAO. You can realize that it is a very short class, this is the advantage of using the GenericDAO. Every single DAO class for a specifi business model class is going to be as short as this one.

Listing 5. Business Model Class Data Access Object.

public class PersonDAO extends HibernateGenericDAO implements GenericDao {
    @Override
    protected Class getDomainClass() {
        return Person.class;
    }
}

Well, we already have the foundation needed to integrate with spring framework. Spring will be responsible to bind all the dependencies of the beans (glue it all together) and to handle the instances.

Listing 6. Spring framework DAO Configuration

<?xml version="1.0" encoding="UTF-8"?>



<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">



<beans>
      <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
            <property name="locations">
                  <list>
                        <value>classpath*:META-INF/jdbc.propertiesvalue>
                        <value>classpath*:META-INF/hibernate.propertiesvalue>
                  </list>
            </property>
      <bean>
      <bean id="internal.theDataSource"
            class="org.apache.commons.dbcp.BasicDataSource"
            destroy-method="close">
            <property name="driverClassName" value="${jdbc.driverClassName}"/>
            <property name="url" value="${jdbc.db.url}" />
            <property name="username" value="${jdbc.username}" />
            <property name="password" value="${jdbc.password}" />
            <property name="maxActive" value="100"/>
            <property name="maxWait" value="1000"/>
            <property name="poolPreparedStatements" value="true"/>
             <property name="defaultAutoCommit" value="true"/>
      </bean>
      <bean id="dataSource" class="org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy" lazy-init="true">
            <property name="targetDataSource" ref="internal.theDataSource" />
      </bean>
      <bean id="persistence.sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean" lazy-init="true">
            <property name="dataSource" ref="dataSource" />
            <property name="mappingLocations">
                  <list>
                        <value>classpath*:mappings/*.hbm.xmlvalue>
                  </list>
            <property>
            <property name="hibernateProperties">
                  <props>
                        <prop key="hibernate.show_sql">
                              ${hibernate.show_sql}
                        </prop>
                        <prop key="hibernate.dialect">
                              ${hibernate.dialect}
                        </prop>
                        <prop key="hibernate.hbm2ddl.auto">
                              ${hibernate.hbm2ddl.auto}
                        </prop>
                        <prop key="hibernate.cglib.use_reflection_optimizer">
                              ${hibernate.cglib.use_reflection_optimizer}
                        </prop>
                        <prop key="connection.pool_size">
                              ${hibernate.connection.pool_size}
                        </prop>
                        <prop key="hibernate.current_session_context_class">
                              ${hibernate.current_session_context_class}
                        </prop>
                        <prop key="hibernate.transaction.flush_before_completion">
                              ${hibernate.transaction.flush_before_completion}
                        </prop>
                  </props>
            </property>
      </bean>
      <bean id="persistence.personDAO" class="com.hexacta.persistence.dao.PersonDAO" lazy-init="default" autowire="default" dependency-check="default">
            <property name="sessionFactory">
              <ref bean="persistence.sessionFactory"/>
            </property>
      </bean>
</beans>

Rich Text Editor WYSIWYG with Javascript

2010-06-30T23:41:00.000-07:00

Looking for a simple way to format source code in the blog, i remembered that it exists a wonderful and useful Rich Text editor in Javascript, it's called TinyMCE, and the best is that is licensed under a Free Software License (LGPL). To see how it works you can visit http://tinymce.moxiecode.com. I have also found a tool to do the same and a little bit faster.

OutOfMemoryError en Eclipse SpringSource Tool Suite 2.3.0

2010-06-28T13:04:00.000-07:00

En diversas ocasiones me he encontrado con un error del tipo java.lang.OutOfMemoryError al utilizar Eclipse SpringSource Tool Suite de Springsource (anteriormente Interface21), ocasionado al parecer por la carga del servidor de aplicaciones del STS. Si tienes un computador con un procesador de varios núcleos, puedes solucionar este problema adicionando las siguientes lineas en el archivo STS.ini en la sección -vmargs (que se encuentra al final):

-XX:+CMSPermGenSweepingEnabled
-XX:+UseConcMarkSweepGC
-XX:+CMSClassUnloadingEnabled

Así luce mi "STS.ini"

-vm
C:\Program Files\Java\jdk1.5.0_08\bin\javaw.exe
-startupplugins/org.eclipse.equinox.launcher_1.0.201.R35x_v20090715.jar
--launcher.library
plugins/org.eclipse.equinox.launcher.win32.win32.x86_1.0.200.v20090519
-product
com.springsource.sts.ide
--launcher.XXMaxPermSize
512M
-vmargs
-XX:+CMSPermGenSweepingEnabled
-XX:+UseConcMarkSweepGC
-XX:+CMSClassUnloadingEnabled

Referencias

http://blog4jose.wordpress.com/2009/02/02/memory-permgen-classloader/

Lidiando con Eclipse: JVM Terminated. Exit Code=-1

2010-06-28T13:01:00.001-07:00

Luego de la instalación SpringSource Tool Suite y ver cómo fallaba con constantes errores de tipo java.lang.OutOfMemoryError, volvi a mi anterior instalación de Eclipse, sin embargo, ahora éste me presentaba el siguiente error, sin razón alguna:JVM Terminated. Exit Code=-1

Para volver a ejecutar Eclipse tienes 2 opciones que funcionaron en mi caso:
1. Ubicar el archivo eclipse.exe y luego renombrarlo con otro nombre, por ejemplo: eclipse-nuevo.exe
2. Remover el argumento vmargs del archivo eclipse.ini ubicado en el mismo directorio del archivo eclipse.exe

Este par de opciones funcionaron también para solucionar un error "Cannot create JVM" lanzado al intentar ejecutar SpringSource Tool Suite 2.3.1.

Referencias
http://troyworks.com/blog/2008/06/08/eclipse-jvm-terminated-exit-code-1/