Tycho

Let me introduce tycho in few words here. Technically tycho is a set of maven plugins. But let it be said at the beginning, tycho tries to use all the eclipse PDE/JDT metadata first, everywhere it’s possible and therefore one of the goals of tycho project is to minimise configuraton duplication in maven artefacts. I try to show how this works on a working example.

But first here is the self-speaking list of tychos packaging types, i will covers here some of them more detailed.

• eclipse-plugin result in Eclipse Plug-In bundle
• eclipse-test-plugin result in a test Plugin
• eclipse-feature wich eclipse feature as Result
• eclipse-application builds Eclipse Applicaton
• eclipse-repository builds repository an executables
• eclipse-update-site responisble for update-sites

Tycho current release is 0.13.0 and is used in my example.

Example Application.

In this article used applicaton is Open source and can be cloned from GitHub (Shuron’s RCP Life Game). This app is a very basic but working implementation of Conways Life Game. Technically it consist of: one parent project, one plugin project, one feature, as well as one target and a one repository projects. If you check that out, you will be able to start the game out of eclipse IDE by klicking on the “Launch Eclipse Application” Button in open org.holbreich.lfgm.eclipse-repository/example.product file.
As you know an RCP application “have to” be build with some set of the eclipse platform plugins – target platform. That is where we start.

Target platform

The definition of the target platform in eclipse can be stored in file with file-extension .target. So my example target platform definition looks like following.

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<?pde version="3.6"?>
<target name="eclipse 3.7.1 (indigo)" sequenceNumber="16">
 <locations>
  <location includeAllPlatforms="false" includeMode="planner" includeSource="false" type="InstallableUnit">
  <unit id="org.eclipse.rcp.source.feature.group" version="3.7.1.r37x_v20110729-9DB5FmNFnFLSFCtLxnRfMqt15A4A"/>
  <unit id="org.eclipse.equinox.sdk.feature.group" version="3.7.1.R37x_v20110907-7M7W8h8eNV4Vrz-hz01A7SL_MhZP"/>
  <unit id="org.eclipse.pde.feature.group" version="3.7.1.r37x_v20110810-0800-7b7qFVtFEx2XnmZ4jlM5mjM"/>
  <repository location="http://download.eclipse.org/releases/indigo"/>
 </location>
</locations>
</target>

Maven’s central project configuration file is pom.xml. The Element build of the pom.xml is a central element where all the needed (plugin) declarations are placed, so that maven is able to get the knowlege about how to compile and build desired artefacts. Typically you’ll find here the definition of needed maven plugins with their configurations, executions and goals. Please see pom.xml Reference on detailed information on how it works toghether in maven.

The target platfrom which was mentioned abow is introduced to maven through mavens’s build-helper-maven-plugin as an artifact. See the configuration section of that plugin.

 <build>
    <plugins>
       <plugin>
        <!-- Id and version of build helper plugin -->
	<groupId>org.codehaus.mojo</groupId>
        <artifactId>build-helper-maven-plugin</artifactId>
	<version>1.3</version>
		<executions>
		<execution>
		  <id>attach-artifacts</id>
		  <phase>package</phase>
		  <goals>
			<goal>attach-artifact</goal>
		  </goals>
		  <configuration>
		        <artifacts>
                             <artifact>
				 <file>indigo.target</file>
				 <type>target</type>
				 <classifier>indigo</classifier>
			     </artifact>
		         </artifacts>
		  </configuration>
		</execution>
		</executions>
	</plugin>
	</plugins>
</build>

Now our target platform can be used whenever we like and we would like to use it nearly everywhere, so that leads to the idea to provide this last configuration only once in the parent pom.xml of the maven parent project for the whole Life Game Application.

Parent project

A parent project is a maven way to handle a kind of configuration inheritance. My so called parent project defines some usefull and multiply used things for all of the modules used in the current application and also provides me the ability to build the whole application at once. Let me show you the whole file here, excuse me if it appears a bit unreadable now.

<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 

http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>
  <groupId>org.holbreich.lfgm</groupId>
  <artifactId>parent</artifactId>
  <version>1.0.0-SNAPSHOT</version>
  <packaging>pom</packaging>
  <name>Shuron's Life Game Maven Parent Project</name>

  <properties>
    <!-- just some properties, tycho version and encoding -->
  <tycho-version>0.13.0</tycho-version>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
<!-- eclipse IDE flat project style. So parent project is only sibling folder
   therefore has to acces his modules by "../". Here are all the child modules. -->
	<modules>
		<module>../org.holbreich.lfgm</module>
		<module>../org.holbreich.lfgm.target</module>
		<module>../org.holbreich.lfgm.feature</module>
		<module>../org.holbreich.lfgm.eclipse-repository</module>
	</modules>

	<build>
		<plugins>
                  <!-- defintion of tychos target-platform-configuration plugin -->
			<plugin>
				<groupId>org.eclipse.tycho</groupId>
				<artifactId>target-platform-configuration</artifactId>
				<version>${tycho-version}</version>
				<configuration>
					<resolver>p2</resolver>
					<target>
                            <!--  A reference to target platform artefact: -->
						<artifact>
							<groupId>org.holbreich.lfgm</groupId>
							<artifactId>target-platform</artifactId>
							<version>1.0.0-SNAPSHOT</version>
							<classifier>indigo</classifier>
						</artifact>
					</target>
					<ignoreTychoRepositories>true</ignoreTychoRepositories>
                           <!-- Environment configuration for the taget platform -->
					<environments>
						<environment>
							<os>win32</os>
							<ws>win32</ws>
							<arch>x86</arch>
						</environment>
						<environment>
							<os>linux</os>
							<ws>gtk</ws>
							<arch>x86</arch>
  						</environment>
					</environments>
				</configuration>
			</plugin>
                 <!-- defintion of tycho-maven-plugin -->
			<plugin>
				<groupId>org.eclipse.tycho</groupId>
				<artifactId>tycho-maven-plugin</artifactId>
				<version>${tycho-version}</version>
				<extensions>true</extensions>
			</plugin>
		</plugins>
	</build>
</project>

As already mentioned in the comments of the pom.xml that defines known modules and a set of plugins with their configuration, here actually two plugins:

• target-platform-configuraton – which refers to allready discussed target platform artifact and provides aditional environment configuration.
• tycho-maven-plugin – which cdefines  addtional packaging types like eclipse-plugin and eclipse feature.

That definition allows you to minimize pom.xml of the plugin’s and features self.

Plug-in pom.xml

As all used plugins are already defined in the parent, the actual the pom.xml file of the pluign project is pretty short and looks like this:

<?xml version="1.0" encoding="UTF-8"?>
<project
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 

http://maven.apache.org/xsd/maven-4.0.0.xsd"

	xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<modelVersion>4.0.0</modelVersion>
	<artifactId>org.holbreich.lfgm</artifactId>
	<version>1.0.0-SNAPSHOT</version>
	<packaging>eclipse-plugin</packaging>
	<!-- Parent reference -->
	<parent>
    	 <artifactId>parent</artifactId>
    	 <groupId>org.holbreich.lfgm</groupId>
    	 <version>1.0.0-SNAPSHOT</version>
    	 <relativePath>../org.holbreich.lfgm.parent/pom.xml</relativePath>
  	</parent>
</project>

And this is great, becuase in a larg application you will have much of the plugings with their simple pom files.
You see the important moment is the reference to the parent and declaration of the packaging type eclipse-plugin. Eclipse Feature project uses eclipse-feature packaging target, but looks most the same, so i’m not showing it here.

Repository

And finally Repositoy Plugin come into play. It’s defines routines for the last assembly and packing of a product. Here i bring only the build element of the pom.xml file where the execution element of tycho-p2-director-plugin defines these two goals.

  <build>
	<plugins>
	<plugin>
		<groupId>org.eclipse.tycho</groupId>
		<artifactId>tycho-p2-director-plugin</artifactId>
		<version>${tycho-version}</version>
		<executions>
			<execution>
				<id>materialize-products</id>
				<goals>
					<goal>materialize-products</goal>
				</goals>
			</execution>
			<execution>
				<id>archive-products</id>
				<goals>
					<goal>archive-products</goal>
				</goals>
			</execution>
		</executions>
	</plugin>
	</plugins>
</build>

Now here we are. I’v didn’t mentioned further eclipse artefacts like feature.xml or some.project, they stay as usual and musst work also whitout maven. You can start to buld your app by executing maven golas like mvn clean install or make this configuration in your CI.

Build automatisation with Jenkins CI

The showed configuration is ready for automation as it is. You can automate this e.g. very simple with a standard Jenkins maven job. Provide git chekout path, for all the projects and define e.g. clean install as maven goals for execution on parent project’s pom.xml in yout Jenkins Job.

However zipped standalone executables for Linux and Windows can be found under org.holbreich.lfgm.eclipse-repository/target/products/ in the project workspace after sucessfull build. Have fun and let me know if you missed something i this description.

Further questions

This post was supposed to give you first motivation to try tycho on your own project and of course not all the aspects of the tycho build are covered here. I think following aspects are good topics for a discussion and future articles:

• Release configuration and management is e.g. a topic for itsself and is straght-forward maven relase.
• Eclipse Test Plugin
• Code qulity with maven: Ceckstyle, PMD, corbetrura & Co
• Eclipse repository and update-side management
• More maven best practices

Let me know if something of the abow topic is something of your interesst.
As well you are invited to comment your solutions and best practices.

Further Readings

• Tycho reference card
• Maven getting started
• Maven POM-file reference
• Tycho package Types

Tank you for reading if you got here

wget http://download.oracle.com/otn-pub/java/jdk/7/jdk-7-linux-x64.tar.gz
tar zxvf jdk-7-linux-x64.tar.gz -C /usr/lib64/jvm/

Then we have to do some configuration.
Debian Linux has useful script to maintain different version of one programs like java called update-altenatives. So i simply use this.

update-alternatives --install /usr/bin/java java /usr/lib/jvm/jdk1.7.0/bin/java 1065
update-alternatives --install /usr/bin/javac javac /usr/lib/jvm/jdk1.7.0/bin/javac 1065

Where 1065 is a given priority.

To check my installation i use –config paramter

update-alternatives --config java
#this prints:
There are 2 choices for the alternative java (providing /usr/bin/java).

  Selection    Path                                      Priority   Status
------------------------------------------------------------
* 0            /usr/lib/jvm/jdk1.7.0/bin/java             1065      auto mode
  1            /usr/lib/jvm/java-6-openjdk/jre/bin/java   1061      manual mode
  2            /usr/lib/jvm/jdk1.7.0/bin/java             1065      manual mode</pre>

And because 1065 is higher than 1061, the fresh installed java 7 will be used by default on my machine

java -version
#prints:
java version "1.7.0"
 Java(TM) SE Runtime Environment (build 1.7.0-b147)
 Java HotSpot(TM) 64-Bit Server VM (build 21.0-b17, mixed mode)

Hope this save somebody some setup time.

Every year i try some of them and  remove them after few hours. As i remember, they where resource-hungry or just bad in reverse engineering

Some weeks ago i tried ObjectAid UML Explorer Class Diagram and liked it. It could quick and easy create simple class Diagrams – just by Drag & Drop. And i had no problems with static constructors or inner classes and other stuff in the code which causes problems to another Plug-ins.

Unfortunately Object Aid Sequence Diagram are not free but cost not much for private usage. Maybe i’ll try it soon.

But first i would ask you what is your favorite Eclipse IDE Plug-in for fast and easy (e.g. partly) revers engineered UML diagrams which can be used to show some architectural details to your colleagues?

Thank you for comments!

(This article should be finished half year ago right after i wrote about svn server installation, but unfortunatelly i didn’t find any time to finish it untill now.)

Motivation

My first version control system (VCS) was CVS and i used it with eclipse 2.0 for programming in java. I found CVS quite impressive and liked it a lot. It was also quite reliable and moderatelly fast.
Then someone at the university told us to use SVN, because it has “plenty” of advantages. Somehow i found SVN not bad even if the eclipse svn plugin quality was never quite good. However SVN matured  and became powerful source control system and many many people and companies started using it. I think it’s the most used version control system.

I like SVN for easy branching and tagging (with good eclipse plugin support), for global version numbers, for understanding “http://” (with Web-Dav) as well as for more comfortable managing tools and easy installation and configuration.

But that’s all what i like… There is no more practical advantages over CVS and moreover there are even some disadvantages also in comparison to cvs.

• SVN is slow and double slow over HTTP. It may not be critical if you do your changes on several files and them commits ‘em. I’m doing so in my  java project and it’s ok. But there could be also other scenarios e.g. if you deal with such “monsters” like magento, performance gain very fast on importance
• Folder movement is a nightmare. With the subversion you have to know what you do when you start move around your folders.
• Ugly .svn folders in the folder tree of your project. O course cvs had them too. But do we really need them? Sometimes i just wanna to copy my project tree without that stuff.
• Not closed connection (don’t know if it is an server or eclipse plugin bug). Sometimes svn commits leave not closed connection. Eclipse hangs.
• SVN consumesa lot of space, more than cvs local and on the server.
• You need to be online if you want to commit.

All of these disadvantages i mentioned above are fixed in GIT. Git is much faster, flexible. So let  install it!

Installation

We start with installing the git-core component from linux (debian in my case) public repositories.

$ apt-get update
$ apt-get install git-core

After executing of these commands, which takes only approx. 2 seconds. you have installed the git-core on your machine. So now you can test it by checking the version or common commands list

$ git --version
# Returns e.g.:  git version 1.5.6.5
$ git
# Returns usage options

First good thing to do after a fresh git installation is to define some global properties:

$ git config --global user.name "Alexander Holbreich"
$ git config --global user.email "alexander@xxxxx.org"
$ git config --global color.status auto
$ git config --global color.branch auto

There are also more properties and configuration possibilities for git. But for normal usage you will never need them. If you think different see git config manual.

Normally you will be ready with git installation now.

Usage (Remote repositories)

First you should think about your branching model. Start by nvie model. It looks  a bit complicated, but it covers nearly every aspect in big project work.  In an agile team such an approach is very easy maintained by git. See also related Stackoverflow discussion.

There is a lot of documentation on git usage on the internet so it makes not much sense to cover everything here again. But if you was interested in installing git, maybe you plan to maintain new reposity, so let’s look at them.

Small teams maybe would prefer to work with one central repository (centralized workflow) for it is a common approach we know from svn and cvs times.

Below a bare repository is created as a central one:

$ git init --bare

Then you can clone this (remote) repository to the local one

$ git clone git://originrepository.place/somedir/

Continue to work with local repository, add, remove, and commit files to local one.  If you decide to propagate your changes, say at the end of a day, to the central repository, use:

$ git push origin master

Cloned repositories know their origin repository automatically. “Origins”  have to be bare repository because they have no checked-out working trees. If you push to a repository which has a checked-out working tree (which is still allowed) the working tree will not be updated, and that may lead to unexpected results. To sum up, let your central repositories be created by git init –bare.

In git it is possible to have several remote repositories for one local. You can add them like this:

# here http is used as example
$ git remote add  somelib http://someremoteplace/lib/repo..

where “somelib” is the alias of repo. Next command shows known remote locations:

$ git remote -v # shows defined remote repositories aliases with URLs.

I hope this gives you a motivation to start using GIT. Hope also to see your questions or ideas in the comments.

More Info and Tools

• Git command reference
• Usage tutorial
• Git user manual
• Git Pro Book (Online)
• msysgit git for windows

Web Service related changes

The new redesigned Java API for XML Web Services (JAX-WS) is the base or a middle part of a newly Java EE 6 Web service stack.  The new stack  includes JAX-WS 2.0, JAXB 2.0, and SAAJ 1.3. and is also called “integrated stack”.  JAX-WS was designed to take place of JAX-RPC. Due this also JSR-109 was updated because it describes run time architecture of JEE Web Services Stack. JAXB which provides an easy way to bind an XML schema to java and vice verse, was updated to.

The SOAP with Attachments API for Java (SAAJ) (also known as Java APIs for XML Messaging (JAXM)) provides a standard way to send XML documents over the Internet from the Java platform and was updated slightly containing now other consolidated standard.

New are JAX-RS, which provides support for RESTful Web services and JAXR which enables pull-parsing API for reading and writing XML documents. Also available in Java SE.

Web Applications related changes

In Java EE 6 we have updates of all technologies of the Web Container except JSTL. So e.g. Servlet 3.0 improves Servlet concept in pluggability and some ease of development. It’s also introduces Async Servlet, and long waited File Uploading!. Also now configuration can be done by annotations.

New a specification of Debugging Support for Other Languages 1.0
This describes standardized tools for correlating Java virtual machine byte code to source code of languages other than the Java programming language, so it would guarantee debugging possibility of everything what runs is JSR-45 certified container.

Enterprise Technologies changes

In Enterprise Application section we see some important changes and new specifications. Most famous and important is  JSR-299 Context and Dependency Injection (CDI) which is there to unify the JavaServer Faces-managed bean component model with the Enterprise JavaBeans component model to simplify the programming model and architecture of web-based applications. Look an Weld Framework as reference implementation to this.

The similar sounding Standard Dependency Injection for Java JSR-330 just define a standard and common known DI like in spring and other frameworks. Look at popular Guice DI-Framework from Google which implements JSR-330.

Bean Validation  introduces a very cool annotation based and architecture layer independent Java Bean validation.

There are also some interesting improvements in EJBs. Singleton is a new type and can be only one per container, it is also possible to use @Local Beans (Same VM) without interface. Also JPA 2.0 has advanced query possibilities and validation.

Management Technologies

Nothing special to mention here.

Java EE 6 Certified Application Server

• Oracle (former Sun) GlassFish AS 3.0.1 Full certified
• JBoss AS 6.0.0 Web Profile certification
• IBM WebSphere Application Server V8.0 (in development, Beta available) should be full certified

Please feel free to correct me or provide additional information.

• JSR-175: A Metadata Facility for the JavaTM^TM Programming Language. Also known as Java Annotations e.g. @Deprecated or @Override.
• JSR-181: Web ServiceMetadatata for the Java Platform. This is just a set of Annotations for using with JAX-WS WebServiceses. Think of  Annotations @WebService, @WebMethod…
• JSR-101: API for XML-based RPC: JAX-RPC 1.1. Definiton of RCP call with SOAP Messages, Type Mapping between Java  and XML.
  
• JSR-109: Implementing Enterprise Web Services Definiton of WebsServices based on JAX-RPC which is now accessed by JAX-WS. That early standard defined WebServiceses for J2EE 1.4. It enabled implementation of Web-Serviceses as Endpoints over Enterprise Session Bean’s (EJB 2 generation with awful  XML descriptors).
• JSR 183: Web Services Message Security APIs
  
• JSR-224: The Java API for XML-Based Web Services (JAX-WS) 2.2
  • Final Release 05.2006 (Version 2.0 JEE 5) ,Last Maintenance 12.200Verisonon (2.2 JEE 6).
  • Current state of the art
  • Relies on its own Architecture for XML Binding JSR -222
  • Of course supports Annotations JSR -181
  • Implementations: Apache CXF, JBoss WS, JAX-WS as Sun’s Ref. Implementation
• JSR-311: JAX-RS: Java ^TM API RESTful Web Services
  • Final Release 10.2008
  • Part of JEE 6
  • AlWeb Servicesvices of REST Style jusPOJOsPOJOs
  • Mseen ssen such typical Annotations like: @Path , @GET，@PUT, @POST，@DELETE
  • Implementations: Apache CXF, Apache Wink, Resteasy as part of JBoss/Tomcat,   Jersey – Sun’s Ref. implementation.

Did I forgot something?

However this is not one post which should bring JIRA near to you. But if you know that you need it, now is best time to get it, because Atlassian started their “Get Startet” Price, which now allows you to by full functional JIRA for 10$ for ever even with one year support. All you need is a little bit of free CPU time, root access, 10$ and if you buy it outside of USA, you will need a credit card.

I installed it  for my private purposes and it works fine! I just followed Atlassian documentation (Read it carefully). Maybe, the easiest way is to install the “all in one” solution which comes with Apache Tomcat. I choosed that one. But don’t forget to switch to serious database before you start really using it. Take MySQL for example like I did.

I will not provide here step by step how to do it, because Simon has already described some of the important configurations moments as he heard about new pricing and as already mentioned the Atlassian installation guide is good and really answered all my questions.

Nevertheless feel free to ask questions here, about installation and configuration to.

Also i would like to discuss other Atlassian developer tools which also available for 10$. Is here outside someone experienced in bamboo?

Please feel free to comment here or there if you know what died changed in Ganymede in ant scripts handling since Europe release and how to fix it.

UPD. Solution!

The problem seems not to do anything with eclipse (logical) but it depends on used ant version. Some version are not good for wscompile.
In my case ant version 1.6.5 and 1.7.1 where not good for wscompile task.
In ant 1.7.0 wscompile tasks works as usual.
May this help somebody!

Occupational i deal with people who works with already aged version WSAD (Rational Application Developer for Web Sphere). I think they use version 5 which is based on eclipse platform in version 2.0 or 2.1 where folding was not supported.

Folding feature of eclipse based IDE’s allows you to clap uninteresting code fragments like methods constructors or imports out from your scope just in place.

So one of developers was just dropping all of his classes in just one package, doing it in apposite to the structure of whole project. He argued that doing so, hi has only one import statement in his classes for all classes from his “containing all” package. Having 15-20 import statements in a class disturbs!

God bless folding feature! Curtain!

… Database Trigger is predefined database procedure, conditionally or unconditionally succeeding or preceding other database operations automatically…[IBM Research Report, RJ1820, 1976]

That is actually what triggers are still today. But alone that definition make clear, that triggers can be also exploited for other purposes, like audit or security, but also for modelling (parts) of application logic or business rules. The main question, that appears is what should triggers do, what it can be used for, and when it becomes ugly? Generalising question thereby is, how much business logic should be done by the Database systems.

You can quick “google” for some answers like evans or from codeproject. But also academia gives similar answers. And this is good so, then there is no need to put application logic to Database tier, contrariwise logic in the database tier is contra productive.

At the moment i have to deal with some very large logistic system which logic is mostly implemented as triggers, not even stored procedures but triggers. The decision to build that system on triggers is unforgivable, even if that System was concept for years (i don’t know how old is it). I thing everybody understand why dealing with triggers is not comparable with one clean implementation of logic through e.g. 2EE based Middle-tier. At first the main logic and rules of the system are spread in a hundreds of triggers over hundreds of tables and therefore it is very difficult to maintenance. Secondly there are many side effects present, and many of them are unfortunately hard to predict, so that some kind of not determinism is always in the air. And at third there are problems on bulk updates, of course, when triggers start the avalanche, cascading each other!

Well, the richness of DB functions and options alone, should not lead to the meaning that all logic should be done in the Database-tier. Of course Database Systems which are rich on functions sells better. Yea! Maybe even better than sex . But at the End we should be carefully with every extra!

Concluding there are some tips when to use triggers:

1. Use them for Integrity control! There where invented for it!

2. Use them careful for Audit trails, consider also triggers are transaction safe, so when an operation is rolled back, all its triggered operations are also rolled back.

3. Use trigger careful for other administrative things like replication or notification.

4. Avoid to use triggers for business logic!

P.S. Next time i maybe explain why it is bad idea to programm Business applications in Visual Basic or atomate business processes witch MS Access )))

JunitEE

But Junit has some limitations, therefore, testing in each application server container becomes a tedious process. The JunitEE test framework addresses these limitations. This framework extends the standard JUnit so that tests can be executed in an application server container. JunitEE is configured in the J2EE Web module of a unit test application, and it uses a TestRunner to output HTML or XML test results. So according to Junitee.org there are following benefites :

• Your tests are packaged conveniently into a .war file which can easily be moved between servers; you can leave the .war file in the main .ear file and simply avoid enabling the test web application on the production server.
• Your test classes will be dynamically reloaded by the app server (assuming your server supports this).
• Your test cases look just like your production code, and can use the same beans (or whatever) you use as a facade for your EJBs.

How it works? Roughly it could be described like below, see resources for detailed examples:

1. Develop JUnit test cases
2. Create and configure a JUnitEE test modulePlace
   1. junit.jar and junitee.jar files in the project classpath by placing them in the WEB-INF/lib directory
   2. a jar file, like MyUnitTest.jar, containing your Test classes. Copy this file into the WEB-INF/lib directory too
   3. Include in the Servlet description like shown below in the web.xml deployment descriptor
3. Deploy and execute test cases on the Application Server.

{[.xml1 /enzymes/xml.php]}

Resources

1. New features in Junit 4
2. JunitEE Tutorial
3. Other Junit Extensions for J2EE
4. An extended example from IBM

The Java Persistence API provides a POJO persistence model for object-relational mapping. The Java Persistence API was developed by the EJB 3.0 software expert group as part of JSR 220, but its use is not limited to EJB software components. It can also be used directly by web applications and application clients, and even outside the Java EE platform, for example, in Java SE applications

So let’s look a bit deeper into the features of new API.

Persistence is dealing with entities. An Entitiy is a lightweight domain specific object (in java) that sometimes should be stored to persistent storage of some kind (e.g. Relational Database).  Typically an entity is represented by a Databae table in a relational databases and each entity instance corresponds with a row in that table.

In the Java Persistence API,  persistent state of an entity is represented either through persistent fields or persistent properties. These fields  use object-relational mapping annotations to map the entities and entity relationships to the relational data in the underlying data store.

So Entities are marked with the @Entity (javax.persistence.Entity) annotation and the entity-class should implement Serializable interface. Further requirements for entitiy classes can be found in the Java EE 5 Tutorial.

Here is  just little examle of Persisten entitiy “User”.

package de.holbreich.chopping;
import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.Table;
import javax.persistence.Column;
import javax.persistence.Id;

@Entity
@Table (name="User")
public class Userimplements Serializable {
 @Id
 @Column(name="id", nullable=false)
 private String userId;

 @Column(name="Username")
 private String username;

 @Column(name="Firstname")
 private String firstname

 public void setUserId(String userId){
 this.userId= userId;
 }

 public String getUserId() {
 return this.userId;
 }

 public void setUsername(String username) {
 this.username=username;
 }

 public String getUsername() {
 return this.username;
 }
...
}

If the entity name is the same as that of the table name, @Table is not required. The same with @Column Attribute. Not Persistent Fields or methods should be marked with @Transient. Here more Information about persistent field and properties and especially Primary Keys.
So far its quite simple.

Entities can have relations to each other. Java Persistence API knows four types of multiplicities: one-to-one, one-to-many, many-to-one, and many-to-many, which are marked with appropriate anotations. Furthermore relationships can be unidirectional or bidirectional. In a unidirectional relationship, only one entity has a relationship field or property that refers to the other. Read more about it.

This looks really interesting to me. But it gone to be better then, the Java Persistence API has an important new feature that was not covered bu SUN before: support for inheritance and polymorphism. An entity may inherit from another entity class. By default, the queries are polymorphic and are applicable against the entire entity hierarchy. Read more about inheritance posibilities.

An finely there is a new and better Query language

Queries and query language

The Java Persistence query language (JPQL) is an extension of the EJB QL, but overcomes EJB QL’s limitations and provides more features such as:

• Bulk update and delete operations
• Join operations
• Group-by operations
• Having operations
• Projection and sub-queries
• Support for dynamic queries
• Use of named parameters (named parameters are parameters in a query that are prefixed with a colon (:))

More on JPQL in the Tutorial

Management of entities

Entities are managed by the entity manager. The entity manager is represented by javax.persistence.EntityManager instances. Each EntityManager instance is associated with a persistence context. A persistence context is a set of managed entity instances that exist in a particular data store and defines the scope under which particular entity instances are created, persisted, and removed.

As expected the are two kinds of managers an container managed and one application managed.
With a container-managed entity manager, an EntityManager instance’s persistence context is automatically propagated by the container to all application components that use the EntityManager instance within a single Java Transaction Architecture (JTA) transaction.

@PersistenceContext(unitName="user")
EntityManager em;

With application-managed entity managers, on the other hand, the persistence context is not propagated to application components, and the life-cycle of EntityManager instances is managed by the application.

@PersistenceUnit(unitName="user")
EntityManagerFactory emf;
EntityManager em = emf.createEntityManager();

Persistent context is described in persistense.xml file

Conclusion

I thik the Java Persistence API is an real cool standard, hope start use it soon. Here are the key features of it summarized:

• Standardizes the persistence API for the Java platform
• Brings simplification through a simple POJO-based persistence model
• Annotations should makes entity coding and deployment easier
• And of course features like support for inheritance and polymorphism, simplistic entity relationship declaration bring the whole thing to new level.
• Advantages of JPQL

Furthermore Java Persistence API can be used for Java SE environments too. This is possible because of the Java Persistence API’s support outside the EJB container.

1. Java Persistence API on java.sun.com
2. Java Persistence API in the Java EE 5 Tototial
3. Good Article goes detailed on inheritance at JavaWorld
4. Extended fetures in Examples of using Persistence API in EJB tier
   
5. Using Persistens with JSF
6. Java WebStart Persistence