import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.io.Serializable;
import java.lang.reflect.Method;
 
/**
 * Shows odd behavior when using an introspector from the java.beans api
 */
public class IntrospectorPossibleBugTest {
 
	/**
	 * Marker interface for all locations
	 */
	interface Location {
	}
 
	/**
	 * A City is a location
	 */
	class City implements Location {
	}
 
	/**
	 * Marker interface for people, a person must have a location assigned
	 */
	interface Person {
		Location getLocation();
	}
 
	/**
	 * A worker is a Person and should have a location that is actually a City
	 */
	static class Worker implements Person, Serializable {
 
		private City location;
 
		public City getLocation() {
			return location;
		}
 
		public void setLocation(City location) {
			this.location = location;
		}
 
	}
 
	/**
	 * This small test cases shows the odd behavior.
	 * Even though Worker conforms with the getters and setters for the javabean spec the
	 * Introspector seems to not be able to find any setter for the property location.
	 * Seems like instead of following a bottom up loockup for property accessors it starts and stops once it
	 * finds a compatible property in one of the implemented interfaces.
	 */
	public static void main(String... args) throws IntrospectionException {
		BeanInfo info = Introspector.getBeanInfo(Worker.class);
		PropertyDescriptor[] descriptors = info.getPropertyDescriptors();
		for (PropertyDescriptor descriptor : descriptors) {
			if (!descriptor.getName().equals("class")) {
				System.out.println("property: \t\t\t\t\t\t" + descriptor.getName());
				System.out.println("getter: \t\t\t\t\t\t" + descriptor.getReadMethod());
				System.out.println("getter returns: \t\t\t\t" + descriptor.getReadMethod().getReturnType());
				System.out.println("setter: \t\t\t\t\t\t" + descriptor.getWriteMethod());
				String propertyName = descriptor.getName();
				String setterName = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
				Method setter = findMethodImplFirst(Worker.class, setterName, City.class);
				System.out.println("setter with reflection: \t\t" + setter);
			}
		}
 
	}
 
	/**
	 * workaround for introspector odd behavior with javabeans that implement interfaces with comaptible return types
	 * but instrospection is unable to find the right accessors
	 *
	 * @param currentTargetClass the class being evaluated
	 * @param methodName		 the method name we are looking for
	 * @param argTypes		   the arg types for the method name
	 * @return a method if found
	 */
	public static Method findMethodImplFirst(Class<?> currentTargetClass, String methodName, Class<?>... argTypes) {
		Method method = null;
		if (currentTargetClass != null && methodName != null) {
			try {
				method = currentTargetClass.getMethod(methodName, argTypes);
			} catch (Throwable t) {
				// nothing we can do but continue
			}
			//Is the method in one of our parent classes
			if (method == null) {
				Class<?> superclass = currentTargetClass.getSuperclass();
				if (!superclass.equals(Object.class)) {
					method = findMethodImplFirst(superclass, methodName, argTypes);
				}
			}
		}
		return method;
	}
 
}

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
		  http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         version="2.5">
    <description>hibernate-rest</description>
    <display-name>hibernate-rest</display-name>
 
    <!-- Spring config  -->
    <context-param>
           <param-name>contextConfigLocation</param-name>
           <param-value>
               /WEB-INF/conf/applicationContext.xml
           </param-value>
       </context-param>
 
    <context-param>
        <param-name>log4jConfigLocation</param-name>
        <param-value>/WEB-INF/conf/log4j.properties</param-value>
    </context-param>
 
 
    <!-- Spring Listeners -->
    <listener>
        <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
    </listener>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <listener>
        <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
    </listener>
 
    <filter>
        <filter-name>openSessionInViewFilter</filter-name>
        <filter-class>
            org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
        </filter-class>
    </filter>
 
    <filter-mapping>
        <filter-name>openSessionInViewFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
 
    <!-- Remote web services -->
       <servlet>
           <servlet-name>CXFServlet</servlet-name>
           <servlet-class>
               org.apache.cxf.transport.servlet.CXFServlet
           </servlet-class>
       </servlet>
 
       <servlet>
           <servlet-name>remoteApiBasicHttpHandlerImpl</servlet-name>
           <servlet-class>org.springframework.web.context.support.HttpRequestHandlerServlet</servlet-class>
       </servlet>
 
 
       <!-- Remote web services mapping -->
       <servlet-mapping>
           <servlet-name>CXFServlet</servlet-name>
           <url-pattern>/api/*</url-pattern>
       </servlet-mapping>
 
 
</web-app>

<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<session-factory name="com.raulraja.tutorials">
        <!-- Persistent entities -->
        <mapping class="com.raulraja.model.domain.Person"/>  
    </session-factory>
</hibernate-configuration>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xmlns:cxf="http://cxf.apache.org/core"
        xmlns:jaxws="http://cxf.apache.org/jaxws"
        xmlns:jaxrs="http://cxf.apache.org/jaxrs" xmlns:util="http://www.springframework.org/schema/util"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
       http://cxf.apache.org/core
       http://cxf.apache.org/schemas/core.xsd
       http://cxf.apache.org/jaxws
       http://cxf.apache.org/schemas/jaxws.xsd
       http://cxf.apache.org/jaxrs
       http://cxf.apache.org/schemas/jaxrs.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"
        default-autowire="byName">
 
    <!-- Load CXF modules from cxf.jar -->
    <import resource="classpath:META-INF/cxf/cxf.xml"/>
    <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml"/>
    <import resource="classpath:META-INF/cxf/cxf-servlet.xml"/>
    <import resource="classpath:META-INF/cxf/cxf-extension-jaxrs-binding.xml"/>
 
 
    <cxf:bus>
        <cxf:features>
            <cxf:logging/>
        </cxf:features>
    </cxf:bus>
 
    <!-- A template instance to expose as the service -->
    <bean id="person" class="com.raulraja.model.domain.Person"/>
 
    <!-- The rest server configuration -->
    <jaxrs:server id="restServer" address="/rest/">
        <jaxrs:serviceBeans>
            <ref bean="person"/>
        </jaxrs:serviceBeans>
        <jaxrs:extensionMappings>
            <entry key="feed" value="application/atom+xml"/>
            <entry key="json" value="application/json"/>
            <entry key="xml" value="application/xml"/>
            <entry key="html" value="text/html"/>
        </jaxrs:extensionMappings>
    </jaxrs:server>
 
    <!-- The datasource -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
        <property name="driverClass" value="org.postgresql.Driver"/>
        <property name="jdbcUrl" value="jdbc:postgresql://localhost:5432/tutorials?autoReconnect=true"/>
        <property name="user" value="tutorials"/>
        <property name="password" value="tutorials"/>
    </bean>
 
    <!-- The hibernate session factory -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="configLocations">
            <list>
                <value>WEB-INF/conf/hibernate.cfg.xml</value>
            </list>
        </property>
        <property name="configurationClass">
            <value>org.hibernate.cfg.AnnotationConfiguration</value>
        </property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
        <property name="dataSource">
            <ref bean="dataSource"/>
        </property>
    </bean>
 
    <!-- A persistence adapter implementation that acts as a data access service -->
    <bean id="persistenceAdapter" class="com.raulraja.model.persistence.impl.HibernatePersistenceAdapterImpl" autowire="autodetect">
        <property name="defaultResultSize" value="10"/>
        <property name="hibernateTemplate">
            <ref bean="hibernateTemplate"/>
        </property>
    </bean>
 
    <!-- The transaction manager -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory">
            <ref bean="sessionFactory"/>
        </property>
    </bean>
 
    <!-- enable the configuration of transactional behavior based on annotations -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
 
    <!-- The hibernate template -->
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
        <property name="sessionFactory">
            <ref bean="sessionFactory"/>
        </property>
    </bean>
 
    <!-- statically injects the persistence service in the entities base class -->
    <bean class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
        <property name="staticMethod" value="com.raulraja.model.domain.PersistentEntity.setPersistenceAdapter"/>
        <property name="arguments">
            <ref bean="persistenceAdapter"/>
        </property>
    </bean>
 
 
</beans>

package com.raulraja.model.domain;
 
import javax.xml.bind.annotation.*;
import java.util.ArrayList;
import java.util.List;
 
/**
 * An object that encapsualtes pagination over list of records
 */
@XmlRootElement(namespace = PersistentEntity.NAMESPACE)
@XmlType(name = "paginatedList", namespace = PersistentEntity.NAMESPACE)
public class PaginatedList<Entity> {
 
	/**
	 * the total amount of items available in the data store
	 */
	private long count;
 
	/**
	 * the starting record displayed on the list
	 */
	private long start;
 
	/**
	 * the size of this list
	 */
	private long size;
 
	/**
	 * the records contained on the list
	 */
	private List<Entity> items = new ArrayList<Entity>();
 
	/**
	 * default constructor
	 */
	public PaginatedList() {
		super();
	}
 
	/**
	 * Constructor that takes the data
	 * @param count the total amount of items available in the data store
	 * @param start the starting record displayed on the list
	 * @param items the records contained on the list
	 */
	public PaginatedList(long count, long start, List<Entity> items) {
		this();
		setCount(count);
		setStart(start);
		setItems(items);
		setSize(items.size());
	}
 
	/**
	 * @return the total amount of items available in the data store
	 */
	public long getCount() {
		return count;
	}
 
	public void setCount(long count) {
		this.count = count;
	}
 
	/**
	 * @return the starting record displayed on the list
	 */
	public long getStart() {
		return start;
	}
 
	public void setStart(long start) {
		this.start = start;
	}
 
	/**
	 * @return the size of this list
	 */
	public long getSize() {
		return size;
	}
 
	public void setSize(long size) {
		this.size = size;
	}
 
	/**
	 * @return the records contained on the list
	 */
	@XmlElementWrapper(name = "items")
	@XmlElements({
            @XmlElement(name="person", type=Person.class, namespace = PersistentEntity.NAMESPACE),
			@XmlElement(name="property", type=Object.class, namespace = PersistentEntity.NAMESPACE)
    })
	public List<Entity> getItems() {
		return items;
	}
 
	public void setItems(List<Entity> items) {
		this.items = items;
	}
}

package com.raulraja.model.domain;
 
import com.raulraja.model.persistence.PersistenceAdapter;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.PropertyUtils;
import org.springframework.transaction.annotation.Transactional;
 
import javax.ws.rs.*;
import java.lang.reflect.InvocationTargetException;
 
/**
 * Base class for entities with static access to the persistent context
 */
public abstract class PersistentEntity<Entity extends PersistentEntity> {
 
	public static final String NAMESPACE = "https://apps.raulraja.org/api";
 
	private static PersistenceAdapter<PersistentEntity> persistenceAdapter;
 
	public static void setPersistenceAdapter(PersistenceAdapter<PersistentEntity> persistenceAdapter) {
		PersistentEntity.persistenceAdapter = persistenceAdapter;
	}
 
	public abstract Long getId();
 
	public abstract Class<Entity> getMappedClass();
 
	@Override
	@SuppressWarnings("unchecked")
	public boolean equals(Object o) {
		if (this == o) {
			return true;
		}
		if (o == null || getClass() != o.getClass()) {
			return false;
		}
 
		PersistentEntity<?> entity = (PersistentEntity<?>) o;
 
		if (getId() != null ? !getId().equals(entity.getId()) : entity.getId() != null) {
			return false;
		}
 
		return true;
	}
 
	@Override
	public int hashCode() {
		return getId() != null ? getId().hashCode() : 0;
	}
 
 
	/**
	 * Returns a paginated list of all entities for this class
	 * @param start the start record
	 * @param size the limit
	 * @return the list of matches
	 */
	@GET @Path("list")
	@SuppressWarnings("unchecked")
    public PaginatedList<Entity> list(@QueryParam("start") int start, @QueryParam("size") int size) {
		Class mappedClass = getMappedClass();
		PaginatedList<Entity> list = (PaginatedList<Entity>) persistenceAdapter.list(mappedClass, start, size);
		return list;
	}
 
	/**
	 * Returns a paginated list of all entities for this class
	 * @param start the start record
	 * @param size the limit
	 * @return the list of matches
	 */
	@GET @Path("{property}/list")
	@SuppressWarnings("unchecked")
    public PaginatedList<Object> list(@PathParam("property") String property, @QueryParam("start") int start, @QueryParam("size") int size) {
		Class mappedClass = getMappedClass();
		PaginatedList<Object> list = (PaginatedList<Object>) persistenceAdapter.list(mappedClass, property, start, size);
		return list;
	}
 
 
	@GET @Path("{id}")
    public PersistentEntity get(@PathParam("id") Long id) {
		Class mappedClass = getMappedClass();
		PersistentEntity entity = persistenceAdapter.get(mappedClass, id);
		return entity;
	}
 
	@GET @Path("{id}/{property}")
    public Object getProperty(@PathParam("id") Long id, @PathParam("property") String property) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
		Class mappedClass = getMappedClass();
		PersistentEntity entity = persistenceAdapter.get(mappedClass, id);
		return PropertyUtils.getProperty(entity, property);
	}
 
	@POST @Path("{id}/{property}")
	@Transactional
    public Object updateProperty(@PathParam("id") Long id, @PathParam("property") String property, String value) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
		Class mappedClass = getMappedClass();
		PersistentEntity entity = persistenceAdapter.get(mappedClass, id);
		BeanUtils.setProperty(entity, property, value);
		return persistenceAdapter.save(entity);	
	}
 
	@POST @Path("create")
	@Transactional
    public PersistentEntity create(Entity entity) {
		PersistentEntity persistentEntity = get(entity.getId());
		if (persistentEntity != null) {
			throw new IllegalStateException("There is already a " + getMappedClass() + " with id = " + entity.getId());
		}
		persistenceAdapter.save(entity);
		return entity;
	}
 
	@POST @Path("update")
	@Transactional
    public PersistentEntity update(Entity entity) {
		PersistentEntity<Entity> persistentEntity = get(entity.getId());
		if (persistentEntity == null) {
			throw new IllegalStateException("There is no" + getMappedClass() + " with id = " + entity.getId());
		}
		persistentEntity.updateFromRequest(entity);
		persistenceAdapter.save(persistentEntity);
		return persistentEntity;
	}
 
	public abstract Entity updateFromRequest(Entity entity);
 
	@POST @Path("delete")
    public Entity delete(Entity entity) {
		persistenceAdapter.delete(entity);
		return entity;
	}
 
}

package com.raulraja.model.domain;
 
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.ws.rs.Path;
import javax.xml.bind.annotation.*;
import java.util.ArrayList;
import java.util.List;
 
@Entity
@Path("/person/")
@XmlRootElement
@XmlType(name = "person", namespace = PersistentEntity.NAMESPACE)
public class Person extends PersistentEntity<Person> {
 
	@Id
	private Long id;
 
	private String name;
 
	private String email;
 
	@ManyToOne
	private Person parent;
 
	@OneToMany(mappedBy = "parent")
	private List<Person> children = new ArrayList<Person>();
 
	@XmlElement(type = Long.class)
	public Long getId() {
		return id;
	}
 
	public void setId(Long id) {
		this.id = id;
	}
 
	@XmlElement(type = String.class)
	public String getName() {
		return name;
	}
 
	public void setName(String name) {
		this.name = name;
	}
 
	@XmlElement(type = String.class)
	public String getEmail() {
		return email;
	}
 
	public void setEmail(String email) {
		this.email = email;
	}
 
	@XmlElement(type = Person.class)
	public Person getParent() {
		return parent;
	}
 
	public void setParent(Person parent) {
		this.parent = parent;
	}
 
	@XmlElement(type = Person.class, name = "person", namespace = PersistentEntity.NAMESPACE)
	@XmlElementWrapper(name = "children")
	public List<Person> getChildren() {
		return children;
	}
 
	public void setChildren(List<Person> children) {
		this.children = children;
	}
 
	public Class<Person> getMappedClass() {
		return Person.class;
	}
 
	public Person updateFromRequest(Person person) {
		setName(person.getName());
		setEmail(person.getEmail());
		return this;
	}
 
 
}

package com.raulraja.model.persistence;
 
import com.raulraja.model.domain.PaginatedList;
 
import java.io.Serializable;
 
 
public interface PersistenceAdapter<Entity> {
 
	/**
	 * Returns a paginated list of all entities for this class
	 * @param entityClass the entity class
	 * @param start the start record
	 * @param limit the limit
	 * @return the list of matches
	 */
	PaginatedList<Entity> list(Class<Entity> entityClass, int start, int limit);
 
	/**
	 * Returns a paginated list of the selected property for this class
	 * @param entityClass the entity class
	 * @param start the start record
	 * @param limit the limit
	 * @return the list of matches
	 */
	PaginatedList<?> list(Class<Entity> entityClass, String property, int start, int limit);
 
    /**
     * Find a persistent object based on its unique id
     * @param entityClass the entity's class
     * @param id unique identifier
     * @return returns a persistent object
     */
    public Entity get(Class<Entity> entityClass, Serializable id);
 
    /**
     * Persists an object
     * @param entity to be persisted
	 * @return the saved entity
     */
    public Entity save(Entity entity);
 
    /**
     * Removes an entity from the data store
     * @param entity to be removed
	 * @return the deleted entity
     */
    public Entity delete(Entity entity);
 
 
}

package com.raulraja.model.persistence.impl;
 
import com.raulraja.model.domain.PaginatedList;
import com.raulraja.model.persistence.PersistenceAdapter;
import org.apache.log4j.Logger;
import org.hibernate.*;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;
import org.hibernate.metadata.ClassMetadata;
import org.springframework.orm.hibernate3.HibernateAccessor;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
 
import java.io.Serializable;
import java.sql.SQLException;
import java.util.List;
 
/**
 * Hibernate spring based impl of the persistence adapter
 */
public class HibernatePersistenceAdapterImpl<Entity> extends HibernateDaoSupport implements PersistenceAdapter<Entity> {
 
	private final static Logger log = Logger.getLogger(HibernatePersistenceAdapterImpl.class);
 
	private Integer defaultResultSize = 10;
 
	public void setDefaultResultSize(Integer defaultResultSize) {
		this.defaultResultSize = defaultResultSize;
	}
 
	/**
	 * Returns a paginated list of all entities for this class
	 *
	 * @param entityClass the entity class
	 * @param start	   the start record
	 * @param limit	   the limit
	 * @return the list of matches
	 */
	@SuppressWarnings("unchecked")
	public PaginatedList<Entity> list(Class<Entity> entityClass, int start, int limit) {
		limit = limit > 0 ? limit : defaultResultSize;
		if (entityClass == null)
            return null;
 
        List<Entity> entities;
		PaginatedList<Entity> page = new PaginatedList<Entity>();
 
		int total;
		try {
			DetachedCriteria criteria = DetachedCriteria.forClass(entityClass);
			entities = (List<Entity>) getPreparedHibernateTemplate().findByCriteria(criteria, start, limit);
			total = count(entityClass);
			page = new PaginatedList<Entity>(total, start, entities);
        }
        catch (Throwable e) {
            log.error(e, e);
        }
        return page;
	}
 
	/**
	 * Returns a paginated list of the selected property for this class
	 *
	 * @param entityClass the entity class
	 * @param start	   the start record
	 * @param limit	   the limit
	 * @return the list of matches
	 */
	public PaginatedList<?> list(Class<Entity> entityClass, String property, int start, int limit) {
		limit = limit > 0 ? limit : defaultResultSize;
		if (entityClass == null)
            return null;
 
        List<Object> properties;
		PaginatedList<Object> page = new PaginatedList<Object>();
 
		int total;
		try {
			DetachedCriteria criteria = DetachedCriteria.forClass(entityClass);
			criteria.setProjection(Projections.property(property));
			properties = (List<Object>) getPreparedHibernateTemplate().findByCriteria(criteria, start, limit);
			total = count(entityClass);
			page = new PaginatedList<Object>(total, start, properties);
        }
        catch (Throwable e) {
            log.error(e, e);
        }
        return page;
	}
 
	private Integer count(final Class<Entity> entityClass) {
		return (Integer) getPreparedHibernateTemplate().execute(new HibernateCallback(){
			public Object doInHibernate(Session session) throws HibernateException, SQLException {
				Criteria criteria = session.createCriteria(entityClass);
				criteria.setProjection(Projections.rowCount());
				return criteria.list().get(0);
			}
		});
	}
 
	/**
	 * Find a persistent object based on its unique id
	 *
	 * @param entityClass the entity's class
	 * @param id		  unique identifier
	 * @return returns a persistent object
	 */
	@SuppressWarnings("unchecked")
	public Entity get(Class<Entity> entityClass, Serializable id) {
		Entity entity = (Entity) getHibernateTemplate().get(entityClass, id);
		return initializeProxy(entity);
	}
 
	/**
	 * Persists an object
	 *
	 * @param entity to be persisted
	 */
	@SuppressWarnings("unchecked")
	public Entity save(Entity entity) {
		getHibernateTemplate().saveOrUpdate(entity);
		return initializeProxy(entity);
	}
 
	/**
	 * Removes an entity from the data store
	 *
	 * @param entity to be removed
	 */
	@SuppressWarnings("unchecked")
	public Entity delete(Entity entity) {
		getHibernateTemplate().delete(entity);
		return initializeProxy(entity);
	}
 
 
	private HibernateTemplate getPreparedHibernateTemplate() {
        HibernateTemplate template = getHibernateTemplate();
        template.setCacheQueries(true);
        template.setFlushMode(HibernateAccessor.FLUSH_AUTO);
        return template;
    }
 
	private Entity initializeProxy(Entity entity) {
		getPreparedHibernateTemplate().initialize(entity);
		return entity;
	}
 
	/**
	 * Finds a class associated with this path name
	 *
	 * @param name the name
	 * @return the found class if any
	 */
	@SuppressWarnings("unchecked")
	public Class<Entity> getClassForName(String name) {
		final String normalizedName = name.length() > 0 ? name.substring(name.lastIndexOf("."),1).toUpperCase() + name.substring(0) : name;
		return (Class<Entity>) getPreparedHibernateTemplate().execute(new HibernateCallback(){
			public Object doInHibernate(Session session) throws HibernateException, SQLException {
				SessionFactory factory = session.getSessionFactory();
				ClassMetadata classMetadata = factory.getClassMetadata(normalizedName);
				return classMetadata != null ? classMetadata.getMappedClass(EntityMode.POJO) : null;
			}
		});
	}
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd"
       default-autowire="byName">
 
    <!-- thumbnail generator engine -->
    <bean id="thumbnailGeneratorEngine" class="com.raulraja.util.thumbnails.impl.ThumbnailGeneratorEngineImpl">
 
        <!-- the file extension for the thumbnail files -->
		<property name="generatedExtension">
			<value>.jpg</value>
		</property>
 
        <!-- the different sizes we want to generate, adjusting the aspect ratio based on the biggest dimension -->
		<property name="supportedSizes">
			<list>
                <value>900</value>
                <value>768</value>
                <value>375</value>
                <value>128</value>
                <value>64</value>
                <value>48</value>
                <value>22</value>
			</list>
		</property>
 
        <!-- mappings from the different content types to the right generator that handles each type -->
		<property name="thumbnailGenerators">
			<map>
				<entry key="image/jpeg" value-ref="imageThumbnailGenerator" />
                <entry key="image/jpg" value-ref="imageThumbnailGenerator" />
                <entry key="image/pjpeg" value-ref="imageThumbnailGenerator" />
                <entry key="image/gif" value-ref="imageThumbnailGenerator" />
                <entry key="image/png" value-ref="imageThumbnailGenerator" />
                <entry key="image/tiff" value-ref="imageThumbnailGenerator" />
                <entry key="image/bmp" value-ref="imageThumbnailGenerator" />
                <entry key="application/pdf" value-ref="pdfThumbnailGenerator" />
			</map>
		</property>
 
        <!-- A default thumbnail generator to be used for unregistered mime types -->
        <property name="defaultThumbnailGenerator" ref="imageThumbnailGenerator"/>
 
        <!-- location for the generated thumbnails -->
        <property name="thumbnailsLocation" value="/Users/raul/Pictures/test/"/>
	</bean>
 
    <!-- a thumbnail generator that generates thumbnails from images -->
	<bean id="imageThumbnailGenerator" class="com.raulraja.util.thumbnails.impl.ImageThumbnailGeneratorImpl" autowire="autodetect" />
 
    <!-- a thumbnail generator that generates thumbnails from pdf files not implemented for simplicity -->
	<bean id="pdfThumbnailGenerator" class="com.raulraja.util.thumbnails.impl.PDFThumbnailGeneratorImpl" autowire="autodetect" />
 
    <!-- upload code below for demo purposes -->
 
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- one of the properties available; the maximum file size in bytes -->
        <property name="maxUploadSize" value="50000000"/>
    </bean>
 
    <bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="mappings">
            <value>
                /upload.form=fileUploader
            </value>
        </property>
        <property name="alwaysUseFullPath" value="true" />
    </bean>
 
 
    <bean id="fileUploader" class="com.raulraja.util.upload.FileUploadService" autowire="autodetect" scope="session">
        <property name="commandClass" value="com.raulraja.util.upload.FileUpload"/>
        <property name="formView" value="uploadFile.jsp"/>
        <property name="successView" value="success.jsp" />
    </bean>
 
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
		  http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         version="2.5">
    <description>method-profiling-with-spring</description>
    <display-name>method-profiling-with-spring</display-name>
 
    <!-- Spring config  -->
    <context-param>
           <param-name>contextConfigLocation</param-name>
           <param-value>
               /WEB-INF/conf/applicationContext.xml
           </param-value>
       </context-param>
 
    <context-param>
        <param-name>log4jConfigLocation</param-name>
        <param-value>/WEB-INF/conf/log4j.properties</param-value>
    </context-param>
 
 
    <!-- Spring Listeners -->
    <listener>
        <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
    </listener>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <listener>
        <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
    </listener>
 
    <servlet>
        <servlet-name>springDispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
 
    <!-- maps the dispatcher to *.form -->
    <servlet-mapping>
        <servlet-name>springDispatcher</servlet-name>
        <url-pattern>*.form</url-pattern>
    </servlet-mapping>
 
</web-app>

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<html>
<head>
    <title></title>
</head>
<body>
    <form action="upload.form" enctype="multipart/form-data" method="post">
        <input type="file" name="file" id="file"  />   
        <input type="submit" value="Upload"/>
    </form>
</body>
</html>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
        "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <title></title>
</head>
<body>
    sucess!!!
</body>
</html>

package com.raulraja.util.thumbnails;
 
import java.io.InputStream;
 
/**
 * An engine in charge of generating thumbnails for files
 */
public interface ThumbnailGeneratorEngine {
 
	/**
	 * @param fileNamePrefix the prefix for the generated thumbnails
	 * @param inputStream	the stream to generate thumbnails for
	 * @param contentType	the content type of this input stream for example image/jpeg
	 */
	void generateThumbnails(String fileNamePrefix, InputStream inputStream, String contentType);
}

package com.raulraja.util.thumbnails.impl;
 
import com.raulraja.util.thumbnails.ThumbnailGenerator;
import com.raulraja.util.thumbnails.ThumbnailGeneratorEngine;
import org.apache.log4j.Logger;
 
import java.io.File;
import java.io.InputStream;
import java.util.List;
import java.util.Map;
 
/**
 * Default impl for the Thumbnail generator engine
 */
public class ThumbnailGeneratorEngineImpl implements ThumbnailGeneratorEngine {
 
	private final static Logger log = Logger.getLogger(ThumbnailGeneratorEngineImpl.class);
 
	private String generatedExtension;
 
	/**
	 * @param generatedExtension The extension for the generated thumbnails
	 */
	public void setGeneratedExtension(String generatedExtension) {
		this.generatedExtension = generatedExtension;
	}
 
	public String getGeneratedExtension() {
		return generatedExtension;
	}
 
	private Map<String, ThumbnailGenerator> thumbnailGenerators;
 
	/**
	 * @param thumbnailGenerators The thumbnail generators known by this engine mapped to a content type
	 */
	public void setThumbnailGenerators(Map<String, ThumbnailGenerator> thumbnailGenerators) {
		this.thumbnailGenerators = thumbnailGenerators;
	}
 
	private List<Integer> supportedSizes;
 
	/**
	 * @param supportedSizes The suported sizes for the batch of generated thumbs
	 */
	public void setSupportedSizes(List<Integer> supportedSizes) {
		this.supportedSizes = supportedSizes;
	}
 
	private ThumbnailGenerator defaultThumbnailGenerator;
 
	/**
	 * @param defaultThumbnailGenerator the default thumbnail generator to be used for unregistered mime types
	 */
	public void setDefaultThumbnailGenerator(ThumbnailGenerator defaultThumbnailGenerator) {
		this.defaultThumbnailGenerator = defaultThumbnailGenerator;
	}
 
	private String thumbnailsLocation;
 
	/**
	 * @param thumbnailsLocation location for the generated thumbnails
	 */
	public void setThumbnailsLocation(String thumbnailsLocation) {
		this.thumbnailsLocation = thumbnailsLocation;
	}
 
	/**
	 * @param fileNamePrefix the prefix for the generated thumbnails
	 * @param inputStream	the stream to generate thumbnails for
	 * @param contentType	the content type of this input stream for example image/jpeg
	 */
	public void generateThumbnails(String fileNamePrefix, InputStream inputStream, String contentType) {
		ThumbnailGenerator thumbnailGenerator = thumbnailGenerators.get(contentType);
		thumbnailGenerator = thumbnailGenerator != null ? thumbnailGenerator : defaultThumbnailGenerator;
		if (thumbnailGenerator != null) {
			Object hint = null;
			for (int dimension : supportedSizes) {
				File fileOut = new File(thumbnailsLocation, fileNamePrefix + "_" + dimension + generatedExtension);
				try {
					hint = thumbnailGenerator.createThumbnail(inputStream, fileOut, dimension, hint);
					log.debug("Generated thumbnail for: " + inputStream + " in " + fileOut + " for type " + contentType);
				}
				catch (Exception e) {
					log.error("Error generating thumbnail for: " + inputStream + " in " + fileOut + " for type " + contentType, e);
				}
 
			}
		} else {
			log.warn("Thumbnail generator not found for content type: " + contentType + " and no default generator was provided");
		}
	}
}

package com.raulraja.util.thumbnails;
 
import java.io.File;
import java.io.InputStream;
import java.io.IOException;
 
 
/**
 * Interface implemented by all thumbnail generators.
 *
 * <p>The thumbnail generation process is always performed in order with the largest thumbnails first.
 * Therefore it may be very handy for the generator to create smaller thumbnails using the results from
 * the prior iteration instead of always using the full-sized image as the source.  To accomplish this,
 * the generator can return a "hint" object that it can use in subsequent iterations, containing whatever
 * helpers it might want (such as the prior image already loaded in memory, etc).
 */
public interface ThumbnailGenerator {
 
 
 
    /**
     * Create the thumbnail.  The thumbnail should always save as a JPEG file.
     *
     * @param inputStream       The source data.
     * @param fileOut           The output file.
     * @param largestDimension  The max width and height.  The generator should size the thumbnail so
     *                          that the width and height both stay within this limit.
     * @param hint              Optional hint that was returned from the prior thumbnail generation
     *                          on this same file, null if none was returned or if this is the first
     *                          thumbnail in this context.
     *
     * @return an optional hint object that will be passed to subsequent thumbnail generation calls
     *         for this same source data.  Return null if you don't use hints, otherwise return some
     *         object which allows you to communicate extra information to the next round, such as
     *         the scaled image already loaded.
	 * @throws java.io.IOException if something goes wrong handling the io
     */
	public Object createThumbnail(InputStream inputStream, File fileOut, int largestDimension, Object hint) throws IOException;
 
}

 
package com.raulraja.util.thumbnails.impl;
 
import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageEncoder;
import org.apache.log4j.Logger;
 
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.IOException;
 
/**
 * Class providing convenience method for abstract thumbnail generators
 */
public class AbstractThumbnailGenerator {
 
	private final static Logger log = Logger.getLogger(AbstractThumbnailGenerator.class);
 
	/**
     * Save an image as a JPEG file on disk.
     *
     * @param image     The raw image to save.
     * @param fileOut   The location where you want to save the file.
     *
     * @return true if successful, false if unsuccessful.
	 * @throws java.io.IOException if something goes wrong closing the stream
     */
    public boolean saveImageAsJPEG(BufferedImage image, File fileOut) throws IOException {
        OutputStream streamOut = null;
        boolean      bSuccess = false;
 
        try {
            streamOut = new FileOutputStream(fileOut);
            JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(streamOut);
            encoder.encode(image);
            bSuccess = true;
        }
        catch (Throwable t) {
            log.warn("Files.saveImageAsJPEG(" + fileOut + "): " + t, t);
        }
        finally {
            if (streamOut != null) {
				streamOut.close();
			}
        }
 
        return bSuccess;
    }
 
 
}

package com.raulraja.util.thumbnails.impl;
 
 
import com.raulraja.util.thumbnails.ThumbnailGenerator;
import org.apache.log4j.Logger;
 
import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.*;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
 
 
/**
 * Generate thumbnails for images.
 */
public class ImageThumbnailGeneratorImpl extends AbstractThumbnailGenerator implements ThumbnailGenerator {
 
    private final static Logger log = Logger.getLogger(ImageThumbnailGeneratorImpl.class);
 
	public Object createThumbnail(InputStream inputStream, File fileOut, int largestDimension, Object hint) throws IOException {
 
        // What's the base image that we are starting with?  If there's a hint, that's the scaled image
        // from the last time around, use that... (since we know we always iterate downwards in scale)
        Image imageIn;
        if (hint instanceof Image) {
            imageIn = (Image) hint;
            log.info("createThumbnail(" + fileOut + ") reusing prior result image...");
        }
        else {
            log.info("createThumbnail(" + fileOut + ") reading image from stream " + inputStream);
            imageIn = ImageIO.read(inputStream);
        }
 
        if (imageIn == null) {
            log.warn("Could not read image file: " + inputStream);
            return hint;
        }
 
        BufferedImage imageOut = createThumbnailImage(imageIn, fileOut, largestDimension);
 
        // Return this image now as the hint for the next scaling iteration
        if (imageOut != null)
            hint = imageOut;
 
        return hint;
    }
 
 
    /**
     * Create a thumbnail image and save it to disk.
     *
     * This algorithm is based on:
     *      http://www.philreeve.com/java_high_quality_thumbnails.php
     *
     * @param imageIn           The image you want to scale.
     * @param fileOut           The output file.
     * @param largestDimension  The largest dimension, so that neither the width nor height
     *                          will exceed this value.
     *
     * @return the image that was created, null if imageIn or fileOut is null.
	 * @throws java.io.IOException if something goes wrong when saving as jpeg
     */
    public BufferedImage createThumbnailImage(Image imageIn, File fileOut, int largestDimension) throws IOException {
        if ((imageIn == null) || (fileOut == null))
            return null;
 
        //it seems to not return the right size until the methods get called for the first time
        imageIn.getWidth(null);
        imageIn.getHeight(null);
 
        // Find biggest dimension
        int     nImageWidth = imageIn.getWidth(null);
        int     nImageHeight = imageIn.getHeight(null);
        int     nImageLargestDim = Math.max(nImageWidth, nImageHeight);
        double  scale = (double) largestDimension / (double) nImageLargestDim;
        int     sizeDifference = nImageLargestDim - largestDimension;
 
        //create an image buffer to draw to
        BufferedImage imageOut = new BufferedImage(100, 100, BufferedImage.TYPE_INT_RGB); // 8-bit RGB
        Graphics2D g2d;
        AffineTransform tx;
 
        // Use a few steps if the sizes are drastically different, and only scale
        // if the desired size is smaller than the original.
        int numSteps = 0;
        if (scale < 1.0d) {
            // Make sure we have at least 1 step
            numSteps = Math.max(1, (sizeDifference / 100));
        }
 
        if (numSteps > 0) {
            int stepSize = sizeDifference / numSteps;
            int stepWeight = stepSize / 2;
            int heavierStepSize = stepSize + stepWeight;
            int lighterStepSize = stepSize - stepWeight;
            int currentStepSize, centerStep;
            double scaledW = imageIn.getWidth(null);
            double scaledH = imageIn.getHeight(null);
 
            if ((numSteps % 2) == 1) //if there's an odd number of steps
                centerStep = (int) Math.ceil((double) numSteps / 2d); //find the center step
            else
                centerStep = -1; //set it to -1 so it's ignored later
 
            Integer intermediateSize;
            Integer previousIntermediateSize = nImageLargestDim;
 
            for (Integer i = 0; i < numSteps; i++) {
                if (i + 1 != centerStep) {
                    //if this isn't the center step
 
                    if (i == numSteps - 1) {
                        //if this is the last step
                        //fix the stepsize to account for decimal place errors previously
                        currentStepSize = previousIntermediateSize - largestDimension;
                    }
                    else {
                        if (numSteps - i > numSteps / 2) //if we're in the first half of the reductions
                            currentStepSize = heavierStepSize;
                        else
                            currentStepSize = lighterStepSize;
                    }
                }
                else {
                    //center step, use natural step size
                    currentStepSize = stepSize;
                }
 
                intermediateSize = previousIntermediateSize - currentStepSize;
                scale = intermediateSize / (double) previousIntermediateSize;
                scaledW = Math.max((int)(scaledW * scale), 1);
                scaledH = Math.max((int)(scaledH * scale), 1);
 
                log.info("step " + i + ": scaling to " + scaledW + " x " + scaledH);
                imageOut = new BufferedImage((int) scaledW, (int) scaledH, BufferedImage.TYPE_INT_RGB); // 8 bit RGB
                g2d = imageOut.createGraphics();
                g2d.setBackground(Color.WHITE);
                g2d.clearRect(0, 0, imageOut.getWidth(), imageOut .getHeight());
                g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
                tx = new AffineTransform();
                tx.scale(scale, scale);
                g2d.drawImage(imageIn, tx, null);
                g2d.dispose();
                imageIn = new ImageIcon(imageOut).getImage();
                previousIntermediateSize = intermediateSize;
            }
        }
        else {
            // This enforces a rule that we always have an 8-bit image with white background for the thumbnail.  Plus, for large
            // images, this makes subsequent downscaling really fast because we are working on a large 8-bit image
            // instead of a large 12 or 24 bit image, so the downstream effect is very noticable.
            imageOut = new BufferedImage(imageIn.getWidth(null), imageIn.getHeight(null), BufferedImage.TYPE_INT_RGB);
            g2d = imageOut.createGraphics();
            g2d.setBackground(Color.WHITE);
            g2d.clearRect(0, 0, imageOut.getWidth(), imageOut.getHeight());
            tx = new AffineTransform();
            tx.setToIdentity(); //use identity matrix so image is copied exactly
            g2d.drawImage(imageIn, tx, null);
            g2d.dispose();
        }
 
        // JPEG-encode the image and write to file.
        saveImageAsJPEG(imageOut, fileOut);
 
        return imageOut;
    }
 
}

package com.raulraja.util.thumbnails.impl;
 
import com.raulraja.util.thumbnails.ThumbnailGenerator;
 
import java.io.InputStream;
import java.io.File;
import java.io.IOException;
 
/**
 * Empty impl for generating thumbnails for pdfs
 */
public class PDFThumbnailGeneratorImpl implements ThumbnailGenerator {
	/**
	 * Create the thumbnail.  The thumbnail should always save as a JPEG file.
	 *
	 * @param inputStream	  The source data.
	 * @param fileOut		  The output file.
	 * @param largestDimension The max width and height.  The generator should size the thumbnail so
	 *                         that the width and height both stay within this limit.
	 * @param hint			 Optional hint that was returned from the prior thumbnail generation
	 *                         on this same file, null if none was returned or if this is the first
	 *                         thumbnail in this context.
	 * @return an optional hint object that will be passed to subsequent thumbnail generation calls
	 *         for this same source data.  Return null if you don't use hints, otherwise return some
	 *         object which allows you to communicate extra information to the next round, such as
	 *         the scaled image already loaded.
	 */
	public Object createThumbnail(InputStream inputStream, File fileOut, int largestDimension, Object hint) throws IOException {
		throw new UnsupportedOperationException("thumbnails for pdf's not implemented in this tutorial...");
	}
}

package com.raulraja.util.upload;
 
import com.raulraja.util.thumbnails.ThumbnailGeneratorEngine;
import org.apache.log4j.Logger;
import org.springframework.validation.BindException;
import org.springframework.web.bind.ServletRequestDataBinder;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.support.ByteArrayMultipartFileEditor;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.SimpleFormController;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
 
/**
 * File upload service to demonstrate files uploads and handing over the files to the thumbnail generation system
 */
public class FileUploadService extends SimpleFormController {
 
	private final static Logger log = Logger.getLogger(FileUploadService.class);
 
	private ThumbnailGeneratorEngine thumbnailGeneratorEngine;
 
	public void setThumbnailGeneratorEngine(ThumbnailGeneratorEngine thumbnailGeneratorEngine) {
		this.thumbnailGeneratorEngine = thumbnailGeneratorEngine;
	}
 
	protected ModelAndView onSubmit(HttpServletRequest request, HttpServletResponse response, Object command, BindException errors) throws Exception {
		FileUpload fileUpload = (FileUpload) command;
		MultipartFile file = fileUpload.getFile();
		InputStream stream = file.getInputStream();
		try {
			//generate thumbnails
			thumbnailGeneratorEngine.generateThumbnails(file.getName(), stream, file.getContentType());
		} catch (Exception e) {
			log.error(e);
		} finally {
			stream.close();
		}
		return super.onSubmit(request, response, command, errors);
	}
 
	protected void initBinder(HttpServletRequest request, ServletRequestDataBinder binder)
			throws ServletException {
		// to actually be able to convert Multipart instance to byte[]
		// we have to register a custom editor
		binder.registerCustomEditor(byte[].class, new ByteArrayMultipartFileEditor());
		// now Spring knows how to handle multipart object and convert them
	}
 
}

package com.raulraja.util.upload;
 
import org.springframework.web.multipart.MultipartFile;
 
/**
 * A file upload object
 */
public class FileUpload {
 
	private MultipartFile file;
 
	public MultipartFile getFile() {
		return file;
	}
 
	public void setFile(MultipartFile file) {
		this.file = file;
	}
 
}

 
raul-raja-martinezs-macbook:test raul$ ./google-code-svn-to-download.sh -p raulrajatutorials -u raulraja -w your_google_code_pass -s "my file summary" -l tag1,tag2,tag3,tag4 -f myfilename
fetching raulrajatutorials from google svn repository
cleaning up local svn files
zipping raulrajatutorials to myfilename.zip
removing svn downloaded files
uploading raulrajatutorials to google code downloads area
The file was uploaded successfully.
URL: http://raulrajatutorials.googlecode.com/files/myfilename.ZIP
Removing myfilename.zip after uploaded to google

 
#!/bin/bash
# checkouts your google code project and makes a zip and uploads it to the downloads section
#  -s SUMMARY, Short description of the file
#  -p PROJECT, Google Code project name
#  -u USER, Your Google Code username
#  -w PASSWORD, Your Google Code password
#  -l LABELS, An optional list of comma-separated labels to attach to the file
#  -f FILENAME, the file name to be used on the upload
 
SCRIPT_USAGE="\
\n    Usage: $0
\n
\n    Required parameters
\n
\n      -p Google Code project name
\n
\n    Optional parameters
\n
\n      -u Your Google Code username (will ask if not provided)
\n      -w Your Google Code password (will ask if not provided)
\n      -s Short description of the file (Defaults to project name)
\n      -l A list of comma-separated labels to attach to the file
\n      -f the name of the file to upload (Defaults to project name)
\n
\n"
 
 
# Iterate over the options passed to the script
while getopts "s:p:u:w:l:f:" MYOPTION;
do
	case "$MYOPTION" in
		s)   GOOGLE_CODE_SUMMARY="$OPTARG" ;;
		p)   GOOGLE_CODE_PROJECT="$OPTARG" ;;
		u)   GOOGLE_CODE_USER="$OPTARG" ;;
		w)   GOOGLE_CODE_PASSWORD="$OPTARG" ;;
		l)   GOOGLE_CODE_LABELS="$OPTARG" ;;
		f)   GOOGLE_CODE_FILENAME="$OPTARG" ;;
	esac
done
 
 
# if all the required options are there
if [ -z "${GOOGLE_CODE_PROJECT}" ];
then
    # One of the required arguments is missing
    echo -e $SCRIPT_USAGE
else
     # setup default values if necessary
    GOOGLE_CODE_FILENAME=${GOOGLE_CODE_FILENAME:="$GOOGLE_CODE_PROJECT"}
    GOOGLE_CODE_SUMMARY=${GOOGLE_CODE_SUMMARY:="latest $GOOGLE_CODE_PROJECT"}
    # fetch project from svn
    echo "fetching $GOOGLE_CODE_PROJECT from google svn repository"
    svn export -q http://$GOOGLE_CODE_PROJECT.googlecode.com/svn/trunk/ $GOOGLE_CODE_PROJECT
 
    # zip the project
    echo "zipping $GOOGLE_CODE_PROJECT to $GOOGLE_CODE_FILENAME.zip"
    zip -r -q $GOOGLE_CODE_FILENAME.zip $GOOGLE_CODE_PROJECT
 
    # remove the svn download folders
    echo "removing svn downloaded files"
    rm -rf $GOOGLE_CODE_PROJECT
 
    # upload the project to the google code downloads
    echo "uploading $GOOGLE_CODE_PROJECT to google code downloads area"
    ./googlecode_upload.py -s "$GOOGLE_CODE_SUMMARY" -p "$GOOGLE_CODE_PROJECT" -u "$GOOGLE_CODE_USER" -w "$GOOGLE_CODE_PASSWORD" -l "$GOOGLE_CODE_LABELS" $GOOGLE_CODE_FILENAME.ZIP
 
    # remove the zip file
    echo "Removing $GOOGLE_CODE_FILENAME.zip after uploaded to google"
    rm -rf $GOOGLE_CODE_FILENAME.ZIP   
fi

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd"
       default-autowire="byName">
 
    <!-- A processor that know about Person objects -->
    <bean id="personProcessor" class="com.raulraja.processor.impl.PersonProcessorImpl"/>
 
    <!-- A processor that knows about Place objects -->
    <bean id="placeProcessor" class="com.raulraja.processor.impl.PlaceProcessorImpl"/>
 
    <!-- A configured processing engine that maps object types to their processors and delegates calls to each one of them -->
    <bean id="processingEngine" class="com.raulraja.processor.impl.DefaultProcessingEngineImpl">
        <property name="processors">
            <map>
                <entry key="com.raulraja.domain.Person" value-ref="personProcessor"/>
                <entry key="com.raulraja.domain.Place" value-ref="placeProcessor"/>
            </map>
        </property>
    </bean>
 
    <!--
        This handler is actually not required but used for demonstrating the tutorial by invoking
        http://localhost:port/tutorialName
    -->
    <bean id="serviceInvokerHandler" class="com.raulraja.util.handler.impl.ServiceInvokerHandlerImpl" autowire="autodetect" />
 
</beans>

package com.raulraja.processor;
 
/**
 * A processing engine that you can feed objects to and processes them
 */
public interface ProcessingEngine<Target> {
 
	/**
	 * Processes something
	 * @param target the target object to be processed
	 */
	void process(Target target);
 
}

 
package com.raulraja.processor.impl;
 
import com.raulraja.processor.ProcessingEngine;
import com.raulraja.processor.Processor;
import org.apache.log4j.Logger;
 
import java.util.Map;
 
/**
 * Default impl of the processing engine based on a spring configured service.
 * Delegates processing calls to the right processor
 */
public class DefaultProcessingEngineImpl<Target> implements ProcessingEngine<Target> {
 
	private final static Logger log = Logger.getLogger(DefaultProcessingEngineImpl.class);
 
	/**
	 * A map of processor that maps object types to a processor that know how to process it
	 */
	private Map<Class<Target>, Processor<Target>> processors;
 
	public void setProcessors(Map<Class<Target>, Processor<Target>> processors) {
		this.processors = processors;
	}
 
	/**
	 * Processes something
	 *
	 * @param target the target object to be processed
	 */
	public void process(Target target) {
		log.debug("started processing " + target);
		Processor<Target> processor = processors.get(target.getClass());
		if (processor != null) {
			processor.process(target);
		} else {
			log.debug("processor not found for " + target);		
		}
		log.debug("finished processing " + target);
	}
}

package com.raulraja.processor;
 
/**
 * A service that know how to process a type of object
 */
public interface Processor<Target> {
 
	/**
	 * Processes something
	 * @param target the target object to be processed
	 */
	void process(Target target);
 
}

package com.raulraja.processor.impl;
 
import com.raulraja.domain.Person;
import com.raulraja.processor.Processor;
import org.apache.log4j.Logger;
 
/**
 * Demonstrates how a Person can be processed
 */
public class PersonProcessorImpl implements Processor<Person> {
 
	private final static Logger log = Logger.getLogger(PersonProcessorImpl.class);
 
	/**
	 * Processes something
	 *
	 * @param person the target object to be processed
	 */
	public void process(Person person) {
   		log.debug(person + " something is being done to a person object");
	}
}

package com.raulraja.processor.impl;
 
import com.raulraja.domain.Place;
import com.raulraja.processor.Processor;
import org.apache.log4j.Logger;
 
/**
 * Demonstrates how a Person can be processed
 */
public class PlaceProcessorImpl implements Processor<Place> {
 
	private final static Logger log = Logger.getLogger(PlaceProcessorImpl.class);
 
	/**
	 * Processes something
	 *
	 * @param place the target object to be processed
	 */
	public void process(Place place) {
   		log.debug(place + " something is being done to a place object");
	}
}

package com.raulraja.domain;
 
/**
 * Represents a person
 */
public class Person {
}

package com.raulraja.domain;
 
/**
 * Represents a place
 */
public class Place {
}

package com.raulraja.util.handler.impl;
 
import com.raulraja.processor.ProcessingEngine;
import com.raulraja.domain.Person;
import com.raulraja.domain.Place;
import org.springframework.web.HttpRequestHandler;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
 
/**
 * Frontend entry point for the demo
 */
public class ServiceInvokerHandlerImpl implements HttpRequestHandler {
 
	/**
	 * The engine that processes object types
	 */
	private ProcessingEngine<Object> processingEngine;
 
	/**
	 * sets the engine that processes object types
	 * @param processingEngine the engine
	 */
	public void setProcessingEngine(ProcessingEngine<Object> processingEngine) {
		this.processingEngine = processingEngine;
	}
 
	/**
	 * Process the given request, generating a response.
	 *
	 * @param request  current HTTP request
	 * @param response current HTTP response
	 * @throws javax.servlet.ServletException in case of general errors
	 * @throws java.io.IOException			in case of I/O errors
	 */
	public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		Person person = new Person();
		Place place = new Place();
		processingEngine.process(person);
		processingEngine.process(place);
	}
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:cxf="http://cxf.apache.org/core"
       xmlns:jaxws="http://cxf.apache.org/jaxws"
       xmlns:jaxrs="http://cxf.apache.org/jaxrs"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
       http://cxf.apache.org/core
       http://cxf.apache.org/schemas/core.xsd
       http://cxf.apache.org/jaxws
       http://cxf.apache.org/schemas/jaxws.xsd
       http://cxf.apache.org/jaxrs
       http://cxf.apache.org/schemas/jaxrs.xsd"
       default-autowire="byName">
 
    <!-- Load CXF modules from cxf.jar -->
    <import resource="classpath:META-INF/cxf/cxf.xml"/>
    <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml"/>
    <import resource="classpath:META-INF/cxf/cxf-servlet.xml"/>
    <import resource="classpath:META-INF/cxf/cxf-extension-jaxrs-binding.xml"/>
 
    <cxf:bus>
        <cxf:features>
            <cxf:logging/>
        </cxf:features>
    </cxf:bus>
 
    <!-- The hello world service -->
    <bean id="helloWorldService" class="com.raulraja.ws.impl.HelloWorldServiceImpl" autowire="autodetect"/>
 
    <!-- Exposing the Helloworld service as a rest service -->
    <jaxrs:server id="restServer" address="/rest/">
        <jaxrs:serviceBeans>
            <ref bean="helloWorldService"/>
        </jaxrs:serviceBeans>
        <jaxrs:extensionMappings>
            <entry key="feed" value="application/atom+xml"/>
            <entry key="json" value="application/json"/>
            <entry key="xml" value="application/xml"/>
            <entry key="html" value="text/html"/>
        </jaxrs:extensionMappings>
    </jaxrs:server>
 
 
    <!-- Exposing the HelloWorld service as a SOAP service -->
    <bean id="jaxbBean"
          class="org.apache.cxf.jaxb.JAXBDataBinding"
          scope="prototype"/>
 
    <bean id="jaxws-and-aegis-service-factory"
          class="org.apache.cxf.jaxws.support.JaxWsServiceFactoryBean"
          scope="prototype">
        <property name="dataBinding" ref="jaxbBean"/>
        <property name="serviceConfigurations">
            <list>
                <bean class="org.apache.cxf.jaxws.support.JaxWsServiceConfiguration"/>
                <bean class="org.apache.cxf.aegis.databinding.AegisServiceConfiguration"/>
                <bean class="org.apache.cxf.service.factory.DefaultServiceConfiguration"/>
            </list>
        </property>
    </bean>
 
 
    <jaxws:endpoint id="helloWorldServiceEndpoint"
                    serviceName="HelloWorld"
                    implementorClass="com.raulraja.ws.HelloWorldService"
                    implementor="#helloWorldService"
                    address="/helloWorldService">
        <jaxws:serviceFactory>
            <ref bean="jaxws-and-aegis-service-factory"/>
        </jaxws:serviceFactory>
    </jaxws:endpoint>
 
</beans>

package com.raulraja.ws;
 
import javax.ws.rs.Path;
import javax.ws.rs.GET;
import javax.jws.WebService;
import javax.jws.WebMethod;
 
/**
 * The hello world service interface exposed as soap and rest
 *
 * @ WebService is for soap
 * @ Path is for the rest top path
 */
@Path("/helloWorldService/")
@WebService(serviceName = "HelloWorld", name = "HelloWorldService", targetNamespace = "http://ws.raulraja.com")
public interface HelloWorldService {
 
	/**
	 * Simple methods that says hello
	 *
	 * @return hello world rest and soap!!!
	 * @ WebMethod is for soap
	 * @ GET is for REST
	 * @ Path is for the REST service path
	 */
	@WebMethod
	@GET
	@Path("/")
	HelloWorld sayHello();
 
}

package com.raulraja.ws.impl;
 
import com.raulraja.ws.HelloWorld;
import com.raulraja.ws.HelloWorldService;
 
/**
 * Implementation of the hello world web service.
 */
public class HelloWorldServiceImpl implements HelloWorldService {
 
	/**
	 * Simple methods that says hello
	 *
	 * @return hello world rest and soap!!!
	 */
	public HelloWorld sayHello() {
		HelloWorld helloWorld = new HelloWorld();
		helloWorld.setMessage("Hello world rest and soap!!!");
		return helloWorld;
	}
}

package com.raulraja.ws;
 
import javax.xml.bind.annotation.XmlRootElement;
 
/**
 * Hello world object that demonstrates the service
 */
@XmlRootElement
public class HelloWorld {
 
	/**
	 * the message
	 */
	private String message;
 
	/**
	 * @return the message
	 */
	public String getMessage() {
		return message;
	}
 
	/**
	 * @param message sets the message
	 */
	public void setMessage(String message) {
		this.message = message;
	}
}