20 abril 2009

persistence unit

Packaging

EJB3 JPA is standardizing POJO persistence. Thus, entities aren't limited to EJB modules; they can be packaged in a Web module, ejb-jar module, library module in the EAR level, or a standard jar file. You can also use entities in Java SE. You must package a descriptor (persistence.xml), like the following, in the archive that contain entities:



oracle.toplink.essentials.PersistenceProvider
jdbc/OracleDS
...

This descriptor identifies the persistence provider, persistent units, and the data source used by a persistent unit. As the name suggests, a persistent unit is a collection of entities that are managed together. If you have a single persistent unit defined in a specific module, you don't have to identify the entity classes in the persistence.xml; it will be dynamically discovered by the persistence provider.

persist an entity (Serializable) on application-managed entity manager

from Standardizing Java Persistence with the EJB3 Java Persistence API

If you persist an entity, any state changes to associated entities will be persisted as well if CascadeType for the relationship is set to PERSIST or ALL. Unless you're using an extended persistent context, the entities will become detached after the end of the transaction. The merge operation lets you merge a detached entity instance with the persistent context; the state of a detached entity will be synchronized with the database. This helps you get rid of the Data Transfer Object (DTO) anti-pattern prevalent in EJB 2.x because entities, being POJOs, can be transferred between tiers. The only requirement is that the entity class must implement the java.io.Serializable interface.

Extending the Hibernate Validation Framework for Complex Rules

go

The Hibernate Validation Framework leverages annotations to define data validation rules on entity beans. Out of the box it comes with many useful annotations for defining simple validation rules such as, NotNull, Min, Max, etc... However, for complex rules that involve multiple properties you will have to write your own validators. This posting shows two approaches to make this easier by using expression language and custom code fragments.

Simple Validations

Here is an example of a simple validation. The annotation on the amount property is scoped just to that property. Thus only simple rules can be defined.

@Entity
public class Loan {
@NotNull(message="The Amount must be provided.")
private Double amount;
...
}

Complex Validation

Here is an example of a complex validation. The annotation on the class is scoped to the whole class. Thus complex rules can be defined that involve any property in the class.

@Entity
@StartDateBeforeEndDate(message="The start date must be before the end date.")
public class Loan {
private Date startDate;
private Date endDate;
...
}

These features pretty much cover all the various validation requirements. However, defining complex validation rules requires writing both a custom annotation and a custom validator for each rule, which can become very cumbersome. Here are two ways around this issue.

Expression Language Validator

By using expression language we can write a generic validator that can be reused for various rules. The generic Expression annotation is used to define the rule.

@Entity
@Expression(value="value.startDate <>", message="The start date must be before the end date.")
public class Loan {
private Date startDate;
private Date endDate;
...
}

The ExpressionValidator class uses the commons-jexl library to evaluate the expression. The value variable in the expression equals the instance of the object being validated. In this case value is a loan.

public class ExpressionValidator implements Validator {
private String expression;
public void initialize(Expression expression) {
this.expression = expression.value();
}

public boolean isValid(Object value) {
org.apache.commons.jexl.Expression e = ExpressionFactory.createExpression(expression);
JexlContext jc = JexlHelper.createContext();
jc.getVars().put("value", value);
return (Boolean) e.evaluate(jc);
}
}

Custom Assertion Validator

There are times when you will just have to write custom validation code. But instead of writing a custom annotation and validator class it would be nice to encapsulate the rules in the same class for which the rules apply. This generic Assertion annotation and IAssertion interface do the trick.

@Entity
@Assertion(value=Loan.StartDateBeforeEndDateAssertion.class, message="The start date must be before the end date.")
public class Loan {
private Date startDate;
private Date endDate;
...
public static class StartDateBeforeEndDateAssertion implements IAssertion
{
public boolean isValid(Object value) {
Loan loan = (Loan) value;
return loan.getStartDate().before(loan.getEndDate());
}
}
}

The AssertionValidator class will create an instance of the IAssertion and execute it against the object being validated.

public class AssertionValidator implements Validator {
private IAssertion assertion;
public void initialize(Assertion assertion) {
this.assertion = (IAssertion) assertion.value().newInstance();
}

public boolean isValid(Object value) {
return assertion.isValid(value);
}
}

Hopefully the expression appoach will satisfy all your needs and you wont need this custom code approach. For example, you could add an isStartDateBeforeEndDate() method to your entity and call it in a simple expression as show below. But the custom code approach is here just in case.

@Entity
@Expression(value="value.startDateBeforeEndDate", message="The start date must be before the end date.")
public class Loan {
...
public boolean isStartDateBeforeEndDate() {
return startDate.before(endDate);
}
}

Multiple Rules

There is still another piece to this puzzle. We need to be able to apply multiple expressions or assertions. To do this we need a container annotation.

@Entity
@Expressions ({
@Expression(value="value.startDate <>", message="..."),
@Expression(value="...", message="...")
})
public class Loan {
private Date startDate;
private Date endDate;
...
}

Note that this capability relies on a requested Hibernate enhancement. You can vote for this enhancement here: JIRA Issue ANN-513 . Or you can apply the patch yourself.

Resources

Hibernate Validation Framework
Taylor Validation

Commons Jexl

An Agile Development Environment

All agile methodologies preach delivering working software early and continuously. To achieve this an automated development environment is beneficial. It is also important to get a new project up and running quickly. To this end here is a suggested development environment made up of open source tools along with instructions for getting up and running.

Server Machine

Use your perfered operationing system: Linux, Windows, etc. These instructions will be some what specific to Windows.
Two gigs of RAM, a dual processor, and a fast harddrive are the minimum recommendations.
Install Java 5 or higher: http://java.sun.com/javase/downloads/index_jdk5.jsp

Source Control Management

The first thing you will need on your development server is version control. SVN is the tool of choice!

SVN 1 Click Setup is a great utility to install SVN and TortoiseSVN on windows.

Next you want to install Apache HTTP Server to access SVN remotely.

Apache HTTP Server Download
This SVN chapter shows how to point Apache to your SVN repository: Chapter 6. Server Configuration. The basics are modify your httpd.conf file to

uncomment the DAV modules
add

LoadModule dav_svn_module modules/mod_dav_svn.so

map the location

DAV svn
SVNPath c:/svnrepos

On the client machines you will need Subclipse and TortoiseSVN.

Continuously Integration Build System

Now we need to install Maven and create your own corporate maven repository.

Download Maven
Unzip to a desired location
Add the bin directory to your system path
Add the following to your httpd.conf file

Alias /maven2/ c:/WINDOWS/system32/config/systemprofile/.m2/repository/
Alias /maven2 c:/WINDOWS/system32/config/systemprofile/.m2/repository

Options Indexes
AllowOverride All
Order allow,deny
Allow from all

Next we need to install and configure Continuum to automate your builds.

Download Continuum
Unzip to a desired location
Add the following to your httpd.conf file

ProxyPass /continuum http://localhost:8091/continuum/
ProxyPassReverse /continuum http://localhost:8091/continuum/

Alias /working-directory/ c:/continuum/working-directory/
Alias /working-directory c:/continuum/working-directory/

Options Indexes
AllowOverride All
Order allow,deny
Allow from all

Note that you will need to add the and sections to all of your pom.xml files.

Database

For running junit tests the Hypersonic in memory database is excellent. It can be downloaded automatically by maven. To demo your applications to your customers MySQL is a great choice.

Download and run

mysql-essential-4.1.21-win32.msi

mysql-gui-tools-5.0-r3-win32.msi

Download and place in your app servers lib directory

mysql-connector-java-3.1.13.zip

Application Server

To get up and running fast with JBoss AS + Portal you can start with the Taylor Tracker Bundle. It is preconfigured with various JBoss components. Just unzip it to the desired location. You will want at least two servers configured: QA and PM. The QA server will be used for running all your automated test cases and for demonstration to your customer. The PM server will run various project management and collaboration software like Taylor Tracker, JBoss Wiki, and JBoss Forum, etc.

Client Tools

On the client side us Eclipse. More information is available on the Taylor Installation page.

That is pretty much it! It is also a good idea to ghost this configuration so that you can stamp out new servers as needed. And don't forget to setup a backup schedule for the SVN repository and the MySQL database.

19 abril 2009

Taylor - Model Management

Model Management

In any real world application you will need to manage the size of your models so that multiple people can work on the project at the same time. This is often referred to as Team support.

String	String	JSF Input Text
Text	String	Text Area - TinyMCE Editor
Date	Date	Seam Date Picker
Boolean	Boolean	JSF Check Box
Integer	Long	RichFaces Spinner
Decimal	Double	JSF Decimal
Currency	BigDecimal	JSF Currency
Percentage	Double	JSF Percentage
Byte[]	byte[]	Seam File Upload
Image	String	JSF Image
Link	String	JSF Link
Enumeration	your Enum	JSF SelectOne
Many to One Association	your Class	JSF SelectOne
Double	Double	deprecated - use Decimal, Currency, or Percentage
Long	Long	deprecated - use Integer

20 abril 2009

Simple Validations

Complex Validation

Expression Language Validator

Custom Assertion Validator

Multiple Rules

Resources

Server Machine

Source Control Management

Continuously Integration Build System

Database

Application Server

Client Tools

19 abril 2009

Contents

SCM

Architecture

Tool Support

Resource Linking

Diagram Shortcuts

Controlling Packages

JSF Support

From Taylor

Seam

Possible Compilation Errors

Editor

Finder

Menus

UI Facelets

Report Facelets

Version Control

Setup

Build

Deploy

Packaging

Other Useful Maven Plugins

Reports

Packaging

Custom Plugins

14 abril 2009

07 abril 2009

06 abril 2009

02 abril 2009