<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE jnlp PUBLIC "-//Sun Microsystems, Inc.//DTD JNLP 1.5//EN" "http://www.netbeans.org/jnlp/DTD/jnlp.dtd">
<jnlp codebase="file:///C:/Netbeans/JPAWebStart" href="JPAWebStart.bad.jnlp">
<information>
<title>JPAWebStart fail</title>
<vendor>Company, Inc.</vendor>
<homepage href="homepage.html"/>
<description> </description>
<icon href="default"/>
<offline-allowed/>
<shortcut online="true"/>
</information>
<resources>
<j2se href="http://java.sun.com/products/autodl/j2se" version="1.6+"/>
</resources>
<resources>
<jar download="eager" href="dist/JPAWebStart.jar" main="false"/>
</resources>
<resources>
<jar download="eager" href="dist/lib/toplink-essentials.jar" main="false" version=""/>
</resources>
<resources>
<jar download="eager" href="dist/lib/derby.jar" main="false" version=""/>
</resources>
<application-desc main-class="demo.ui.JPAWebStartDemo"/>
</jnlp>
|
Ok, off I go to run my application:
javaws JPAWebStart.bad.jnlp |
And low and behold, I get the following error:
Exception in thread "AWT-EventQueue-0" javax.persistence.PersistenceException: No Persistence provider for EntityManager named JPAWebStartPU at javax.persistence.Persistence.createEntityManagerFactory(Persistence.java:89) at javax.persistence.Persistence.createEntityManagerFactory(Persistence.java:60) at demo.ContactImpl$1.run(ContactImpl.java:37) at java.security.AccessController.doPrivileged(Native Method) at demo.ContactImpl. |
Why is my Persistence provider not found when I can run the application fine as a standalone application from the command line or from NetBeans?
The error message is misleading as the issue turns out to be due to the sandbox environment that Java Web Start uses to protect users from untrusted applications.
So where do we go from here? Well, we will create two jnlp files, one to start our application, the other which contains the classes which require more access then the sandbox allows. The jar files contained in the second jnlp, which is referenced from our first jnlp file, will enable access to the system and all jar files listed as resources will be signed.
Here is the new JNLP file, JPAWebStart.jnlp, used to launch my application:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE jnlp PUBLIC "-//Sun Microsystems, Inc.//DTD JNLP 1.5//EN" "http://www.netbeans.org/jnlp/DTD/jnlp.dtd">
<jnlp codebase="file:///C:/Netbeans/JPAWebStart" href="JPAWebStart.jnlp">
<information>
<title>JPAWebStart Demo</title>
<vendor>Company, Inc.</vendor>
<homepage href="homepage.html"/>
<description> </description>
<icon href="default"/>
<offline-allowed/>
<shortcut online="true"/>
</information>
<resources>
<j2se href="http://java.sun.com/products/autodl/j2se" version="1.6+"/>
</resources>
<resources>
<jar download="eager" href="dist/JPAWebStartMain.jar" main="false"/>
</resources>
<resources>
<extension href="JPAPermissions.jnlp" name="jpa"/>
</resources>
<application-desc main-class="demo.main.JPADemo"/>
</jnlp>
|
I made the following changes to JPAWebStart.jnlp:
- Start the application via a new program which resides in the jar JPAWebStartMain.jar
- Use the extension element to reference the JPAPermissions.jnlp which contains the jars that needed to be signed as well as grant the access beyond what is allowed by the sandbox
Here is the JPAPermissions.jnlp which contains all of the signed jars and enables the extra security access:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE jnlp PUBLIC "-//Sun Microsystems, Inc.//DTD JNLP 1.5//EN" "http://www.netbeans.org/jnlp/DTD/jnlp.dtd">
<jnlp codebase="file:///C:/Netbeans/JPAWebStart" href="JPAPermissions.jnlp">
<information>
<title>JPAPermissions</title>
<vendor>Company, Inc.</vendor>
<homepage href="homepage.html"/>
<description> </description>
<icon href="default"/>
<offline-allowed/>
<shortcut online="true"/>
</information>
<security>
<all-permissions/>
</security>
<resources>
<jar download="eager" href="dist/lib/toplink-essentials.jar" main="false" version=""/>
</resources>
<resources>
<jar download="eager" href="dist/lib/derby.jar" main="false" version=""/>
</resources>
<resources>
<jar download="eager" href="dist/JPAWebStart.jar" main="false"/>
</resources>
<component-desc/>
</jnlp>
|
Next, we need to sign the jars. To do this I added a -post-jar target to the default build.xml in my NetBeans project:
<target name="-post-jar">
<property name="key-alias" value="jpawebstart"\>
<property name="keystore.password" value="foobar"\>
<property name="keystore.location" value="dist/keystore"\>
<delete file="${keystore.location}"\>
<genkey alias="${key-alias}" keystore="${keystore.location}" storepass="${keystore.password}" validity="3650" dname="CN=jpawebstart, OU=jpawestart, O=net, C=US"\>
<signjar jar="dist/JPAWebStart.jar" alias="${key-alias}" keystore="${keystore.location}" storepass="${keystore.password}"\>
<signjar jar="dist/lib/derby.jar" alias="${key-alias}" keystore="${keystore.location}" storepass="${keystore.password}"\>
<signjar jar="dist/lib/toplink-essentials.jar" alias="${key-alias}" keystore="${keystore.location}" storepass="${keystore.password}"\>
<jar destfile="dist/JPAWebStartMain.jar"
basedir="build/classes"
includes="demo/main/**"
manifest="MANIFEST_MAIN.MF"
\>
</target>
|
One other addition to the -post-jar target is the creation of the jar file that is referenced in JPAWebStart.jnlp. Why am I doing it here you ask? Well, it was easier then overriding all of the default targets for building the application that NetBeans provides (if someone has an alternative suggestion, let me know).
About the JPAWebStart sample application
The sample application demonstrates the use of the Java Persistence API from Java SE, using Swing, Java DB and Java Web Start:
When the application is started the main screen is shown:
There are no contacts in the database when the application is started. To add contacts to the database, you would select the Contacts menu item, "Add Contact"
and the following form will be opened:
The main entry point to the application is the JPADemo class. JPADemo is packaged in the jar JPAWebStartMain.jar and its sole purpose is to start the rest of the application which requires more permissions than the sandbox allows:
package demo.main;
import demo.ui.JPAWebStartDemo;
public class JPADemo {
/** Creates a new instance of JPADemo */
public JPADemo() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new JPAWebStartDemo().setVisible(true);
}
});
}
}
|
As this is a simple demo, there is only one Entity used by the application, Contact:
package demo.entity;
import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
/**
* Entity class Contact
*
*/
@Entity
@Table(name="Contacts")
public class Contact implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String firstName;
private String lastName;
private String phone;
/**
* Creates a new instance of Contact
*/
public Contact() {
}
/**
* Creates a new instance of Contact
*/
public Contact(String firstName, String lastName, String phone) {
this.firstName = firstName;
this.lastName = lastName;
this.phone = phone;
}
/**
* Gets the id of this Contact.
*
* @return the id
*/
public Long getId() {
return this.id;
}
/**
* Sets the id of this Contact to the specified value.
*
* @param id the new id
*/
public void setId(Long id) {
this.id = id;
}
/**
* Returns a hash code value for the object. This implementation computes
* a hash code value based on the id fields in this object.
* @return a hash code value for this object.
*/
@Override
public int hashCode() {
int hash = 0;
hash += (this.id != null ? this.id.hashCode() : 0);
return hash;
}
/**
* Determines whether another object is equal to this TestPerson. The result is
*
|
To persist a new Contact, the addContact() method of ContactImpl is called:
public void addContact(Contact contact) {
try{
em = emf.createEntityManager();
em.getTransaction().begin();
em.persist(contact);
em.getTransaction().commit();
System.out.println("row created");
} finally {
em.close();
}
}
|
Because this application is strictly a Java SE application and not running inside of a container, the application must do the following:
- Explicitly create an EntityManagerFactory by calling Persistence.createEntityManagerFactory()
- Create an application managed EntityManager by calling the method createEntityManager() on an EntityManagerFactory instance in each method as an EntityManager is lightweight and not thread safe
- Explicitly control the transaction (this is a Resource-Local Transaction). The application must acquire an instance of EntityTransaction and then call the methods begin(), commit() and rollback() as needed.
- Close the EntityManger by calling the close() method. It is recommended that this is done in a finally block to guarantee that the EntityManager is closed.
emf = Persistence.createEntityManagerFactory("JPAWebStartPU");
|
One other thing to note is that in order to run TopLink Essentials with Java Web Start, you must enable privileges for the call to Peristence.createEntityManagerFactory which is done in the ContactImpl constructor:
public ContactImpl() {
emf = (EntityManagerFactory ) AccessController.doPrivileged(
new PrivilegedAction() {
public Object run() {
return Persistence.createEntityManagerFactory("JPAWebStartPU");
}
}
);
}
|
If you do not enable privileges for Peristence.createEntityManagerFactory, then you will encounter the following Exception:
---------------------------------------------------- |
When we configure the persistence.xml we will need to indicate that we are using a Resource-Local Transaction
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
<persistence-unit name="JPAWebStartPU" transaction-type="RESOURCE_LOCAL">
<provider>oracle.toplink.essentials.ejb.cmp3.EntityManagerFactoryProvider</provider>
<class>demo.entity.Contact</class>
<properties>
<property name="toplink.jdbc.url" value="jdbc:derby:testDB;create=true"/>
<property name="toplink.jdbc.user" value="APP"/>
<property name="toplink.jdbc.driver" value="org.apache.derby.jdbc.EmbeddedDriver"/>
<property name="toplink.jdbc.password" value="APP"/>
<property name="toplink.ddl-generation" value="drop-and-create-tables"/>
<property name="toplink.logging.level" value="FINE"/>
</properties>
</persistence-unit>
</persistence>
|
After adding a few contacts, you can then query the database allowing for the rows to either be deleted or modified:
The application provides an implementation of the JTable TableModel interface, ContactTableModel, which is used to manage the display and modification of the rows within the JTable.
package demo;
import demo.entity.Contact;
import java.util.ArrayList;
import java.util.List;
import javax.swing.table.AbstractTableModel;
/*
* ContactTableModel.java
*
* Created on May 23, 2007, 4:59 PM
*
* To change this template, choose Tools | Template Manager
* and open the template in the editor.
*/
/**
*
* @author Owner
*/
public class ContactTableModel extends AbstractTableModel {
private List
|
The ContactTableModel invokes the static factory ContactFactory.getInstance() to obtain an instance of ContactImpl which in our example is implemented using the Java Persistence API. This factory allows for providing additional implementations for accessing the database such as JDBC.
contactImpl = ContactFactory.getInstance(ContactFactory.ConfigApi.USE_JPA); |
When a query is submitted, it is built as a dynamic query. Normally you will find the use of Named queries more efficient. However, sometimes you will find you need to use a dynamic query based on the number of parameters that might be optional.
public List
|
All of the rows that are displayed in the JTable are detached and must be managed by the persistence context prior to committing the transaction. This is accomplished by calling the EntityManager method merge() prior to committing the transaction:
/**
* Remove a contact to the database. The contact that is
* passed in, needs to be merged prior to removing.
* @param contact The Contact to remove
*/
public void removeContact(Contact contact) {
try {
if(contact != null) {
em = emf.createEntityManager();
em.getTransaction().begin();
Contact mergedContact = em.merge(contact);
em.remove(mergedContact);
em.getTransaction().commit();
System.out.println("row removed");
}
} finally {
em.close();
}
}
/**
* Update a contact in the database. The contact that is
* passed in, needs to be merged prior to the update.
* @param contact The Contact to update
*/
public void updateContact(Contact contact) {
try {
em = emf.createEntityManager();
em.getTransaction().begin();
em.merge(contact);
em.getTransaction().commit();
System.out.println("row :" + contact + " updated");
} finally {
em.close();
}
}
|
Configuring the JPAWebStart application
The following steps are needed to configure the JPAWebStart application:
- The JPAWebStart application requires Java SE 6.
- Download the JPAWebStart Application
- Optionally download and install NetBeans
- Optionally install the NetBeans Java Web Start plugin from the Update Center: NetBeans Update Center Beta
- Install Java DB and update the NetBeans project properties to specify the location of the Java DB embedded JDBC driver.
- If you are going to run the JPAWebStart application using the javaws command, then you need to modify the jnlp elements in the files JPAWebStart.jnlp and JPAPermissions.jnlp files specifying the correct codebase:
<jnlp codebase="file:///C:/Netbeans/JPAWebStart" href="http://weblogs.java.net/blog/lancea/archive/JPAWebStart.jnlp">
|
For, example if you are on unix and installed JPAWebStart in /tmp, you would modify the jnlp element in JPAWebStart.jnlp and JPAPermissions.jnlp to be:
<jnlp codebase="file:///tmp/JPAWebStart" href="JPAWebStart.jnlp">
|
Running the JPAWebStart application
You can run the JPAWebStart application using Java Web Start in multiple ways:
- Using the javaws command
javaws JPAWebStart.jnlp |
- Running using the NetBeans Java Web Start plugin:
- Deploying and then running from a web browser using the NetBeans Java Web Start plugin:
- After the application deploys, a web browser will be launched allowing you to start the JPAWebStart application:
Summary
This blog provides an overview of how to successfully develop a Java SE application using Java Web Start, Java Persistence API, Swing and NetBeans 5.5. In order to use Java Web Start with the Java Persistence API, you must enable security and sign the jars for the classes which need more access than the Java Web Start sandbox allows.
The following are additional references which you might find useful when developing applications using the technologies demonstrated in this article:
- The Java Persistence API Specification
- The Glassfish Persistence home page
- The Swing Tutorial on creating and using JTables
- The Java Web Start Developer Guide
- The Java DB documentation
Special thanks to Mitesh, Markus and Ryan for a quick review, testing and suggestions for the blog..
]]>