Springfuse - Online java code generation

Conversation using JPA 2, JSF 2, PrimeFaces and the Spring Framework

2013-03-05T00:00:00-08:00

Conversation with JSF2

In this article we give you a bird eye view on how we implement custom Conversations for data-driven applications using JPA 2, JSF 2, PrimeFaces and the Spring Framework.

Our solution is using neither CDI nor Spring Web Flow, but a home-made API. We believe our solution has several advantages:

It is XML free, thus refactorable, debuggable.
It uses callbacks, which allows us to use a JSF views as black boxes. Spring Web Flow has a similar feature, but it is in XML.
The core API comprises 15 classes, it is understandable in one day and can be improved to fit your custom needs.
It does not require any Java EE application server, a bare Jetty or Tomcat is enough.

The full implementation is available in all projets generated by SpringFuse. You can browse a project example on github.

Conversation

A conversation is a kind of inner web session. It has a start and an end. In between it enforces a strict navigation between pages (like spring webflow or up coming Faces Flow do)

For our case, data-driven applications, a conversation is created each time the user wants to edit a JPA Entity. It starts with a search page, continue with an edit page and when the user is done editing, he goes back the the search page. From there, he can click from the menu a quit button which terminates the conversation.

From the main edit page the user can of course edit the entity's properties but he can also manage the entity's associations (if any).

For example, if the entity has a many-to-many association, the user can add a new entity to this many-to-many association. To do so the user can navigate to the target entity's edit page.

But when should the entity be added to the collection ?

before navigating to the target entity's edit page?
after navigating to the target entity's edit page?

If we choose the first approach we have to handle the case when the user changes his mind and finally prefer not to add the entity.

The second approach is more natural, we add it only if the user clicks a 'Submit' button in the target entity's edit page.

But wait a second. Other entities could also have a many-to-many association to the same target entity. The target edit page should be therefore reusable, that is it should not 'know' from which page the user is coming from. For this reason we introduce callback.

Here is a concrete example

An Account entity has a many-to-many association with a Role entity. From the Account edit page, when the user clicks on the icon, it invokes the addRole method which ultimately sets a callback and return the target entity's edit page (we rely on JSF implicit navigation).

Here is an extract of the Account entity edit page:

Here is an extract of the AccountEditForm class, which is a statefull controller:

public String addRole() {
    ConversationContext<Role> ctx = RoleController.newEditContext(new Role());
    ctx.setLabelWithKey("account_roles");
    ctx.setCallBack(addRoleCallBack);
    getCurrentConversation().setNextContextSub(ctx);
    return ctx.view();
}

protected ConversationCallBack<Role> addRoleCallBack = new ConversationCallBack<Role>() {
    private static final long serialVersionUID = 1L;

    @Override
    protected void onOk(Role role) {
        getAccount().addRole(role);
        messageUtil.infoEntity("status_added_new_ok", role);
    }
};

Here is an extract of the target Role edit page:

As you have guessed, when the user clicks the "Submit" button above, the onOk(Role role) callback is invoked. In this case it adds the Role to the account's role collection.

Great, but how do we know we should go back to the account's edit page once the role is added?

For each page we create a new ConversationContext, each context has a view property which holds an uri.

Here is the code that created the ConversationContext to edit the Role entity above:

public final static String editUri = "/domain/roleEdit.faces";

/**
 * Helper to construct a new ConversationContext to edit an Role.
 * @param role the entity to edit.
 */
public static ConversationContext<Role> newEditContext(final Role role) {
    ConversationContext<Role> ctx = new ConversationContext<Role>();
    ctx.setEntity(role); // used by GenericEditForm.init()
    ctx.setViewUri(editUri);
    return ctx;
}

Like for the role edit page, the account edit page also has a ConversationContext (not shown here).

As the user goes forward in the conversation, we stack up (push) conversation contextes. Going backward is just a matter of returning the previous ConversationContext's view property after the callback invocation. Of course, when going backward, the current ConversationContext is popped from the stack.

For each association we have a similar mechanism, for example, if the user wants to add some existing roles to the account entity, it clicks on the icon. This time, the destination page is not the role edit page but the role search page, which allows the user to select one or more existing roles.

Here is the callback for existing roles selection:

public String selectRole() {
    ConversationContext<Role> ctx = RoleController.newSearchContext();
    ctx.setLabelWithKey("account_roles");
    ctx.setCallBack(selectRoleCallBack);
    ctx.setVar("multiCheckboxSelection", true);
    getCurrentConversation().setNextContextSub(ctx);
    return ctx.view();
}

protected ConversationCallBack<Role> selectRoleCallBack = new ConversationCallBack<Role>() {
    private static final long serialVersionUID = 1L;

    @Override
    protected void onSelected(List<Role> roles) {
        for (Role role : roles) {
            Role mergedRole = getCurrentConversation().getEntityManager().merge(role);
            if (!getAccount().containsRole(mergedRole)) {
                getAccount().addRole(mergedRole);
                messageUtil.infoEntity("status_added_existing_ok", mergedRole);
            }
        }
    }
};

And here is an extract of the target search role page:

When the user clicks on the icon, the callback onSelected(List<Role> roles) is invoked. This callback is more interesting, as you can see we keep an EntityManager instance in the Conversation.

The conversation allows you to move forward/backward through the entity graph, the changes you make are retained in this conversation's entityManager. Nothing is committed until you invoke a service method annotated with a read-write @Transactional This means you can have a long conversation to prepare all the desired changes and commit them in a short transaction.

This works great, however, there is one drawback: If you use the conversation's entityManager in search pages, you may not see changes made by others as the entityManager guaranties you repeatable reads. For this reason, we do not use the conversation's entityManager in search page. This way we are sure to display the most up to date data to the user. You should now better understand why we need to merge the selected roles back in the conversation's entity manager.

Note that both the role search page and the role edit page that are used in the Account's conversation are also used in the Role conversation... reusability we said.

Conversation Scope

Our Conversation API defines a custom Spring Scope, named conversation.

Beans in the conversation scope reside in a ConversationContext. They are visible only when the conversation is bound to the current Thread of execution and their hosting ConversationContext is on top of the conversation's contextes stack. This allows a conversation to have 2 'conversation scoped' beans with the same name (they just have to reside in 2 different ConversationContext). This prevents bean name clash in complex navigation scenario within the same conversation.

Misc

The user can have several conversations in parallel, we provide a menu Conversations menu to switch from one conversation to another
We limit the number of Conversation per user. In case the max number of conversations is reached a warning page is displayed.
etc.

Conclusion

This simple API:

enforces navigation
supports extended persitence context (i.e. we reuse the same entityManager in conversation's edit pages)
allows page reuse thanks to callbacks
is strongly typed
is easy to understand (assuming you are not a beginner).

What else would you want? Your answer is probably: we want CDI!

And we agree with you, if someone send us the source code to do the same thing using CDI we would be delighted to propose it in the code we generate :-)

If you want to know more, the best is to study the source code and run it on your computer.

We encourage you to:

Have fun !

The Jaxio/SpringFuse team.

Follow @springfuse

Unique Validator with JSF2 and JPA2 but without Bean Validation

2012-09-27T00:00:00-07:00

Unique Validator with JSF2 and JPA2 but without Bean Validation

Such a classic! One of your form's fields must be unique in the database.

As we use JPA2 and bean validation, our fist thought was let's use bean validation. But soon, we realized this is not as easy as it should be:

Bean Validation, does not provide any unique validator for JPA (ok I am a bit exigent)
from the validator implementation you don't have access to the entity name
you cannot inject beans within Bean Validation validator implementation. For instance, you cannot inject the entityManager.

Hopefully, your devoted team has found a solution and is sharing it here with you (and in the projects generated by springfuse)

Instead of annotating an entity property, we leverage the <f:validateBean> tag directly in the view.

Here is an usage example:

<app:input id="username" value="#{account.username}" size="100" label="${msg.account_username}" required="true">
    <f:validateBean binding="#{jpaUniqueValidator}" entity="${account}" property="username" />
</app:input>

When an already existing username is entered, the validator fails and a nice error message is displayed.

Source code

Here is the jpaUniqueValidator component source code:

@FacesValidator(value = "jpaUniqueValidator")
@Component
@Scope(BeanDefinition.SCOPE_PROTOTYPE)
public class JpaUniqueValidator implements Validator {

    @Inject
    private JpaUniqueSupport jpaUniqueSupport;
    @Inject
    private ResourcesUtil resourcesUtil;

    @Override
    public void validate(FacesContext context, UIComponent component, Object value) throws ValidatorException {
        if (entity == null && isBlank(property)) {
            return;
        }

        if (entity == null) {
            throw new IllegalStateException("Missing 'entity' attribute");
        }

        if (property == null) {
            throw new IllegalStateException("Missing 'property' attribute");
        }

        if (!jpaUniqueSupport.isUnique(entity, property, value)) {
            FacesMessage fm = new FacesMessage(resourcesUtil.getProperty(entity.getClass().getSimpleName().toLowerCase() + "_" + property + "_already_exists"));
            fm.setSeverity(SEVERITY_ERROR);
            throw new ValidatorException(fm);
        }
    }

    private Identifiable<?> entity;
    private String property;

    public void setEntity(Identifiable<?> entity) {
        this.entity = entity;
    }

    public Identifiable<?> getEntity() {
        return entity;
    }

    public void setProperty(String property) {
        this.property = property;
    }

    public String getProperty() {
        return property;
    }
}

It invokes the jpaUniqueSupport.isUnique(entity, property, value) method which is listed below:

@Named
@Singleton
public class JpaUniqueSupport {
    @PersistenceContext
    private EntityManager entityManager;

    public boolean isUnique(Identifiable<?> entity, String propertyName, Object propertyValue) {
        if (entity == null || propertyValue == null) {
            return true;
        }
        checkJpaEntityPresence(entity);
        return !existsInDatabase(getEntityName(entity), entity, propertyName, propertyValue);
    }

    private boolean existsInDatabase(String entityName, Identifiable<?> entity, String propertyName, Object propertyValue) {
        if (entity.isIdSet()) {
            return existsInDatabaseOnOtherObjects(entityName, entity, propertyName, propertyValue);
        } else {
            return existsInDatabaseOnAllObjects(entityName, entity, propertyName, propertyValue);
        }
    }

    private boolean existsInDatabaseOnAllObjects(String entityName, Identifiable<?> entity, String propertyName, Object propertyValue) {
        return entityManager //
                .createQuery( //
                        format("select count(c) from %s c where %s = :propertyValue", entityName, propertyName), Long.class) //
                .setParameter("propertyValue", propertyValue) //
                .getSingleResult() > 0;
    }

    private boolean existsInDatabaseOnOtherObjects(String entityName, Identifiable<?> entity, String propertyName, Object propertyValue) {
        return entityManager //
                .createQuery( //
                        format("select count(c) from %s c where %s = :propertyValue and %s != :id", //
                                entityName, propertyName, getPkAttributeName(entity.getClass())), Long.class) //
                .setParameter("propertyValue", propertyValue) //
                .setParameter("id", entity.getId()) //
                .getSingleResult() > 0;
    }

    private void checkJpaEntityPresence(Identifiable<?> value) {
        Entity entity = findAnnotation(value.getClass(), Entity.class);
        if (entity == null) {
            throw new IllegalStateException(value.getClass().getSimpleName() + " is not a JPA entity");
        }
    }

    private String getEntityName(Identifiable<?> value) {
        Entity entity = findAnnotation(value.getClass(), Entity.class);
        if (isBlank(entity.name())) {
            return value.getClass().getSimpleName();
        }
        return entity.name();
    }

    private String getPkAttributeName(Class<?> clazz) {
        String pkAttributeName = getPkAttributeName(clazz, Id.class);
        return pkAttributeName != null ? pkAttributeName : getPkAttributeName(EmbeddedId.class);
    }

    @SuppressWarnings( { "rawtypes", "unchecked" })
    private String getPkAttributeName(Class<?> clazz, Class annotation) {
        for (Method m : clazz.getMethods()) {
            if (findAnnotation(m, annotation) != null) {
                return methodToProperty(m);
            }
        }
        for (Field f : clazz.getFields()) {
            if (f.getAnnotation(annotation) != null) {
                return f.getName();
            }
        }
        return null;
    }

    private String methodToProperty(Method m) {
        String value = m.getName();
        if (value.startsWith("get")) {
            int length = "get".length();
            return value.substring(length, length + 1).toLowerCase() + value.substring(length + 1);
        } else if (value.startsWith("is")) {
            int length = "is".length();
            return value.substring(length, length + 1).toLowerCase() + value.substring(length + 1);
        } else {
            return value;
        }
    }
}

Enjoy!

The SpringFuse/Jaxio team.

JPA2 Query By Example

2012-09-05T00:00:00-07:00

Query by example with JPA 2

In this post, we present our work on providing Query By Example for JPA 2 in projects generated by SpringFuse.

The code uses JPA 2 standard only, it does not rely on any JPA implementation.

More Resources

What is Query By Example?

The idea is to use an entity as a parameter holder when doing query on an entity. For example, assuming we have an Account entity with a lastname property. Here is how to do a simple query by example:

Account account = new Account();
account.setLastname("agger"); // will apply LIKE %agger%
    
List<Account> result = accountRepository.find(account);

This codes leads in fine to following SQL query:

select
    account0_.id as id3_,
    account0_.address_id as address2_3_,
    account0_.BIRTH_DATE as BIRTH3_3_,
    account0_.civility as civility3_,
    account0_.description as descript5_3_,
    account0_.email as email3_,
    account0_.FIRST_NAME as FIRST7_3_,
    account0_.is_enabled as is8_3_,
    account0_.LAST_NAME as LAST9_3_,
    account0_."PASSWORD" as PASSWORD10_3_,
    account0_.login as login3_,
    account0_.version as version3_ 
from
    Account account0_ 
where
    lower(account0_.LAST_NAME)=? limit ?

Mixing Query by Example and Range Query.

Now, let's imagine that you also want to restrict the query above to all accounts having their date of birth between 1940 and 1945 included. Of course, the entity does not have the appropriate property (from & to). For this reason, we introduce some additional RangeDate parameters. Here is an example:

Calendar from = Calendar.getInstance();
from.set(1940, 0, 1);

Calendar to = Calendar.getInstance();
to.set(1945, 11, 31);
Account account = new Account();

// like
account.setLastName("Jagger");        

// between from and to
RangeDate<Account> birthDateRange = new RangeDate<Account>(Account_.birthDate);
birthDateRange.setFrom(from.getTime());
birthDateRange.setTo(to.getTime());

SearchParameters searchParameters = new SearchParameters();
searchParameters.addRange(birthDateRange);

List<Account> result = accountRepository.find(account, searchParameters);

Note that you can add ranges of any type: Integer, Long, LocalDate (joda time), BigDecimal, etc...

This codes leads in fine to following SQL query:

select
    account0_.id as id2_,
    account0_.address_id as address2_2_,
    account0_.BIRTH_DATE as BIRTH3_2_,
    account0_.civility as civility2_,
    account0_.description as descript5_2_,
    account0_.email as email2_,
    account0_.FIRST_NAME as FIRST7_2_,
    account0_.is_enabled as is8_2_,
    account0_.LAST_NAME as LAST9_2_,
    account0_."PASSWORD" as PASSWORD10_2_,
    account0_.login as login2_,
    account0_.version as version2_ 
from
    Account account0_ 
where
    (
        account0_.BIRTH_DATE between ? and ?
    ) 
    and lower(account0_.LAST_NAME)=? limit ?

Query all string properties in a OR clause

You can also query all entities having at least one of their String property matching a given value, here is how:

    
List<Account> result = accountRepository.find("foo");

Here is the resulting SQL query:

    
select
    account0_.id as id1_,
    account0_.address_id as address2_1_,
    account0_.BIRTH_DATE as BIRTH3_1_,
    account0_.civility as civility1_,
    account0_.description as descript5_1_,
    account0_.email as email1_,
    account0_.FIRST_NAME as FIRST7_1_,
    account0_.is_enabled as is8_1_,
    account0_.LAST_NAME as LAST9_1_,
    account0_."PASSWORD" as PASSWORD10_1_,
    account0_.login as login1_,
    account0_.version as version1_ 
from
    Account account0_ 
where
    lower(account0_."PASSWORD") like ? 
    or lower(account0_.email) like ? 
    or lower(account0_.id) like ? 
    or lower(account0_.FIRST_NAME) like ? 
    or lower(account0_.LAST_NAME) like ? 
    or lower(account0_.description) like ? 
    or lower(account0_.login) like ? limit ?

Pagination

Pagination parameters are set on the SearchParameters, as in the example below:

    
Account account = new Account();
account.setLastName("agger");

SearchParameters searchParameters = new SearchParameters();
searchParameters.setFirstResult(10); // the 11th element
searchParameters.setMaxResults(25); // page size

List<Account> result = accountRepository.find(account, searchParameters);

We now have an offset in the sql query:

    
select
    account0_.id as id5_,
    account0_.address_id as address2_5_,
    account0_.BIRTH_DATE as BIRTH3_5_,
    account0_.civility as civility5_,
    account0_.description as descript5_5_,
    account0_.email as email5_,
    account0_.FIRST_NAME as FIRST7_5_,
    account0_.is_enabled as is8_5_,
    account0_.LAST_NAME as LAST9_5_,
    account0_."PASSWORD" as PASSWORD10_5_,
    account0_.login as login5_,
    account0_.version as version5_ 
from
    Account account0_ 
where
    lower(account0_.LAST_NAME)=? limit ? offset ?

GenericDao Implementation

The full implementation is available on github or in any generated project.

Here are few excepts

find method in GenericDao

    
public List<E> find(E entity, SearchParameters sp) {
    if (sp.hasNamedQuery()) {
        return (List<E>) getNamedQueryUtil().findByNamedQuery(sp);
    }

    CriteriaBuilder builder = entityManager.getCriteriaBuilder();
    CriteriaQuery<E> criteriaQuery = builder.createQuery(type);
    Root<E> root = criteriaQuery.from(type);

    // predicate
    Predicate predicate = getPredicate(root, criteriaQuery, builder, entity, sp);
    if (predicate != null) {
        criteriaQuery = criteriaQuery.where(predicate);
    }

    // order by
    criteriaQuery.orderBy(sp.getJpaOrders(root, builder));

    TypedQuery<E> typedQuery = entityManager.createQuery(criteriaQuery);

    // cache
    setCacheHints(typedQuery, sp);

    // pagination
    typedQuery.setFirstResult(sp.getFirstResult());
    typedQuery.setMaxResults(sp.getMaxResults());

    // execution
    List<E> entities = typedQuery.getResultList();
    if (log.isDebugEnabled()) {
        log.debug("Returned " + entities.size() + " elements");
    }

    return entities;
}

This method is responsible for constructing the query and executing it. It invokes the getPredicate method which construct a single Predicate out of the passed example and search parameters. Here it is:

    
protected <R> Predicate getPredicate(Root<E> root, CriteriaQuery<R> query, CriteriaBuilder builder, E entity, SearchParameters sp) {
    List<Predicate> predicates = newArrayList();

    // search by range
    Predicate rangePredicate = ByRangeUtil.byRanges(root, query, builder, sp.getRanges(), type);
    if (rangePredicate != null) {
        predicates.add(rangePredicate);
    }

    // search by example
    Predicate examplePredicate = getByExamplePredicate(root, entity, sp, builder);
    if (examplePredicate != null) {
        predicates.add(examplePredicate);
    }

    // composite pk
    Predicate comppositePkPredicate = getByCompositePkPredicate(root, entity, sp, builder);
    if (comppositePkPredicate != null) {
        predicates.add(comppositePkPredicate);
    }

    // search by pattern
    Predicate patternPredicate = byPatternUtil.byPattern(root, query, builder, sp, type);
    if (patternPredicate != null) {
        predicates.add(patternPredicate);
    }

    return JpaUtil.andPredicate(predicates, builder);
}

protected Predicate getByExamplePredicate(Root<E> root, E entity, SearchParameters sp, CriteriaBuilder builder) {
    return byExampleUtil.byExampleOnEntity(root, entity, sp, builder);
}

Here is the ByRangeUtil.byRanges method:

    
public static <E> Predicate byRanges(Root<E> root, CriteriaQuery<?> query, CriteriaBuilder builder, final List<Range<?, ?>> ranges, final Class<E> type) {

    List<Predicate> predicates = newArrayList();
    for (Range<?, ?> r : ranges) {
        @SuppressWarnings("unchecked")
        Range<E, ?> range = (Range<E, ?>) r;
        if (range.isSet()) {
            Predicate rangePredicate = buildRangePredicate(range, root, builder);

            if (rangePredicate != null) {
                if (!range.isIncludeNullSet() || range.getIncludeNull() == FALSE) {
                    predicates.add(rangePredicate);
                } else {
                    predicates.add(builder.or(rangePredicate, builder.isNull(root.get(range.getField()))));
                }
            }

            // no range at all, let's take the opportunity to keep only null...
            if (TRUE == range.getIncludeNull()) {
                predicates.add(builder.isNull(root.get(range.getField())));
            } else if (FALSE == range.getIncludeNull()) {
                predicates.add(builder.isNotNull(root.get(range.getField())));
            }
        }
    }

    return JpaUtil.andPredicate(predicates, builder);

}

private static <D extends Comparable<? super D>, E> Predicate buildRangePredicate(Range<E, D> range, Root<E> root, CriteriaBuilder builder) {
    if (range.isBetween()) {
        return builder.between(root.get(range.getField()), range.getFrom(), range.getTo());
    } else if (range.isFromSet()) {
        return builder.greaterThanOrEqualTo(root.get(range.getField()), range.getFrom());
    } else if (range.isToSet()) {
        return builder.lessThanOrEqualTo(root.get(range.getField()), range.getTo());
    }
    return null;
}

And finally, the most complex part, the core of Query By Example, the ByExampleUtil helper class which construct the example Predicate.

/*
 * (c) Copyright 2005-2012 JAXIO, www.jaxio.com
 * Source code generated by Celerio, a Jaxio product
 * Want to use Celerio within your company? email us at info@jaxio.com
 * Follow us on twitter: @springfuse
 * Template pack-backend-jpa:src/main/java/project/dao/support/ByExampleUtil.p.vm.java
 */
package com.jaxio.demo.dao.support;

import static com.google.common.collect.Lists.newArrayList;
import static javax.persistence.metamodel.Attribute.PersistentAttributeType.EMBEDDED;
import static javax.persistence.metamodel.Attribute.PersistentAttributeType.MANY_TO_ONE;
import static javax.persistence.metamodel.Attribute.PersistentAttributeType.ONE_TO_ONE;
import static org.apache.commons.lang.StringUtils.isNotEmpty;

import java.lang.reflect.Method;
import java.util.Collection;
import java.util.List;

import javax.inject.Named;
import javax.inject.Singleton;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.Path;
import javax.persistence.criteria.Predicate;
import javax.persistence.metamodel.Attribute;
import javax.persistence.metamodel.ManagedType;
import javax.persistence.metamodel.SingularAttribute;

import org.springframework.util.ReflectionUtils;

import com.google.common.base.Throwables;

/**
 * Helper to create find by example query.
 */
@Named
@Singleton
public class ByExampleUtil {

    @PersistenceContext
    private EntityManager em;

    public <T> Predicate byExampleOnEntity(Path<T> entityPath, final T entityValue, SearchParameters sp, CriteriaBuilder builder) {
        if (entityValue == null) {
            return null;
        }

        Class<T> type = entityPath.getModel().getBindableJavaType();
        ManagedType<T> mt = em.getMetamodel().entity(type);

        List<Predicate> predicates = newArrayList();
        byExample(mt, entityPath, entityValue, sp, builder, predicates);
        return JpaUtil.andPredicate(predicates, builder);
    }

    public <E> Predicate byExampleOnEmbeddable(Path<E> embeddablePath, final E embeddableValue, SearchParameters sp, CriteriaBuilder builder) {
        if (embeddableValue == null) {
            return null;
        }

        Class<E> type = embeddablePath.getModel().getBindableJavaType();
        ManagedType<E> mt = em.getMetamodel().embeddable(type); // note: calling .managedType() does not work

        List<Predicate> predicates = newArrayList();
        byExample(mt, embeddablePath, embeddableValue, sp, builder, predicates);
        return JpaUtil.andPredicate(predicates, builder);
    }

    private <T> void byExample(ManagedType<T> mt, Path<T> mtPath, final T mtValue, SearchParameters sp, CriteriaBuilder builder, List<Predicate> predicates) {
        for (SingularAttribute<? super T, ?> attr : mt.getSingularAttributes()) {
            if (attr.getPersistentAttributeType() == MANY_TO_ONE //
                    || attr.getPersistentAttributeType() == ONE_TO_ONE //
                    || attr.getPersistentAttributeType() == EMBEDDED) {
                continue;
            }

            Object attrValue = getValue(mtValue, attr);
            if (attrValue != null) {
                if (attr.getJavaType() == String.class) {
                    if (isNotEmpty((String) attrValue)) {
                        predicates.add(JpaUtil.stringPredicate(mtPath.get(stringAttribute(mt, attr)), attrValue, sp, builder));
                    }
                } else {
                    predicates.add(builder.equal(mtPath.get(attribute(mt, attr)), attrValue));
                }
            }
        }
    }

    /**
     * Helper method to a predicate out of the passed many-to-one or one-to-one association.
     * <p>
     * Note 1: If the fkpValue is present, there no need to add a predicate as it is already processed by byExample facility.
     * <p>
     * Note 2: By convention, if the passed fkeValue is not null and has no property set, we assume that you want a not null predicate on the fkePath.
     * 
     * @param fkpPath
     *            the raw fk path.
     * @param fkpValue
     *            the raw fk column value (it is annotated with Column), not used for inverse one-to-one
     * @param fkePath
     *            the path of the property carrying the x-to-one association (it is annotated with ManyToOne or OneToOne)
     * @param fkeValue
     *            the association value
     * @param builder
     *            criteria builder
     */

    public <FKP, FKE> void predicatesForToOneAssociation(Path<FKP> fkpPath, FKP fkpValue, Path<FKE> fkePath, FKE fkeValue, SearchParameters sp,
            CriteriaBuilder builder, List<Predicate> predicates) {
        if (fkeValue != null && fkpValue == null) {
            predicates.add(builder.and(builder.isNotNull(fkpPath), byExampleOnEntity(fkePath, fkeValue, sp, builder)));
        }
    }

    /**
     * Helper method to create a predicate out of the passed one-to-many or many-to-many association.
     * 
     * @param joinPath
     *            the join path of the property carrying the one-to-many or many-to-many association (it is annotated with OneToMany or ManyToMany)
     * @param cValue
     *            the association value
     * @param builder
     *            criteria builder
     */
    public <E> void predicatesForToManyAssociation(Path<E> joinPath, Collection<E> cValue, SearchParameters sp, CriteriaBuilder builder,
            List<Predicate> predicates) {
        if (cValue == null || cValue.isEmpty()) {
            return;
        }

        List<Predicate> examples = newArrayList();

        for (E item : cValue) {
            examples.add(byExampleOnEntity(joinPath, item, sp, builder));
        }

        predicates.add(builder.or(examples.toArray(new Predicate[predicates.size()])));
    }

    private <T> Object getValue(T example, Attribute<? super T, ?> attr) {
        try {
            return ReflectionUtils.invokeMethod((Method) attr.getJavaMember(), example);
        } catch (Exception e) {
            throw Throwables.propagate(e);
        }
    }

    private <T, A> SingularAttribute<? super T, A> attribute(ManagedType<? super T> mt, Attribute<? super T, A> attr) {
        return mt.getSingularAttribute(attr.getName(), attr.getJavaType());
    }

    private <T> SingularAttribute<? super T, String> stringAttribute(ManagedType<? super T> mt, Attribute<? super T, ?> attr) {
        return mt.getSingularAttribute(attr.getName(), String.class);
    }
}

Enjoy!

The SpringFuse/Jaxio team.

Query by example with Spring Data JPA

2012-01-31T00:00:00-08:00

Query by Example with Spring Data JPA

We are pleased to announce that SpringFuse now leverages Spring Data JPA in the code it generates.

It simplifies dramatically the generated data access layer.

The most challenging part was to offer a Query By Example feature, as we did when using Hibernate Example support.

This small blog entry is about it.

Query By Example

 Account account = new Account();
    account.setLastname("agger"); // will apply LIKE %agger%
    
    Page<Account> accountRepository.findWithExample(account, new PageRequest(0, 100)); // we get first 100 result

This codes leads in fine to following SQL query (to be accurate, there is also a count query, for pagination):

  select
        account0_.id as id6_,
        account0_.address_id as address2_6_,
        account0_.BIRTH_DATE as BIRTH3_6_,
        account0_.civility as civility6_,
        account0_.email as email6_,
        account0_.FIRST_NAME as FIRST6_6_,
        account0_.is_enabled as is7_6_,
        account0_.LAST_NAME as LAST8_6_,
        account0_."PASSWORD" as PASSWORD9_6_,
        account0_.login as login6_,
        account0_.version as version6_ 
    from
        Account account0_ 
    where
        account0_.LAST_NAME like ? limit ?

Mixing Query by Example and Range Query.

 Calendar from = Calendar.getInstance();
    from.set(1940, 0, 1);
    
    Calendar to = Calendar.getInstance();
    to.set(1945, 11, 31);
    Account account = new Account();
    
    // like
    account.setLastName("Jagger");        
    
    // between from and to
    RangeDate<Account> birthDateRange = new RangeDate<Account>(Account_.birthDate);
    birthDateRange.setFrom(from.getTime());
    birthDateRange.setTo(to.getTime());
    
    // prepare ranges arg
    List<Range<Account, ?>> ranges = new ArrayList<Range<Account, ?>>();
    ranges.add(birthDateRange);
    
    accountRepository.findWithExample(account, ranges, new PageRequest(0, 100));

Note that you can add ranges of any type: Integer, Long, LocalDate (joda time), BigDecimal, etc...

This codes leads in fine to following SQL query (to be accurate, there is also a count query, for pagination):

  select
        account0_.id as id1_,
        account0_.address_id as address2_1_,
        account0_.BIRTH_DATE as BIRTH3_1_,
        account0_.civility as civility1_,
        account0_.email as email1_,
        account0_.FIRST_NAME as FIRST6_1_,
        account0_.is_enabled as is7_1_,
        account0_.LAST_NAME as LAST8_1_,
        account0_."PASSWORD" as PASSWORD9_1_,
        account0_.login as login1_,
        account0_.version as version1_ 
    from
        Account account0_ 
    where
        (
            account0_.LAST_NAME like ?
        ) 
        and (
            account0_.BIRTH_DATE between ? and ?
        ) limit ?

How it works

The repository implementation is rather simple as we provide a custom Spring Data repository common to all entities. Here is the implementation of the findWithExample method:

    @Override
    public Page<E> findWithExample(E example, List<Range<E, ?>> ranges, Pageable pageable) {
        Specifications<E> spec = Specifications.where(byExampleSpecification.byExample(example));
        spec = RangeSpecification.andRangeIfSet(spec, ranges);
        return findAll(spec, pageable);
    }

Pretty simple, isn't it?

The tricky and beautiful part is of course the implementation of the reusable ByExampleSpecification and RangeSpecification.

To know more you can either generate a project yourself or browse the code of some already generated projects on github.

Enjoy!

The SpringFuse/Jaxio team.

How to skip JSF BeanValidation conditionally

2011-12-15T00:00:00-08:00

How to skip JSF BeanValidation conditionally

Here is a trick that allows you to perform JSF-based BeanValidation depending on the action. It will be supported by next SpringFuse version (3.0.69)

Note: We are using Spring and SpringWebFlow, but this should be easy to adapt it to a pure Java EE application.

The challenge

The challenge when developing JSF applications involving multi-page form is to provide a usable navigation between the pages.

By usable navigation we mean:

a user should be able to navigate freely from one page to another without loosing the data entered in the input fields, even if the entered data is invalid, so that the user can come back to it later.
for certain actions (for example 'save' action) the validation should be enforced.

Requirements

The solution should be easy to develop and maintain. For example, we have tried to implement the a trick that Mr Ed Burns suggests, without any success.
JSF 2.0 supports BeanValidation, which is extremely convenient. We should leverage it.

The trick

We leverage the binding attribute of the JSF <f:validateBean/> tag.

As the documentation says, this attribute value is a ValueExpression that evaluates to an object that implements javax.faces.validate.BeanValidator

Unsurprisingly BeanValidator implements the validate method below from the Validator interface:

    public void validate(FacesContext context,
                         UIComponent component,
                         Object value) throws ValidatorException;

We just have to extend BeanValidator and override the validate method, here is the code:

package com.jaxio.demo.web.component;

import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.validator.BeanValidator;

import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

/**
 * Lenient bean validator which disable validation in certain cases 
 * in order to let the user navigate to sub view without loosing the 
 * data entered in input field.  
 */
@Component
@Scope(BeanDefinition.SCOPE_PROTOTYPE)
public class LenientBeanValidator extends BeanValidator {
    @Override
    public void validate(FacesContext context, UIComponent component, Object value) {
        if (doValidation(context)) {
            super.validate(context, component, value);
        }
        // simply skip it...
    }

    private boolean doValidation(FacesContext context) {
        // main page (action that saves the main entity) 
        if (context.getExternalContext().getRequestParameterValuesMap().containsKey("form:save")) {
            return true;
        }

        // sub page (action that binds the entered data to an associated entity)
        if (context.getExternalContext().getRequestParameterValuesMap().containsKey("form:ok")) {
            return true;
        }

        return false;
    }
}

Of course the code above may be improved to fit your need and your security requirements.

How to use it

Then, to use it from your view, you simply do as follow:

  <h:form id="form">
    <f:validateBean disabled="true"> 
    
        <!-- ... skip for clarity ... -->
        
        <p:inputText id="email" label="${msg.account_email}" value="#{account.email}" maxlength="80" >
            <f:validateBean binding="#{lenientBeanValidator}"/>
        </p:inputText>
    
        <!-- 'save' (validation is enforced) -->
        <p:commandButton id="save" action="save" ajax="true" update="messages" process="@form"
            styleClass="aria-save-button default"
            image="ui-icon-disk"
            value="#{msg.menu_save}"
            rendered="#{not subPage}" />

        <!-- 'ok' (validation is enforced) -->
        <p:commandButton id="ok" action="ok" process="@form" ajax="true" update="messages" 
            styleClass="default"
            image="ui-icon-check"
            value="${msg.submit}"
            rendered="#{subPage}" />    

        <!-- 'otherCase' (validation is NOT enforced) -->
        <p:commandButton id="navigateInSubPage" action="navigateInSubPage" process="@form" ajax="false" 
            styleClass="default"
            image="ui-icon-check"
            value="${msg.submit}"
         />    
    </f:validateBean>
  </h:form>

If you have any remark on this solution, please share :)

Enjoy!

The SpringFuse/Jaxio team.

Generate Accessible Rich Internet Application using JSF2 and PrimeFaces

2011-10-27T00:00:00-07:00

Generate Accessible Rich Internet Application using JSF2 and PrimeFaces

We are trying to make the web applications generated by SpringFuse as accessible as possible.

Online code checker

Our first goal was to pass online code checkers such as achecker.

All the generated pages pass the WCAG 2.0 (Level AAA) with 0 known problems and 0 likely problems.

Achieving it is not really complicated, the key is to use standard HTML components.

Hopefully, PrimeFaces, the JSF 2 component library that we use is pretty clean in that respect.

keyboard

Our next focus was to unplug the mouse to ensure that the generated application is entirely usable with the keyboad.

The result is pretty good with all major browsers except with IE8 which randomly select the default submit button when the user presses enter.

If you have any hints on how we could fix it, please drop us a line. (Note: SpringFuse v. 3.0.66 resolves this issue).

Screen readers and Aria

Then we started to leverage ARIA and specially ARIA live region.

For the screencast, we use Mac OSX Lion, which includes a new version of VoiceOver (a screen reader) with a nice French voice (sorry for the accent :-)

The generated app uses live regions for two main purposes:

to announce the number of items found on each search pages [photo | screencast]
to announce the error detected after a form submission [photo | screencast]

Issue with numbers:

You probably noticed that it does not read 2 digits numbers properly. When it encounters '48', instead of saying 'quarante-huit' (forty eight), it says 'quatre' (four) then 'huit' (eight). If you know how to fix that, we are interested.

More tests...

We encourage you to generate a webapp and try it for yourself. Your feedbacks, specially test results using screen readers would be greatly appreciated.

Resources

Springfuse announces early Primefaces 3 support

2011-09-08T00:00:00-07:00

Springfuse announces early Primefaces 3 support

We are pleased to announce that we have successfully migrated the code that SpringFuse generates from PrimeFaces 2.2.1 to PrimeFaces 3.0.RC1-SNAPSHOT

Primefaces 3 is still in development, but the 3.0 release should arrive soon.

Progressively we will make sure we use the best of the new components.

Here is a screenshot of our classic Account entity edit flow (generated by SpringFuse from our database schema example)

You may also check the fantastic PrimeFaces 3 lab show case

Have fun!

Generate Spring MVC3, JQuery, JPA2 CRUD Application

2011-05-04T00:00:00-07:00

Generate Spring MVC3, JQuery, JPA2 CRUD Application

We are pleased to announce some major improvements in the Spring MVC application that SpringFuse generates.

As usual, you can generate the application from SpringFuse quickstart page.

One of the top 40 company in France is already running an application generated with this version. Their application's database schema has over 50 tables.

Look & Feel

Instead of using our home grown stylesheets, the generated application now uses Blue Print CSS.

It also uses jQuery UI 1.8.11

The generated application look'n' feel is much easier to maintain.

Navigation

We now provide navigation for all JPA associations. It allows you to easily browse though the entity graph and update the associated entities. Here is a screenshot of the 'Account' entity page from the sample application:

You can follow the 5 different associations:

many-to-many for the Roles
many-to-one for the Address
inverse one-to-one for the Contact Info
one-to-many for the books
one-to-many for the documents, mostly here to illustrate file upload/download

Auto complete instead of select box

To set a many to one association, you can configure Celerio to use auto-complete (ajax) instead of displaying all the possible target in a select list box. In the screenshot below, we set the linked address using auto-complete:

Joda Time

You can configure Celerio to use Jodatime instead of java.util.Date.

Here is an example of generated java code and a screen shot:

 @Column(name = "date_joda", length = 8)
    @Type(type = "org.joda.time.contrib.hibernate.PersistentLocalDate")
    @DateTimeFormat(iso = ISO.DATE)
    public LocalDate getDateJoda() {
        return dateJoda;
    }
    
    public void setDateJoda(LocalDate dateJoda) {
        this.dateJoda = dateJoda;
    }
    
    @Column(name = "date_time_joda", length = 23)
    @Type(type = "org.joda.time.contrib.hibernate.PersistentLocalDateTime")
    @DateTimeFormat(iso = ISO.DATE)
    public LocalDateTime getDateTimeJoda() {
        return dateTimeJoda;
    }
    
    public void setDateTimeJoda(LocalDateTime dateTimeJoda) {
        this.dateTimeJoda = dateTimeJoda;
    }

Zenika announces a major Java JEE conference in Paris

2011-02-01T00:00:00-08:00

Zenika announces a major Java JEE conference in Paris

Hello,

Our friends from Zenika have recently announced that they are organizing a new major Java event in Europe...

I am glad for two reasons:

it's Zenika, and we love them at Jaxio
but also because it is going to be in Paris...

Check their site http://www.whatsnextparis.com/ and register asap.

Yes Paris could become the Java capital in Europe !

Go go Zenika.

2011 february 1

Springfuse generates Primefaces with Spring Web Flow front end

2011-01-04T00:00:00-08:00

Springfuse generates Primefaces with Spring Web Flow front end

We are pleased to announce that SpringFuse (v 3.0.43), our online Java Code Generation service, is now able to generate advanced CRUD web applications leveraging:

JSF2
PrimeFaces 2.2
SpringWebFlow 2.2.1,
JPA2
Bean Validation,
Spring 3.0.5
SpringSecurity 3.0.5

Thanks to PrimeFaces, the generated front-end looks great, comes with some nice cool Ajax effects, is easy to understand and modify. The CRUD navigation is entirely driven by Spring Web Flow.

Reusable flows

For each entity SpringFuse generates 2 reusable flows:

one to search for existing entity instances
one to create/read/update/delete the entity

Whenever an entity has an association (many-to-one, one-to-one, one-to-many, many-to many), you can navigate to it until you reach leaves. This advanced navigation is achieved thanks to flows composition.

Advances navigation

Here is how look for example a 'search' view for the Account entity (example provided by SpringFuse)

And below, here is how look the 'edit' view for the Account entity

Extended persistence context

As you walk through the entity graph, the changes you make are retained in an extended persistence context bound to the conversation. Nothing is committed until you invoke a service method annotated with a read-write @Transactional This means you can have a long conversation to prepare all the desired changes and commit them in a short transaction.

A nice side-effect of using extended persistence context is that you no longer have to spend your time merging entities as the user navigates from one view to an other. Indeed, the entities remain by definition in the same persitence context. The back-end is the same as before, JPA2, Bean Validation, Spring, etc.

Building upon great technologies

Thanks to PrimeFaces and Spring Web Flow, it becomes a real pleasure to work with JSF and real enterprise applications can be written without spending months on re-inventing the wheel... specially when you use SpringFuse ;-)

Springfuse

We hope this contribution will make you realize the potential of such architecture for enterprise applications.

We won't go further in the details of all the generated code.

Your turn

The best is to generate a project, play with it and study the source code.

Have fun !

Flex and Spring integration using Blazeds and SpringFuse

2010-12-02T00:00:00-08:00

Flex and Spring integration using Blazeds and SpringFuse

Hello,

here is a nice article about adding BlazeDS support to SpringFuse generated project.

The target audience is people that want to implement a Java based back-end for a Flex web application but are novice to Spring and Hibernate.

Enjoy !

2010 december 2

Java Code Generator Success Story

2009-11-01T00:00:00-07:00

Java Code Generator Success Story

Earlier this year, a software development team working at Steria, a leading IT consulting firm in Europe, has invited Jaxio to demonstrate Celerio, the Enterprise version of SpringFuse.

During our presentation of Celerio, we realized that the development team had already bootstrapped a major project for a bank with the Java source code generated by SpringFuse.

Three days later Celerio was added to their build process.

We are happy to announce that 7 months later, Steria delivers on time the project BForBank, the “first 100% online private bank from Credit Agricole”.

The launch of BforBank has been extensively covered by the media in France: press articles and even a TV ad.

Steria and Jaxio are going to present this success story at the Model Driven Day conference in Paris on November 26th.

We hope to meet you there!

2009 novembre 1

Java Code Generation Promises

2009-10-25T00:00:00-07:00

Java Code Generation Promises

In the last months there has been some increasing interest for Java code generation.

However, code generation may be source of a great disappointment if you expect too much out of it.

In France, a politician said something like: “promises commit only those who believe in it” (I am unsure about the translation). Applied to code generation it becomes: if you believe all promises of code generation, it is your responsibility. If you consider using code generation on your next project, you may be interested in checking the various points that drive us in the development of Celerio, the code generator that powers SpringFuse.

The model

SQL is still predominant in this world. Many web applications are data-oriented and the database schema is the only model that is always up to date. We have created Celerio especially for this kind of applications. So, it is natural for us to use the database schema as an entry model for the code generation. When the schema is not enough, for example to describe entity inheritance, we rely on a configuration file. We could have taken a different path, starting from UML or Java Entities; but for the application we target, SQL + some configuration remain the most pragmatic model.

Maintenance

In some many cases, an application is maintained by developers that were not part of the initial core team. To ease the maintenance, the code generation tool should be pragmatic, easy to learn, with as fewer bells and whistles as possible.

Self training

The generated code should help the most junior developers to train themselves. The code should be clean, well organized, and documented. The generated code should not be considered as a black-box. At the end of a project, the developer should understand the ins and outs of the generated code and the underlying technologies it uses. We have received many feedbacks from users who used SpringFuse to learn JPA, Spring MVC, Spring Security, Spring Web Flows, etc.

Code generation templates

Developers should focus on the business code, not on writing the code generation templates. Moreover the underlying technology is moving fast: one year you use hibernate, the next you support JPA, the next you move to JPA 2. Spring is out in 2.5, but version 3 is coming etc… Java ecosystem has not landed yet, it may never. We write templates for the latest stable technologies as they are released and we support them. For example our next move will be supporting Spring 3.0 and part of EE6.

Speed

Code generation phase should be almost transparent to the developers that generate-compile-deploy-debug often, even on large models.

Over generating

The most difficult thing is to resist to the temptation of generating some code. As we progress with Celerio, we tend to generate less and less code. We also warn our users that parts of the code that Celerio generates are just meant for training/tutorial purposes (i.e. web UI code) or should be used as a copy-paste source.

IDE

A code generation tool is just a tool. I believe it should not force you to use a specific IDE. Celerio is just a Maven2 plugin; it can run in a console mode, in Eclipse etc.

Lock-in

The generated code should run without the code generation tool itself. Of course Celerio is not required at runtime and the generated code depends only on well known Open Source projects.

Code generation round trip

The generated code manual modification should not be lost when regenerating. Celerio uses different techniques to preserve the user code (this could be the subject of a separated post).

Conclusion

Code generation can be of great helps if you select the right tool for the right project, for the right team and if you know in advance what to expect from it. Keep in mind that at the end, one of the most important features is simply the result, which is the generated code. So take the time to review it before selecting a tool. Make sure the generated code complies with your highest expectations in term of quality. Try to put yourself in a position where you would have to maintain this code manually or explain it to another team. To ease the process of reviewing the code that Celerio generates, we have created SpringFuse. Developers can use this service to generate a project in less than 15 minutes. The result is a zip file that contains the generated source code organized into a Maven2 project.

Have fun!

Project lombok - a must have in your java toolbox !

2009-10-18T00:00:00-07:00

Project lombok - a must have in your java toolbox !

What you'll read in this post:

using eclipse to write POJO
using eclise and commons-lang to write POJO
using lombok to write POJO
a maven project with working examples

Get the code directly on github !

ProjectLombok is my new technical friend

Today I would like to share with you my new technical companion: projectlombok.

What is lombok

ProjectLombok like Springfuse is a code generator, and I very much like code generators as they make my life easier. Where springfuse is producing working knowledge spanning many technologies, project lombok produces simple code to bypass java excessive verbosity. Project lombok is generating :

While reading this you should think that eclipse does it for you already since... for ever.

You could also tell me that I should use a real language like scala or a dynamic language like groovy.

The problem

Well they could be ideal solutions, but like so many I have no choice but to stick with java.

Should we really rely on our IDE to generate this kind of code ?
Should we really have to see all these methods clutter our code ?
Should we really need to loose time and focus to manually verify that our hashcode, equals, toString methods are in sync ?
Come on, our time is precious, and this really totally dumb, and error prone !

But there should not be this problem to solve in the first place !

WRITING ALL THESE METHODS MANUALLY

I used to write them manually while using emacs back in the 2000 days, let's skip these painful memories...

A LITTLE HELP FROM ECLIPSE

We all know how to generate all these methods using eclipse, but I had the curiosity for this post to count the number of steps to generate them:

click Source
click generate getter & setter
click Select all
click Ok
click Source
click generate to String
click Ok
Click Source
click generate hashcode and equals
click Ok
I tidy up things

That’s 11 steps !

Ok, now it’s time to do some eclipse magic and bind "generate setter/getter" to a shortcut.

That’s right, no big deal. But sounds like an ugly solution isn’t it?

And I insist, this problem should not exist in the first place !

So you end up with :

 package com.springfuse.blog.projectlombok;
    
    public class UsingEclipse {
        private String not;
        private String really;
        private String fun;
    
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((fun == null) ? 0 : fun.hashCode());
            result = prime * result + ((not == null) ? 0 : not.hashCode());
            result = prime * result + ((really == null) ? 0 : really.hashCode());
            return result;
        }
    
        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            UsingEclipse other = (UsingEclipse) obj;
            if (fun == null) {
                if (other.fun != null)
                    return false;
            } else if (!fun.equals(other.fun))
                return false;
            if (not == null) {
                if (other.not != null)
                    return false;
            } else if (!not.equals(other.not))
                return false;
            if (really == null) {
                if (other.really != null)
                    return false;
            } else if (!really.equals(other.really))
                return false;
            return true;
        }
    
        @Override
        public String toString() {
            return "UsingEclipse [fun=" + fun + ", not=" + not + ", really=" + really + "]";
        }
    
        public String getNot() {
            return not;
        }
    
        public void setNot(String not) {
            this.not = not;
        }
    
        public String getReally() {
            return really;
        }
    
        public void setReally(String really) {
            this.really = really;
        }
    
        public String getFun() {
            return fun;
        }
    
        public void setFun(String fun) {
            this.fun = fun;
        }
    
    }

Basically the usual pojo suspect you see everywhere ...

Some help from commons-lang

Commons-lang is giving simple and effective solutions to reduce the boilerplate code with

So you have now only the getter and setter to generate with eclipse and no more need to worry about your equals/hashcode methods.

You should now have this:

 package com.springfuse.blog.projectlombok;
    
    import org.apache.commons.lang.builder.EqualsBuilder;
    import org.apache.commons.lang.builder.HashCodeBuilder;
    import org.apache.commons.lang.builder.ToStringBuilder;
    
    public class UsingCommonsLang {
        private String not;
        private String really;
        private String fun;
    
        public String getNot() {
            return not;
        }
    
        public void setNot(String not) {
            this.not = not;
        }
    
        public String getReally() {
            return really;
        }
    
        public void setReally(String really) {
            this.really = really;
        }
    
        public String getFun() {
            return fun;
        }
    
        public void setFun(String fun) {
            this.fun = fun;
        }
    
        @Override
        public int hashCode() {
            return HashCodeBuilder.reflectionHashCode(this);
        }
    
        @Override
        public boolean equals(Object obj) {
            return EqualsBuilder.reflectionEquals(this, obj);
        }
    
        @Override
        public String toString() {
            return ToStringBuilder.reflectionToString(this);
        }
    }

This is better, less error prone, but we still still have so many getter/setters that we can’t stand.

Lombok comes and wins

Now look how we do it using lombok:

 package com.springfuse.blog.projectlombok;
    
    import lombok.Data;
    
    @Data
    public class UsingProjectLombok {
        private String get;
        private String fun;
        private String back;
    }

Isn't it elegant ?

The @Data does express my intention nicely ... and completely as the code is also generated. After the shock of such a concise POJO, the next though you have is for configuration ... Projectlombok gives you this freedom.

 package com.springfuse.blog.projectlombok;
    
    import lombok.EqualsAndHashCode;
    import lombok.Getter;
    import lombok.Setter;
    import lombok.ToString;
    
    @EqualsAndHashCode(exclude = { "get" })
    @ToString(exclude = { "get" })
    public class UsingProjectLombokWithConfiguration {
        protected String get;
        @Getter
        private String fun;
        @Getter
        @Setter
        private String back;
    
        public UsingProjectLombokWithConfiguration(String get, String fun, String back) {
            this.get = get;
            this.fun = fun;
            this.back = back;
        }
    }

Please note that Lombok is a good citizen as it gives you clear warnings.

How does it work ?

Project lombok is a javac plugin that will use the javac 6 annotation processor. That means that the generation of the methods is part of the compilation, and no runtime nor java agent is required ! It's almost like adding behavior with aspectj but with plain java !

Lombok and maven

Using lombok and maven is straightforward:

  <dependency> <!-- Will be picked by javac -->
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>0.8.5</version>
        <scope>compile</scope>
    </dependency>
    ... 
    <repositories>
        <repository> <!-- project lombok is not yet in public maven repo -->
            <id>projectlombok.org</id>
            <url>http://projectlombok.org/mavenrepo</url>
        </repository>
    </repositories>
    ... 
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>2.3.2</version>
            <configuration>
                <compilerVersion>1.6</compilerVersion>
                <source>1.6</source>
                <target>1.6</target>
            </configuration>
        </plugin>
    </plugins>

Lombok and eclipse

Execute the lombok.jar and specify your eclipse folder it will add itself or add manually in eclipse.ini the botclasspath and javaagent like this

-javaagent:lombok.jar
-Xbootclasspath/a:lombok.jar

Constraints

javac 1.6

Lombok does work only under javac 1.6, but if you want to target 1.5 just configure it in your pom. But JDK 1.5 has 10 more days before it is no more supported by sun ! It is time to give this info to your boss and make the switch.

Eclipse refactoring

The current version 0.8.5 does not work great in this regard, however they fixed it in the trunk. If you do build your own, you'll be fine

git clone git://github.com/rzwitserloot/lombok.git
ant

... or wait for the next binary release !

Edit: the 0.9 release is out

Netbean support

It's in the way

Do not abuse

Lombok generates other methods like @Cleanup, @Synchronized, @SneakyThrows or @Logger. I am not sure what to think about these, maybe it could go too far but as the intent is clearly described via the annotation, why not... Anyway I'll stick with the simple features for now and see how it goes.

I love this tool !

I have to say, that the combination of google collections and project lombok gave me a fresh view of what you can accomplish with java. It feels like the gap between the language "du jour" and my plain old java has been dramatically reduced. And you know what ?

It feels good !

Testing various equals and hashCode strategies

2009-10-11T00:00:00-07:00

Testing various equals and hashCode strategies

Equality in Java and in particular when working with Hibernate/JPA is a tricky subject. You will find in this post a simple Java project with some unit tests that illustrate the importance of overriding the equals() and hashCode() methods. The project has a User entity with pluggable equals/hashCode implementations. Of course this design is only meant for testing different equals/hashCode implementations against the same unit tests. Running the tests and seeing them fail or succeed depending on the equals/hashCode strategy used is a fun and easy way to learn and remember the importance of overriding equals/hashCode. Note that the subject of identity is extensively covered

in "Item 9" of Effective Java second Edition
and in chapter 9 of Java Persistence with Hibernate.

Both books are must read.

Here is a preview of the kind of equals/hashCode tests you are going to find in the project:

  @Test
     public void reflexive() {
      User x = newUser(1, "x");
      assertTrue(x.equals(x));
     }
    
     @Test
     public void logicalEquality() {
      User x1 = newUser(1, "x", "yellow");
      User x2 = newUser(1, "x", "yellow");
    
      assertTrue(x1.equals(x2) && x2.equals(x1));
    
      // consistent
      x1.setFavoriteColor("red");
      x2.setFavoriteColor("blue");
      assertTrue(x1.equals(x2) && x2.equals(x1));
    
      x2.setId(2);
      x2.setUsername("x2");
      assertFalse(x1.equals(x2));
     }
    
     @Test
     public void entityInSet() {
      Set<User> set = new HashSet<User>();
      set.add(newUser(1, "x"));
      set.add(newUser(1, "x"));
      assertEquals(1, set.size());
     }
    
    
     @Test
     public void differentManagersReturnSameEntity() {
      UserManager um1 = new UserManager(this);
      UserManager um2 = new UserManager(this);
    
      Set<User> set = new HashSet<User>();
      set.add(um1.getUser(1));
      set.add(um2.getUser(1));
    
      assertEquals(1, set.size());
     }

Etc..

You can download the simple equal/hashCode project on github. Clone itlocally and import it in your IDE as a Maven project. You may also run directly the unit tests from a command line (mvn test). Once imported, for example in Eclipse, you can run the Junit tests.

RUNNING THE TESTS WITH THE DEFAULT EQUALS/HASHCODE IMPLEMENTATION

Run as a junit test the DefaultUserIdentityTest class. You should have the following result :

As you can see most of the tests fail. The following logical identity test is not satisfied as you can expect.

  @Test
     public void logicalEquality() {
      User x1 = newUser(1, "x", "yellow");
      User x2 = newUser(1, "x", "yellow");
    
      assertTrue(x1.equals(x2) && x2.equals(x1));
    
      // consistent
      x1.setFavoriteColor("red");
      x2.setFavoriteColor("blue");
      assertTrue(x1.equals(x2) && x2.equals(x1));
    
      x2.setId(2);
      x2.setUsername("x2");
      assertFalse(x1.equals(x2));
     }

The default equals implementation is not sufficient. Let’s use a strategy based on the primary key that is the id property and see what happens. RUNNING THE TESTS WITH AN EQUALS/HASHCODE STRATEGY USING THE PRIMARY KEY

Run as a junit test the IdUserIdentityTest class. package com.springfuse.blog.identity;

 import java.io.Serializable;
    
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    
    /**
    * equals/hashCode strategy using the User primary key, the id property.
    */
    public class IdEqualsStrategy implements EqualsStrategy, Serializable {
     static private final long serialVersionUID = 1L;
     static final private Log logger = LogFactory.getLog(IdEqualsStrategy.class);
    
     private User user;
    
     public IdEqualsStrategy(User user) {
      this.user = user;
     }
    
     public boolean doEquals(User other) {
      return user.getId() != null ? user.getId().equals(other.getId()) : false;
     }
    
     public int doHashCode() {
      if (user.getId() != null) {
       return user.getId().hashCode();
      } else {
       logger.warn("TODO: developer your code is not safe regarding hashCode", new Exception("stack trace"));
       return System.identityHashCode(user);
      }
     }
    }

You should have the following result:

Almost all the tests pass now, except the one below:

  @Test
     public void setIdAfterAddingEntityInSetAndTryToRemoveIt() {
      Set<User> set = new HashSet<User>();
      User x = newUser("x");
      set.add(x);
      x.setId(1);
      set.remove(x);
    
      assertEquals(0, set.size());
     }

You may not encounter this scenario everyday, but with hibernate you might, for example when using saveOrUpdate(user). Imagine, if the user is added a Set before being saved in the database, you fall into this scenario. This lead us to use instead a "business key", that is a property or a set of properties that is unique, not null and rarely or never change and known before inserting the entity in the Set and in the database.

RUNNING THE TESTS WITH AN EQUALS/HASHCODE STRATEGY USING A BUSINESS KEY

Run as a junit test the UsernameUserIdentityTest class.

 package com.springfuse.blog.identity;
    
    import java.io.Serializable;
    
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    
    /**
    * equals/hashCode strategy using a business key, the username property.
    */
    public class UsernameEqualsStrategy implements EqualsStrategy, Serializable {
     static private final long serialVersionUID = 1L;
     static final private Log logger = LogFactory.getLog(UsernameEqualsStrategy.class);
    
     private User user;
    
     public UsernameEqualsStrategy(User user) {
      this.user = user;
     }
    
     public boolean doEquals(User other) {
      return user.getUsername() != null && user.getUsername().length() > 0 ? user.getUsername().equals(other.getUsername()) : false;
     }
    
     public int doHashCode() {
      if (user.getUsername() != null && user.getUsername().length() > 0) {
       return user.getUsername().hashCode();
      } else {
       logger.warn("TODO: developer your code is not safe regarding hashCode", new Exception("stack trace"));
       return System.identityHashCode(user);
      }
     }
    }

You should have the following result :

All the tests pass now :-)

Note that the doHashCode() methods warns the developer if the username is not set.

  public int doHashCode() {
      if (user.getUsername() != null && user.getUsername().length() > 0) {
       return user.getUsername().hashCode();
      } else {
       logger.warn("TODO: developer your code is not safe regarding hashCode", new Exception("stack trace"));
       return System.identityHashCode(user);
      }
     }

Indeed, the hashCode is most likely called by a Set implementation and if the username is not yet set, you may break the Set contract if you set (sorry for this repetition) the username while the User is in the Set. You could be more violent and throw an exception instead to be sure to spot such pratice.

If you want to send us some code modifications, please use a pull request

Happy coding !

Why we switched from jaxb to jibx

2009-10-01T00:00:00-07:00

Why we switched from jaxb to jibx

Here is what you will find in this post :

xsd to java generation using jaxb2 with an maven project example
java to xsd generation using jaxb2
jaxb2 cannot generate an xsd with documentation
xsd from java generation using jibx with a maven project example
jibx customization is easy
add jibx xsd generation in maven with customization
how to use jibx using spring oxm

XSD authored manually

Continuing on my previous post on how to integrate your own xsd to ease your plugin configuration, I will talk today on something that really bugged me for a while.

Some of our xsd are pretty large; we created them using xsd authoring tool, then continued by hand. We used jaxb to produce the java code to map the xsd, but the generated code was not that great. There are some ways to tweak the xjc plugin to bend the produced code the way you like. But this was way too awkward for us.

Jaxb generates XSD from java annotations

Then we thought that it was time to use the java code and annotate it with jaxb annotation so we could produce the xsd for our users to use.

You annotate with the same few annotations here and there, and after this very tedious task you can add maven-jaxb-schemagen-plugin plugin to your pom and voilà you have a fresh xsd ready for production generated directly from your classes.

But something is missing, looks like the generated xsd is very small compared to the manually authored one: jaxb did not insert any documentation !

Of course I thought that I did a silly mistake, and was ready to add something like @XmlDocumentation annotations. And here starts the story: there is no way to add documentation information to schemagen !

Jaxb cannot generate an XSD with configuration

This really surprised me, because the xsd are also here to help the users when they author an xml by showing documentation while they type etc.

I really searched to find a way to use the tool; I even tried to dive into the schemagen source-code to see if there would be an existing annotation not present in the documentation.

By the way, let me give a big thumb down to java.net for beeing so slow ! It was hell to navigate through the documentation on a site that is that slow.

Wrong path: I was stuck. But there was no way I wanted to continue maintaining both the java and the xsd !

Enter jibx

Then I looked at the alternatives to jaxb, and quickly found out jibx http://jibx.sourceforge.net/ was the tool I was looking for!

Bindgen is for jibx what maven-jaxb-schemagen-plugin is for jaxb. But instead of relying on annotation, bindgen rely solely on the class attributes and on the javadocs for producing the xsd and its documentation. Here is an example :

 public class XSD {
     
     /** please define your complex object */
     private ComplexObject complexObject;
     /** you are allowed to set many simple objects */
     private List<SimpleObject> simpleObject = new ArrayList<SimpleObject>();
    }

 public class ComplexObject {
     /**
     * only string are allowed
     */
     private String stringAttribute;
     /**
     * This should be a date
     */
     private Date dateAttribute;
     /**
     * boolean are so over
     */
     private boolean thisIsABool = false;
     /**
     * enums are much better than booleans
     */
     private MyEnum myEnum;
    }

Would generate the following xsd :

  <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:tns="http://jaxio.com" elementFormDefault="qualified" targetNamespace="http://jaxio.com">
      <xs:element type="tns:XSD" name="XSD"></xs:element>
      <xs:complexType name="XSD">
        <xs:annotation>
          <xs:documentation>this is my annotated xsd</xs:documentation>
        </xs:annotation>
        <xs:sequence>
          <xs:element name="complexObject" minOccurs="0">
            <xs:annotation>
              <xs:documentation>please define your complex object</xs:documentation>
            </xs:annotation>
            <xs:complexType>
              <xs:sequence>
                <xs:element type="xs:string" name="stringAttribute" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>only string are allowed</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="myEnum" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>enums are much better than booleans</xs:documentation>
                  </xs:annotation>
                  <xs:simpleType>
                    <xs:annotation>
                      <xs:documentation>this is a enum, you need to choose between the values</xs:documentation>
                    </xs:annotation>
                    <xs:restriction base="xs:string">
                      <xs:enumeration value="A"></xs:enumeration>
                      <xs:enumeration value="B"></xs:enumeration>
                      <xs:enumeration value="C"></xs:enumeration>
                      <xs:enumeration value="D"></xs:enumeration>
                    </xs:restriction>
                  </xs:simpleType>
                </xs:element>
              </xs:sequence>
              <xs:attribute type="xs:dateTime" name="dateAttribute">
                <xs:annotation>
                  <xs:documentation>This should be a date</xs:documentation>
                </xs:annotation>
              </xs:attribute>
              <xs:attribute type="xs:boolean" use="required" name="thisIsABool">
                <xs:annotation>
                  <xs:documentation>boolean are so over</xs:documentation>
                </xs:annotation>
              </xs:attribute>
            </xs:complexType>
          </xs:element>
          <xs:element name="simpleObject" minOccurs="0" maxOccurs="unbounded">
            <xs:complexType>
              <xs:sequence>
                <xs:element type="xs:string" name="simpleString" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>trivial string</xs:documentation>
                  </xs:annotation>
                </xs:element>
              </xs:sequence>
              <xs:attribute type="xs:int" use="required" name="simpleNumeric">
                <xs:annotation>
                  <xs:documentation>trivial numeric</xs:documentation>
                </xs:annotation>
              </xs:attribute>
            </xs:complexType>
          </xs:element>
        </xs:sequence>
      </xs:complexType>
    </xs:schema>

Perfect: all the documentation is present, it is taken directly from the javadoc!

But if you follow closely the xsd, the stringAttribute and myEnum are not properties, they are defined as element.

An xml would look like

  <complexObject thisIsABool="true" dateAttribute="2009-10-01T20:36:39.515Z">
        <stringAttribute>my string attribute</stringAttribute>
        <myEnum>B</ myEnum>
    </complexObject>

You could also see that there is no mention on required, default values etc.

Jibx customization is easier than jaxb's

Bindgen is not that magic, we have to give it hints using customization, fortunately it is pretty straightforward thanks to a good documentation along with examples.

  <custom>
        <class name="com.jaxio.ComplexObject" optionals="myEnum">
            <value attribute="myEnum" property-name="myEnum"></value>
            <value attribute="stringAttribute" property-name="stringAttribute"></value>
        </class>
    </custom>

The only major pain was to make everything work in maven, in particular:

The BindGen setup using the ant task maven plugin and the correct dependencies
maven-jibx-plugin can use only relative path for its directory configuration point.

You can download and execute a working example here.

Jibx and spring OXM

And now jibx and Spring 3.0 oxm project! Oxm will help you to have a nice hierarchy of exception that wraps your underlying xml provider so you do not have to deal with it.

 JibxMarshaller marshaller = new JibxMarshaller();
    marshaller.setTargetClass(XSD.class);
    marshaller.afterPropertiesSet();
    
    // write
    StringWriter writer = new StringWriter();
    marshaller.marshal(xsd, new StreamResult(writer));
    System.out.println(writer.toString());
    
    // load 
    (XSD) marshaller.unmarshal(new StreamSource(new FileInputStream(filename))

You have a unit test ready to be executed in the sample project

Have fun with jibx !

Spring Web Flow Menus

2009-09-24T00:00:00-07:00

Spring Web Flow Menus

Overview

Spring Web Flow allows you to manage real conversational state on the web.

In general, for a given user you allow one flow (i.e. conversation) at a time. This flow may launch sub-flows, but technically, your user is still running one flow at a time.

Let’s address a more complex scenario where you would like to let your user start several independent flows in parallel and allow your user to switch from one flow to another.

Nothing prevents you from starting multiple flows. You just have to provide one or several links pointing to a flow start. Your user may click on them several times and launch several flows in parallel.

But,how do you allow the user to switch from one flow to another?

The first trivial solution is to start each flow in a separate window. A more user-friendly solution is to provide a flow menu, listing all the active flows.

This feature is not built-in in Spring Web Flow, but the Spring Web Flow API is flexible enough to let us implement it.

Note that the code shown below was generated by SpringFuse

Here is the Java code

You first need to create a FlowExecutionListener to capture for each running flow a menu entry, that is a URL and a Label.

 package com.jaxio.example.web.flow;
    
    /**
    * Captures a relevant URL and Label to be displayed in a flow Menu.
    */
    public class FlowMenuExecutionListener extends FlowExecutionListenerAdapter {
    
        @Autowired
        private FlowMenu flowMenu;
    
        @Override
        public void viewRendering(RequestContext context, View view, StateDefinition viewState) {
            // we ignore non view state and popups
            if (!viewState.isViewState() || ((ViewState) viewState).getPopup()) {
                return;
            }
    
            flowMenu.updateFlowMenuItem(context.getFlowExecutionUrl(), getFlowMenuItemLabel(context));
        }
    
        @Override
        public void stateEntering(RequestContext context, StateDefinition state) throws EnterStateVetoException {
            if (state instanceof EndState) {
                flowMenu.removeFlowMenuItem(context.getFlowExecutionUrl());
            }
        }
    
        @Override
        public void sessionEnding(RequestContext context, FlowSession session, String outcome, MutableAttributeMap output) {
            flowMenu.removeFlowMenuItem(context.getFlowExecutionUrl());
        }
    
        private String getFlowMenuItemLabel(RequestContext context) {
            return (String) context.getFlowScope().get("menuLabel");
        }
    }

The code above relies on the following bean below:

 package com.jaxio.example.web.flow;
    
    // this bean has a session scope (see conf file)
    /**
    * A session scope bean (see conf file) that holds the
    * user's active.
    */
    public class FlowMenu implements Serializable {
        static final private long serialVersionUID = 1L;
    
        private Map&lt;String, FlowMenuItem&gt; menu = new LinkedHashMap&lt;String, FlowMenuItem&gt;();
    
        /**
    * Create or update a menu entry.
    */
        public void updateFlowMenuItem(String flowExecutionUrl, String label) {
            menu.put(getFlowExecutionId(flowExecutionUrl), new FlowMenuItem(flowExecutionUrl, label));
        }
    
        /**
    * Remove a menu entry.
    */
        public void removeFlowMenuItem(String flowExecutionUrl) {
            menu.remove(getFlowExecutionId(flowExecutionUrl));
        }
    
        /**
    * Extract string that represent the flow execution id, for example:
    * http://localhost:8080/flow/myflow?execution=e12s2 becomes
    * http://localhost:8080/flow/myflow?execution=e12
    */
        private String getFlowExecutionId(String flowExecutionUrl) {
            return flowExecutionUrl.substring(0, flowExecutionUrl.lastIndexOf('s'));
        }
    
        /**
    * In flow end-state, instead of redirecting to a fixed page,
    * you can call this method to redirect the user
    * to a flow that is not yet ended.
    */
        public String getEndStateRedirect() {
            if (menu.isEmpty()) {
                return defaultExternalRedirect;
            } else {
                return "serverRelative:" + menu.values().iterator().next().getUrl();
            }
        }
    
        /**
    * Called from the view in charge of displaying the menu.
    */
        public List&lt;FlowMenuItem&gt; getFlowMenuAsList() {
            return new ArrayList&lt;FlowMenuItem&gt;(menu.values());
        }
    
        /**
    * Holds the label/url.
    */
        public class FlowMenuItem implements Serializable {
            static final private long serialVersionUID = 1L;
    
            String url;
            String label;
    
            public FlowMenuItem(String url, String label) {
                this.url = url;
                this.label = label != null ? label : url;
            }
    
            public String getUrl() {
                return url;
            }
    
            public String getLabel() {
                return label;
            }
    
            @Override
            public String toString() {
                return url + ":" + label;
            }
        }
    
        //---------------------------------------------------
        // Configuration
        //---------------------------------------------------
    
        private String defaultExternalRedirect = "contextRelative:index.action";
        public void setDefaultExternalRedirect(String defaultExternalRedirect) {
            this.defaultExternalRedirect = defaultExternalRedirect;
        }

Note that the listener is a singleton while the flowMenu bean must be a session bean. You must declare your flowMenu bean in your configuration file as a scoped-proxy.

Please read Spring documentation for more information.

Beside that, if you are familiar with spring Web flow and Spring MVC, the configuration is trivial.

Here is how the configuration file should look like.

  <bean id="flowMenuExecutionListener" class="com.jaxio.example.web.flow.FlowMenuExecutionListener"/>
    
    <bean name="flowMenu" class="com.jaxio.example.web.flow.FlowMenu" scope="session">
        <aop:scoped-proxy></aop:scoped-proxy>
    </bean>
    
    <webflow:flow-executor id="flowExecutor" flow-registry="flowRegistry">
        <webflow:flow-execution-attributes>
            <webflow:always-redirect-on-pause value="false"></webflow:always-redirect-on-pause>
        </webflow:flow-execution-attributes>
        <webflow:flow-execution-listeners>
            <!-- ... other listeners here ... -->
            <webflow:listener ref="flowMenuExecutionListener"></webflow:listener>
        </webflow:flow-execution-listeners>
    </webflow:flow-executor>

How do we get the label?

The label string must be set in the flow as a flowScope variable and be named ‘menuLabel’. You can set it inside an on-start tag and update it at will in view-state if you want your label to vary during the flow execution. Here is an example (again from a project generated with SpringFuse):

  <flow xmlns="http://www.springframework.org/schema/webflow"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="
            http://www.springframework.org/schema/webflow
            http://www.springframework.org/schema/webflow/spring-webflow-2.0.xsd">
    
        <var name="accountForm" class="com.jaxio.example.web.controller.domain.account.AccountForm"></var>
    
        <on-start>
            <set name="flowScope.menuLabel" value="'Account creation'"></set>
        </on-start>
        <!-- ... the flow ... -->
    </flow>

Redirection on flow ending

Would not it be nice to redirect the user to one of the other active flows when he/she ends a flow?

This is already implemented in the flowMenu bean, all you have to do is set the view attribute of your end-state as illustrated below:

  <flow xmlns="http://www.springframework.org/schema/webflow"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="
            http://www.springframework.org/schema/webflow
            http://www.springframework.org/schema/webflow/spring-webflow-2.0.xsd">
    
        <!-- ... the flow ... -->
    
        <end-state id="cancel" view="externalRedirect:${flowMenu.endStateRedirect}"></end-state>
    </flow>

How to access the menu bean from the view?

Now you need to access the menu from the view, in a JSP you can do this:

* <a href="#">Active Flows</a>
        
        <c:forEach var="flowMenuItem" items="${flowMenu.flowMenuAsList}">
        * <a href="${flowMenuItem.url}">${flowMenuItem.label}</a>
        </c:forEach>

The only trick is that the flowMenu must be somehow set as a request attribute. In SpringFuse, we use a BeanInViewInterceptor, here it is:

 import com.jaxio.example.web.flow.FlowMenu;
    
    /**
    * This interceptor is responsible for binding useful beans on the ModelMap so they can be used
    * from the view.
    */
    @Service
    public class BeanInViewInterceptor implements HandlerInterceptor {
    
        @Autowired
        private FlowMenu flowMenu;
    
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException {
            // Note: using the modelAndView in the postHandle would not work
            //       view returned by Spring Web Flow
            request.setAttribute("flowMenu", flowMenu);
    
            // proceed
            return true;
        }
    
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
        }
    
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        }
    }

Don't forget to declare this interceptor... in your interceptor chain.

Have fun coding !

A better way to handle maven plugin configuration

2009-09-18T00:00:00-07:00

A better way to handle maven plugin configuration

When times were simple

Celerio the code generation engine behind springfuse.com is a maven plugin.

It can be configured extensively via xml.

Only a small subset can be configured directly in maven relying on mojo's source level annotations described here.

You can get variables directly like this :

   /**
      * jdbc user
      * @parameter expression="${jdbc.user}"
      * @parameter required
      */
      protected String jdbcUser;

Or relying on simple nested structures like this :

    /**
 * list of enabled modules
 * @parameter
 */
   protected String[] enabledModules = new String[0];

So you could configure your plugin like that

    <plugin>
      <groupId>sample.plugin</groupId>
      <artifactId>maven-hello-plugin</artifactId>
      <version>1.0-SNAPSHOT</version>
      <configuration>
        <jdbcUser>me</jdbcUser>
        <enabledModules>
            <enabledModule>module1</enabledModule>
            <enabledModule>module2</enabledModule>
        </enabledModules>
      </configuration>
    </plugin>

When we first wrote the maven plugin we were happy and life was simple.

When the storm came

But in fact it was a pain, because of the limitation of the maven plugin configuration mapping support we had 2 representations of our configuration, one for the maven plugin, and the other one for the xml file backed by an XSD. Therefore it meant for us to merge manually both configuration, duplication of code was involved, documentation was a pain, twice the testing, and worst : questions from our customers.

Weather is changing

While navigating in the maven xsd I stumbled on the plugin configuration tag definition which is

    <xs:element name="configuration" minOccurs="0">
        <xs:annotation>
            <xs:documentation source="version">0.0.0+</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:sequence>
                <xs:any minOccurs="0" maxOccurs="unbounded" processContents="skip"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>

Notice the processContents="skip". I never paid attention to it but when you set your maven plugin configuration it is not known by the maven xsd therefore it makes perfect sense to skip the maven.xsd validation of the enclosed xml tags ... and let maven's magic appear.

    <plugin>
      <groupId>sample.plugin</groupId>
      <artifactId>maven-hello-plugin</artifactId>
      <version>1.0-SNAPSHOT</version>
      <configuration>
        <jdbcUser>me</jdbcUser>  <!-- not part of maven xsd -->
        <enabledModules> <!-- not part of maven xsd -->
            <enabledModule>module1</enabledModule> <!-- still not part of maven xsd -->
            <enabledModule>module2</enabledModule> <!-- and your editor does not complain -->
        </enabledModules>
      </configuration>
    </plugin>

This made me realize that maven must handle the content of the tag as plain xml string or some kind of DOM. Of course, how could it be otherwise? And if there was a way of getting from the plugin the xml, I could use it too and sent it to our configuration service!

And the sun shines again

I fired Eclipse and went on navigating in maven source code to find code related to configuration.

It was not long before I found http://maven.apache.org/ref/2.0.8/maven-model/apidocs/org/apache/maven/model/Plugin.html

Then http://maven.apache.org/ref/2.0.8/maven-model/apidocs/org/apache/maven/model/ConfigurationContainer.html#getConfiguration()

    /**
 * Get The configuration as DOM object.
 */
    public Object getConfiguration() {
     ...
     }

... I was on the right track. Turns out this Object is an Xpp3Dom object http://plexus.codehaus.org/plexus-utils/apidocs/org/codehaus/plexus/util/xml/class-use/Xpp3Dom.html And the good story is that its toString method returns directly the DOM as a String xml representaton. Perfect, I could give that to my configuration service, and voilà.

Back to cloudy times

The maven plugins typically extends the AbstractMojo to get facilities. But you cannot get the desired plugin instance directly! Yes that's really strange. Turns out, I found the solution here There must some way to get it more easily, maybe by implementing some interface or what not. But I could stop there with maven as I had what I wanted.

And the XSD sun shines again

Adding our xsd in the pom project header

  <project xmlns="http://maven.apache.org/POM/4.0.0" 
                 xmlns:celerio="http://www.jaxio.com/schema/celerio" 
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd
                                                 http://www.jaxio.com/schema/celerio http://www.jaxio.com/schema/prototype/celerio-2.6.xsd">
        ...

We could now have

    <plugin>
     <groupId>com.jaxio.prototype</groupId>
     <artifactId>maven-celerio-plugin</artifactId>
     <configuration>
      <celerio:celerio>
       <celerio:database jdbcUser="myJdbcUser"/>
      </celerio:celerio>
     </configuration>
        <executions>
            ...
        </executions>
    </plugin>

Our customers will now be guided by their editors when configuring our maven plugin. They will use the same knowledge they used when using our xml configuration file. Oh yes, and when you get your maven pluging configuration, all the substitutions has been made. Therefore it is not the "raw" configuration.

    <plugin>
     <groupId>com.jaxio.prototype</groupId>
     <artifactId>maven-celerio-plugin</artifactId>
     <configuration>
      <celerio:celerio>
       <celerio:my>
           <celerio:really>
               <celerio:deep>
                   <celerio:nested-structure>
                       <celerio:that>makes sense to you</celerio:that>
                   </celerio:nested-structure>
               </celerio:deep>
           </celerio:really>
       </celerio:my>
      </celerio:celerio>
     </configuration>
        <executions>
            ...
        </executions>
    </plugin>

Then the rainbow :)

So by noticing the attribute in the maven xsd, and following its logic I went on adding real value to our product that is:

auto-documented configuration via xsd in both pom.xml and xml configuration file
a single configuration
a single documentation
and no more (valid) questions from our customer

Introducing JPA in the code generated by SpringFuse

2009-06-22T00:00:00-07:00

Introducing JPA in the code generated by SpringFuse

In version 2.8.9, we are introducing JPA in the code generated by SpringFuse. I t was the most demanded feature from our users.

The beans of the generated domain layer now use JPA annotations. Since we wanted to keep all the features we had in previous version of SpringFuse, there are still some Hibernate dependencies in the generated code. For example we use the Criteria API in the generated DAO layer. We also use some specific Hibernate annotations at the bean level, for example to configure the second level cache.

We think this is not a problem. When JPA 2.0 will be out we might reduce the number of hibernate dependencies. However, this is not our priority.

Another important change in the generated code is the use of Generics. We have factorized most of the DAO and manager code implementations/interfaces in base classes/interfaces using generic types.

We encourage you to generate or regenerate a project with the latest version of SpringFuse to benefit from the JPA support.

Changes in SpringFuse offer

2009-06-06T00:00:00-07:00

Changes in SpringFuse offer

Based on numerous users feedbacks, we have slightly changed our SpringFuse offer, for the better of course!

Springfuse Free Trial changes

You can now generate and download as many projects as you want for database schema having up to 10 tables instead 4.

This new limit should allow you to evaluate SpringFuse on small application or a subset of your application.

Springfuse 1 Month Pass changes<

You can now generate and download as many projects as you want for database schema having up to 100 tables, instead of 50, over a 1 month period.

We have also changed the currency from Euro to US Dollars without adjusting the price (it is now 249$)

Thanks again for your support and your feedbacks.

Springfuse approach to code generation

2009-03-25T00:00:00-07:00

Springfuse approach to code generation

One of the most interesting objections I ever received about code generation came from a woman who told me:

« Code generators are great, but only their creator can really use them. So at the end, they are useless ».

That’s a point!

I think she is right, it is pretty hard to write a code generator that can be used by other people without having them to understand the ins and outs of the code generator itself.

You probably cannot create an easy to use code generator that produces exactly what you have in mind. It is a bit like the Heisenberg’s principle, you cannot get the exact position and speed of a particle at the same time… you have to choose your camp.

With SpringFuse, we made a clear choice. We choose the camp of simplicity. We sacrifice the possibility to configure extensively the generator to produce exactly what you want.

For example, we do not try to generate business code out of complex rules that tend to resemble to code! Instead SpringFuse uses existing database schema as an entry point.

The range of applications that could benefit from SpringFuse is therefore limited to database-oriented applications having a data model that fit roughly the business model. There are still many of them.

This bottom-up approach has an advantage: it leaves the developer in charge of the business layer. The generated code is just here to support the developer in his day to day job. The developer keeps the control of the code that creates the real value for the end user. Thanks to the generated code, the developer can spend more time on creating real value.

Of course the developer should understand the generated code to use it. There is no magical stuff here. But at least the code that SpringFuse generates is clean, well organized, with no cyclic dependencies. It uses many popular frameworks such as:

Spring Framework,
Spring Security,
Spring MVC,
Hibernate,
etc…

so understanding how this code works, is clearly an investment as all the technologies used are demanded by the industry.

That’s it for today!