David R. Heffelfinger

Screencast and Code for my JavaOne Java EE 7 / HTML 5 Presentation

2013-09-26T02:46:06-04:00

Earlier this week I had the pleasure and the privilege to give a talk at the 2013 JavaOne conference. The session was very well attended and liked.

In the session I gave a demo on how to develop JSF applications using HTML 5 friendly markup, that is, no JSF specific tags, instead using regular HTML 5 input fields with JSF attributes to bind user input to a CDI managed bean. I started the application using a sample Websocket application included with NetBeans as a base.

Then I finished the demo by adding developing a Java EE Websocket server endpoint that returned a JSON containing data to populate the JSF/HTML5 page, and finally added some Javascript to the page to parse the JSON and populate the page.

After the talk was over, a number of attendees asked for the source code to the demo. I wasn't expecting to be asked for the source code, so I hadn't uploaded it anywhere, but since there was demand for it, I just uploaded a zip file containing all of the demo source code. Feel free to download it and use it as you please.

Additionally, if you weren't able to make it to the talk, I just uploaded a screencast of the demo to Youtube, you can find it here, or, even easier, embedded below.

If you would like to learn more about Java EE development with NetBeans, please check out my Java EE Development with NetBeans video course.

My New Java EE Development With NetBeans Video Course is now available

2013-08-01T12:00:13-04:00

For the past several months I've been diligently working on developing a Java EE Development with NetBeans video course.

The course has just been published by Packt Publishing and is available for download at http://www.packtpub.com/java-ee-development-with-netbeans-7/video.

It covers all of the most popular Java EE Technologies and APIs including JSF, Facelets, EJB, and JPA, as well as many NetBeans specific tips and tricks to boost productivity.

NetBeans Tip: Quickly opening windows without memorizing keyboard shortcuts

2012-11-06T17:05:05-05:00

When working with NetBeans, sometimes I need to open a window to look at some information (breakpoints, output, etc). Windows can be accessed by going to the "Windows" pull down menu, then selecting the appropriate window, or, most windows have a keyboard shortcut (ctrl+1 for projects, for example).

The "Window" menu has several submenus, and it is not always entirely obvious where a specific window may be (the "Terminal" window, for example, is under "Output").

Sometimes I would like to open a window, but I'm not sure exactly where it is located, and I don't know it's keyboard shortcut.

Fortunately NetBeans has a "Quick Search" text field at the top right, and typing the name of the window makes it appear in the search results, therefore, if I want to open the "Breakpoints" window, for example, all I have to do is type "Breakpoints" in the quick search

Java One JSF with NetBeans BOF Demo

2012-10-06T16:18:31-04:00

I had the pleasure of being a speaker at this year's JavaOne conference. One of the sessions I participated was a Birds of a Feather (BOF) session on JSF development with the NetBeans IDE.

During the demo I showed how a complete, nice looking application can be developed in only a few minutes using NetBeans.

For the benefit of those that couldn't attend the session, here is a video of said demonstration.

For those that want to learn more, I wrote a book on NetBeans and Java EE.

New Spring to Java EE Migration Article Series

2011-11-02T10:41:54-04:00

For the past few weeks I've been working on a new article series for the Oracle Technology Network. The topic of the series is Spring to Java EE migration using the NetBeans IDE.

Part 1 of the series was just published. In this part we begin migrating Spring's sample Pet Clinic application to standard Java EE APIs such as JavaServer Faces (JSF) and the Java Persistence API (JPA), while showcasing time saving NetBeans features such as JPA entity generation.

Java EE 6 Development With NetBeans 7

2011-06-29T23:03:14-04:00

A new edition of my NetBeans book has recently been published by Packt Publishing.

The book covers NetBeans 7's support for all major Java EE 6 APIs,
including JSF 2.0, EJB 3.1, JPA 2.0, CDI 1.0 and Servlets 3.0. The book
also covers NetBeans support for PrimeFaces, a very popular high quality
JSF 2.0 component library.

Development of web applications taking advantage of new Servlet 3.0 and JSF 2.0 features is covered. New
JSF 2.0 features such as XML-less configuration, project stages, new
JSF 2.0 conventions, resource directories, Facelets templating
(including predefined templates included with NetBeans) are covered as
well. The book also explains how NetBeans can help application
developers build JSF 2.0 components using markup only, without having to
develop any Java code.

The book explains how to develop sophisticated JSF 2.0 applications with PrimeFaces.

New EJB 3.1 features such as the new EJB timer service are covered.

The book also covers NetBeans 7 support for JPA 2.0, including the new
Criteria API, and how to use NetBeans to automatically generate JPA code
from existing databases; as well as generating complete Java EE CRUD
applications from an existing database schema.

Contexts and Dependency Injection (CDI) is covered as well, including coverage of CDI
named beans, scopes, CDI Qualifiers, Stereotypes and Interceptor
Binding Types are covered as well.

After finishing the book, readers not only will be well versed in the latest Java EE technologies,
but they will also be able to take advantage of NetBeans 7
functionality that allows developing Java EE applications in record
time.

NetBeans Visual Web Pack Dead, What a Shame

2009-06-26T23:57:10-04:00

One of the features I really liked about NetBeans was it's Visual Web Pack (VWP) functionality, it allowed developing the GUI of a JSF application by simply dragging and dropping components from a palette into the page.

Although I have no trouble actually typing code or markup by hand, especially with a good code editor such as the one provided by NetBeans, the convenience of VWP didn't stop with the visual drag and drop.

When creating a VWP page, a managed bean was created automatically, and automatically added to faces-config.xml. Although on the surface this sounds simple, it was a big time saver. Additionally, a database table could be dragged to some of the components, and a lot of "plumbing" code was automatically generated to display or update, as illustrated in this tutorial.

Visual Web Pack used the Woodstock JSF component library, in October 2008, Sun announced that it would be abandoning project Woodstock, but luckily provided a migration path to IceFaces, going as far as having IceFaces provide a VWP plugin for NetBeans. Unfortunately it looked like this was the beginning of the end of VWP.

I actually used the IceFaces VWP NetBeans plugin for a small project, although my initial impression of the NetBeans IceFaces plugin was less than favorable, after a while I started liking it. Lately, I've been using the NetBeans 6.7 release candidate, one of the first things I did after installing this version of NetBeans was to get the IceFaces NetBeans plugin for it. To my surprise and dismay, it does not provide Visual Web functionality.

It is really unfortunate that for whatever reason, IceFaces decided to drop support for visual web development, as far as I can tell, all their current NetBeans plugin does is provide a palette that introduces markup to JSF pages (mind you, this is not visual), and include the IceFaces libraries in any JSF project declared to use IceFaces.

Dragging and dropping into markup is not really that useful, we can simply type an opening angled bracket ("<") and hit ctrl+space to see all the JSF tags we can use, this is actually faster than moving the hand to the mouse, scroll the components in the palette up and down until we find the one we need, then drag it and drop it to the appropriate location on the page.

The one thing I will miss the most is the automated managed bean generation, in practice, I rarely used the feature where a database table could be visually linked to a JSF component since th generated code was a bit convoluted an unusual. I want to say it used JDBC, but this is not exactly accurate, it used a VWP specific concept of a dataprovider to link the database data to the component, I tend to use JPA in my Java EE projects, the fact that the database table drag and drop functionality did not generate JPA code kept me from using it in my project.

In any case, it looks like VWP is dead, long live VWP!

NetBeans in an Old Clunker

2009-01-15T23:53:09-05:00

For the past few months I've been working with a new client that does not allowed personal hardware to be plugged into their network. They provide the hardware for their consultants and employees to use.

The only computer they had available for me was a laptop with great specs (five years ago), 1 GB of RAM, and a 1.6 Gz (single core, but I think it goes without saying) processor.

On this laptop I've had to run NetBeans, alongside with JBoss or GlassFish (one of the projects I'm working on uses JBoss another one uses GlassFish).

I've always had the fortune of having access to fairly modern hardware, and although I had heard complaints about NetBeans performance, it was always good on the hardware I had available. This situation gave me an opportunity to use NetBeans in, let's just say, "less than ideal" hardware.

What I have noticed is that NetBeans takes a very long time to initialize, but once it does, it works fine, for the most part. The most noticeable annoyance I have seen is that opening files via the "SHIFT+ALT+O" shortcut is slow, many times I finish typing the file name before the list to pick from pops up.

Even with substandard hardware, for the most part I've found that NetBeans performs fairly well.

New Version of IceFaces NetBeans Plugin Out

2009-01-10T18:10:58-05:00

A couple of days ago I noticed that the NetBeans IceFaces plugin had been updated. I wrote my initial impressions about the plugin a while back.

I've been wanting to take the updated version for a spin, but other commitments have been preventing me from trying it out. Today I had a few minutes to spare so I gave it a try.

I am happy to report that most of the issues I found with the plugin are now fixed.

Pages developed with the plugin now work with GlassFish 3 effortlessly.

Additionally, I can drop components into the navigator view to avoid the CSS absolute positioning that happens when dropping components directly in the page, please note that I only tried this under Linux, which wasn't broken to start with; in my previous test I used both a Windows and a Linux box, and only under Windows I wasn't able to drop components in the navigator.

I was also very glad to be able to change the default package where the automatically generated JSF managed beans get created, it was awful having all of these classes in a package named "WebApplication5" or something along those lines before.

There are a couple of issues that still persist.

The "label" attribute of IceFaces components is still ignored. The weird thing is, it works fine when using Facelets (without visual editing, of course) why doesn't it work with JSPs with Visual Web is anyone's guess. When JSF 1.2 came out, I was so glad that we had an easy way to display user friendly error messages, it has been frustrating not to be able to easily use this feature, first with Woodstock and now with IceFaces

Another issue that is still present is that ctrl+shift dragging from a label or message component into an input component does not yet set the "for" attribute like it was possible with Woodstock. The mouse pointer changes into a crosshair when doing this, also the target component is highlighted when hovering over it, therefore I believe this issue is a bug and not an omission of the feature.

It looks like the folks at IceFaces are making some progress getting this plugin up to speed. Hopefully in the near future the remaining issues will be addressed.

NetBeans IceFaces Plugin First Impressions

2008-12-18T23:56:47-05:00

Recently Sun announced that there will be no further development for Project Woodstock. Some maintenance will be done in the project, but no new features are planned.

This announcement affects NetBeans Visual Web projects, since they use Project Woodstock JSF components behind the scenes.

Sun is now recommending that current Woodstock applications be migrated to IceFaces. An IceFaces plugin has been available for a while to develop JSF applications visually using the IceFaces components, the plugin works in a way that is very similar to the standard Visual Web JSF NetBeans plugin.

Since Woodstock will no longer be developed, I figured now is a good time to take the NetBeans IceFaces plugin for a spin, to see how well it works, turns out, it doesn't work very well, at least the current version available from the NetBeans Plugin Manager.

The first issue I ran into is that the Java package for managed beans defaults to the project name and cannot be changed. The project name never adheres to standard Java package naming conventions (i.e. com.mycompany.packagename), therefore we end up with classes in nonstandard packages.

Under Windows, I wasn't able to drag components from the palette into the navigator page, this it is possible using NetBeans standard Visual Web JSF functionality (oddly enough, I was able to do this under Ubuntu Linux). I prefer dropping the components in the navigator page instead of directly in the JSP design view, since dropping the components in the design view results in CSS absolute positioning. I'd rather use the JSF standard way of placing components, which is using a panel grid for layout right inside a JSF form component. This issue can be worked around, by placing a grid in the design view then manually removing its "style" attribute, but it feels cleaner to just drop components in the navigator page.

Also, applications developed using IceFaces cannot be run under GlassFish 3. Maybe there is some faces-config.xml or web.xml incantation that needs to be done in order to make this work, I didn't try and didn't research it, all I did was develop a simple test application and try to deploy it.

Here is a partial stack trace from the GlassFish 3 log when attempting to deploy an IceFaces application developed using the NetBeans Plugin:

SEVERE: Can't find TLD for location [http://java.sun.com/jsf/core]. JAR containing the TLD may not be in the classpath
SEVERE: Can't find TLD for location [http://java.sun.com/jsf/html]. JAR containing the TLD may not be in the classpath
SEVERE: Failed to execute JSP lifecycle.
java.lang.IllegalStateException: ICEfaces parser unable to determine JSF implementation ViewTag class.
        at com.icesoft.faces.webapp.parser.Parser.parse(Parser.java:152)
        at com.icesoft.faces.application.D2DViewHandler.renderResponse(D2DViewHandler.java:528)
        at com.icesoft.faces.application.D2DViewHandler.renderView(D2DViewHandler.java:159)

Additionally, when working with standard Visual Web JSF, the "for" attribute of labels and message components can be set by ctrl+shift dragging from the label or message component to the target component. This functionality is not available in the IceFaces visual plugin.

One thing I was looking forward to was finding out if IceFaces wouldn't suffer from my Woodstock pet peeve. In JSF 1.2, the "label" attribute was added to all standard JSF input components. This attribute results in user friendly error messages. The JSF message and messages components by default use the component id to identify a validation error in a component, which is meaningless to the user. The label attribute allows the error message to use a user friendly label, as opposed to the component ID.

Woodstock components have a label attribute that, in addition to enabling user friendly error messages as described in the previous paragraph, actually adds a label to the component. Kind of neat, but it also makes it very difficult to right align all the components and left align all the labels like it is usually done in web applications. Therefore, when using Woodstock, there was always this catch-22 between user friendly error messages and ease of component alignment.

One of the first things I tried when testing the IceFaces NetBeans plugin was to set the "label" attribute on an input text component, and set the component's "required" attribute to "true". I ran the application, submitted the page (purposefully leaving the required input field blank) braced myself and bam! The component id is still shown in the error message, as opposed to my user friendly label, bummer!

I googled a bit and read some people had success with the label attribute using Facelets. I installed the NetBeans Facelets plugin and redid my simple application using Facelets. This time the label attribute "kicked in" and worked as expected.

Although I am not afraid to code things by hand, especially with excellent code/tag completion support like the one found in NetBeans, Visual web provides a nice way to preview a page while working with it, this functionality is lost when using Facelets with NetBeans.

I guess the plugin is "almost there", but the fact that the "label" attribute is ignored is a big bummer. Also, I miss the ability to drop components from the palette into the navigator window, bypassing CSS absolute positioning.

Other functionality we are used to from Visual Web JSF is still there. A request scoped managed bean is created for each IceFaces visual page we create (one caveat, the default package for these managed beans can't be changed, it defaults to the project name, which does not adhere to standard java package naming conventions). Also, double clicking on a command button automatically creates a method on the managed bean to handle its action event.

Although I don't have a lot of experience with this plugin, my impression is that it is better than coding JSF applications by hand, but I really miss some of the missing features from the standard Visual Web JSF functionality.

I would also like to clarify that this entry is not meant to knock IceFaces. I've seen the IceFaces demo apps and I can see that it eases creation of very sophisticated and elegant web applications, I just found some issues with the IceFaces NetBeans plugin that I hope will be addressed in the near future.

Update: a new version of the plugin came out, I tested the new version and wrote my thoughts here.

NetBeans Podcast Interview Just Finished

2008-12-12T12:10:30-05:00

My NetBeans Podcast Interview just finished a few minutes ago.

We talked about NetBeans, Java EE and my book.

There were some interesting questions regarding NetBeans and Java EE, in addition to questions about how I got involved with my publisher, Packt Publishing, and how I got the idea of writing a book about NetBeans.

The podcast is scheduled to come out sometime this month.

NetBeans Podcast Interview

2008-12-06T01:59:09-05:00

I was just invited to be interviewed in the next NetBeans Podcast. Geertjan Wielenga and Lloyd Dunn will be asking me questions about my new book, Java EE 5 Development with NetBeans 6

I'm very excited about the opportunity to be a part of an episode of the NetBeans podcast, I've been listening to it for the past several month to keep up to date on what is going on in the NetBeans world.

NetBeans 6.5 Final Now Available

2008-11-19T15:06:28-05:00

It has come to my attention that NetBeans 6.5 final is now available.

It can be downloaded from the NetBeans web site.

If you would like to learn the ins and outs of enterprise Java development, my book, Java EE 5 Development with NetBeans 6, may help.

JavaRanch Book Promotion Over

2008-11-09T00:13:13-05:00

The JavaRanch book promotion we had this week for my new book, Java EE 5 Development With NetBeans 6 is now over.

There were many good questions over the week about the book and NetBeans in general.

I would like to personally congratulate all the "Java Ranchers" that won a free copy of the book:

renu richard
Peter Johnson
Rogerio Kioshi
Ankit Garg

Congratulations to all!

Java EE Development With NetBeans 6 has been published

2008-10-31T11:43:09-04:00

I'm pleased to announce that my latest book, Java EE Development With NetBeans 6 has been published.

The book covers several aspects of Java EE development using NetBeans, such as:

Visual Web JSF Development
JPA development, including automatic JPA generation from existing database schemas.
Automated JSF CRUD application generation from existing JPA entities
EJB 3 development, including session and message driven beans.
Debugging Java EE applications with the NetBeans debugger
Profiling Java EE applications with the NetBeans profiler
Additional Java EE Development Topics

I have been working on the book for the past several months, I am glad to finally see the fruits of my labor.

NetBeans Book Promotion Next Week On JavaRanch

2008-10-28T01:10:46-04:00

Next week I'll be discussing my new book, Java EE 5 Development With NetBeans 6 in the IDEs, Version Control and other tools of the JavaRanch Big Moose Saloon.

I will be answering questions about the book, Java EE 5 and NetBeans.

See you there!

NetBeans Book Title Changed

2008-10-23T23:12:12-04:00

After some discussion with the publisher, we decided to change the title of my NetBeans book scheduled to be released very soon.

The new title is "Java EE 5 Development With NetBeans 6", the main reason for the change is that we wanted to have version numbers in the title, so that the title gives a better idea of exactly what is covered.

I would like to clarify that the book targets NetBeans 6.5, however, most of the material is applicable to NetBeans 6.0 and 6.1, therefore we decided to just state "NetBeans 6" in the title, since the material applies to any NetBeans 6.X version.

NetBeans 6.5 RC1 Released

2008-10-22T16:45:03-04:00

NetBeans 6.5 RC1 available, it can be found at http://download.netbeans.org/netbeans/6.5/rc/.

My soon to be published book, Java EE Development With NetBeans, covers NetBeans 6.5.

Netbeans 6.5 RC1 to be released soon

2008-10-17T22:43:57-04:00

The NetBeans Core QA Team has announced that NetBeans 6.5 RC1 will be released soon . It is expected to be available this afternoon.

I would like this opportunity to mention that my new NetBeans Book covers NetBeans 6.5.

NetBeans IDE Turning 10 Years Old

2008-10-15T23:35:23-04:00

The NetBeans IDE will turn 10 years old this month.

To celebrate, the NetBeans team is planning several activities. Check it out at http://www.netbeans.org/birthday/.

Automated DAO Generation from JPA Entities with NetBeans

2008-10-13T23:53:27-04:00

One very nice NetBeans feature is the ability to generate Java Persistence API (JPA) entitites from an existing database schema. NetBeans can also generate complete JSF CRUD applications from JPA entities in a project. Both of these features are covered in detail in my Java EE 5 Development With NetBeans book.

As of NetBeans 6.5, scheduled to be released next month, will also add the ability to automatically generate DAO's (NetBeans calls them controllers, but they are, in fact, Data Access Objects) from existing JPA Entities.

This will certainly save us developers a lot of work, here is a sample DAO from generated from the Customer JPA entity discussed in the book:



package com.ensode.customerdb.jpacontrollers;

import com.ensode.customerdb.jpa.Customer;
import com.ensode.customerdb.jpacontrollers.exceptions.NonexistentEntityException;
import com.ensode.customerdb.jpacontrollers.exceptions.PreexistingEntityException;
import com.ensode.customerdb.jpacontrollers.exceptions.RollbackFailureException;
import java.util.List;
import javax.annotation.Resource;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.PersistenceUnit;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import com.ensode.customerdb.jpa.CustomerOrder;
import java.util.ArrayList;
import java.util.Collection;
import com.ensode.customerdb.jpa.Address;
import com.ensode.customerdb.jpa.Telephone;
import javax.transaction.UserTransaction;

/**
*
* @author heffel
*/
public class CustomerJpaController {
@Resource
private UserTransaction utx = null;
@PersistenceUnit(unitName = "WebApplication1PU")
private EntityManagerFactory emf = null;

public EntityManager getEntityManager() {
return emf.createEntityManager();
}

public void create(Customer customer) throws PreexistingEntityException, RollbackFailureException, Exception {
if (customer.getCustomerOrderCollection() == null) {
customer.setCustomerOrderCollection(new ArrayList());
}
if (customer.getAddressCollection() == null) {
customer.setAddressCollection(new ArrayList());
}
if (customer.getTelephoneCollection() == null) {
customer.setTelephoneCollection(new ArrayList());
}
EntityManager em = null;
try {
utx.begin();
em = getEntityManager();
Collection attachedCustomerOrderCollection = new ArrayList();
for (CustomerOrder customerOrderCollectionCustomerOrderToAttach : customer.getCustomerOrderCollection()) {
customerOrderCollectionCustomerOrderToAttach = em.getReference(customerOrderCollectionCustomerOrderToAttach.getClass(), customerOrderCollectionCustomerOrderToAttach.getCustomerOrderId());
attachedCustomerOrderCollection.add(customerOrderCollectionCustomerOrderToAttach);
}
customer.setCustomerOrderCollection(attachedCustomerOrderCollection);
Collection attachedAddressCollection = new ArrayList();
for (Address addressCollectionAddressToAttach : customer.getAddressCollection()) {
addressCollectionAddressToAttach = em.getReference(addressCollectionAddressToAttach.getClass(), addressCollectionAddressToAttach.getAddressId());
attachedAddressCollection.add(addressCollectionAddressToAttach);
}
customer.setAddressCollection(attachedAddressCollection);
Collection attachedTelephoneCollection = new ArrayList();
for (Telephone telephoneCollectionTelephoneToAttach : customer.getTelephoneCollection()) {
telephoneCollectionTelephoneToAttach = em.getReference(telephoneCollectionTelephoneToAttach.getClass(), telephoneCollectionTelephoneToAttach.getTelephoneId());
attachedTelephoneCollection.add(telephoneCollectionTelephoneToAttach);
}
customer.setTelephoneCollection(attachedTelephoneCollection);
em.persist(customer);
for (CustomerOrder customerOrderCollectionCustomerOrder : customer.getCustomerOrderCollection()) {
Customer oldCustomerIdOfCustomerOrderCollectionCustomerOrder = customerOrderCollectionCustomerOrder.getCustomerId();
customerOrderCollectionCustomerOrder.setCustomerId(customer);
customerOrderCollectionCustomerOrder = em.merge(customerOrderCollectionCustomerOrder);
if (oldCustomerIdOfCustomerOrderCollectionCustomerOrder != null) {
oldCustomerIdOfCustomerOrderCollectionCustomerOrder.getCustomerOrderCollection().remove(customerOrderCollectionCustomerOrder);
oldCustomerIdOfCustomerOrderCollectionCustomerOrder = em.merge(oldCustomerIdOfCustomerOrderCollectionCustomerOrder);
}
}
for (Address addressCollectionAddress : customer.getAddressCollection()) {
Customer oldCustomerIdOfAddressCollectionAddress = addressCollectionAddress.getCustomerId();
addressCollectionAddress.setCustomerId(customer);
addressCollectionAddress = em.merge(addressCollectionAddress);
if (oldCustomerIdOfAddressCollectionAddress != null) {
oldCustomerIdOfAddressCollectionAddress.getAddressCollection().remove(addressCollectionAddress);
oldCustomerIdOfAddressCollectionAddress = em.merge(oldCustomerIdOfAddressCollectionAddress);
}
}
for (Telephone telephoneCollectionTelephone : customer.getTelephoneCollection()) {
Customer oldCustomerIdOfTelephoneCollectionTelephone = telephoneCollectionTelephone.getCustomerId();
telephoneCollectionTelephone.setCustomerId(customer);
telephoneCollectionTelephone = em.merge(telephoneCollectionTelephone);
if (oldCustomerIdOfTelephoneCollectionTelephone != null) {
oldCustomerIdOfTelephoneCollectionTelephone.getTelephoneCollection().remove(telephoneCollectionTelephone);
oldCustomerIdOfTelephoneCollectionTelephone = em.merge(oldCustomerIdOfTelephoneCollectionTelephone);
}
}
utx.commit();
} catch (Exception ex) {
try {
utx.rollback();
} catch (Exception re) {
throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
}
if (findCustomer(customer.getCustomerId()) != null) {
throw new PreexistingEntityException("Customer " + customer + " already exists.", ex);
}
throw ex;
} finally {
if (em != null) {
em.close();
}
}
}

public void edit(Customer customer) throws NonexistentEntityException, RollbackFailureException, Exception {
EntityManager em = null;
try {
utx.begin();
em = getEntityManager();
Customer persistentCustomer = em.find(Customer.class, customer.getCustomerId());
Collection customerOrderCollectionOld = persistentCustomer.getCustomerOrderCollection();
Collection customerOrderCollectionNew = customer.getCustomerOrderCollection();
Collection addressCollectionOld = persistentCustomer.getAddressCollection();
Collection addressCollectionNew = customer.getAddressCollection();
Collection telephoneCollectionOld = persistentCustomer.getTelephoneCollection();
Collection telephoneCollectionNew = customer.getTelephoneCollection();
Collection attachedCustomerOrderCollectionNew = new ArrayList();
for (CustomerOrder customerOrderCollectionNewCustomerOrderToAttach : customerOrderCollectionNew) {
customerOrderCollectionNewCustomerOrderToAttach = em.getReference(customerOrderCollectionNewCustomerOrderToAttach.getClass(), customerOrderCollectionNewCustomerOrderToAttach.getCustomerOrderId());
attachedCustomerOrderCollectionNew.add(customerOrderCollectionNewCustomerOrderToAttach);
}
customerOrderCollectionNew = attachedCustomerOrderCollectionNew;
customer.setCustomerOrderCollection(customerOrderCollectionNew);
Collection attachedAddressCollectionNew = new ArrayList();
for (Address addressCollectionNewAddressToAttach : addressCollectionNew) {
addressCollectionNewAddressToAttach = em.getReference(addressCollectionNewAddressToAttach.getClass(), addressCollectionNewAddressToAttach.getAddressId());
attachedAddressCollectionNew.add(addressCollectionNewAddressToAttach);
}
addressCollectionNew = attachedAddressCollectionNew;
customer.setAddressCollection(addressCollectionNew);
Collection attachedTelephoneCollectionNew = new ArrayList();
for (Telephone telephoneCollectionNewTelephoneToAttach : telephoneCollectionNew) {
telephoneCollectionNewTelephoneToAttach = em.getReference(telephoneCollectionNewTelephoneToAttach.getClass(), telephoneCollectionNewTelephoneToAttach.getTelephoneId());
attachedTelephoneCollectionNew.add(telephoneCollectionNewTelephoneToAttach);
}
telephoneCollectionNew = attachedTelephoneCollectionNew;
customer.setTelephoneCollection(telephoneCollectionNew);
customer = em.merge(customer);
for (CustomerOrder customerOrderCollectionOldCustomerOrder : customerOrderCollectionOld) {
if (!customerOrderCollectionNew.contains(customerOrderCollectionOldCustomerOrder)) {
customerOrderCollectionOldCustomerOrder.setCustomerId(null);
customerOrderCollectionOldCustomerOrder = em.merge(customerOrderCollectionOldCustomerOrder);
}
}
for (CustomerOrder customerOrderCollectionNewCustomerOrder : customerOrderCollectionNew) {
if (!customerOrderCollectionOld.contains(customerOrderCollectionNewCustomerOrder)) {
Customer oldCustomerIdOfCustomerOrderCollectionNewCustomerOrder = customerOrderCollectionNewCustomerOrder.getCustomerId();
customerOrderCollectionNewCustomerOrder.setCustomerId(customer);
customerOrderCollectionNewCustomerOrder = em.merge(customerOrderCollectionNewCustomerOrder);
if (oldCustomerIdOfCustomerOrderCollectionNewCustomerOrder != null && !oldCustomerIdOfCustomerOrderCollectionNewCustomerOrder.equals(customer)) {
oldCustomerIdOfCustomerOrderCollectionNewCustomerOrder.getCustomerOrderCollection().remove(customerOrderCollectionNewCustomerOrder);
oldCustomerIdOfCustomerOrderCollectionNewCustomerOrder = em.merge(oldCustomerIdOfCustomerOrderCollectionNewCustomerOrder);
}
}
}
for (Address addressCollectionOldAddress : addressCollectionOld) {
if (!addressCollectionNew.contains(addressCollectionOldAddress)) {
addressCollectionOldAddress.setCustomerId(null);
addressCollectionOldAddress = em.merge(addressCollectionOldAddress);
}
}
for (Address addressCollectionNewAddress : addressCollectionNew) {
if (!addressCollectionOld.contains(addressCollectionNewAddress)) {
Customer oldCustomerIdOfAddressCollectionNewAddress = addressCollectionNewAddress.getCustomerId();
addressCollectionNewAddress.setCustomerId(customer);
addressCollectionNewAddress = em.merge(addressCollectionNewAddress);
if (oldCustomerIdOfAddressCollectionNewAddress != null && !oldCustomerIdOfAddressCollectionNewAddress.equals(customer)) {
oldCustomerIdOfAddressCollectionNewAddress.getAddressCollection().remove(addressCollectionNewAddress);
oldCustomerIdOfAddressCollectionNewAddress = em.merge(oldCustomerIdOfAddressCollectionNewAddress);
}
}
}
for (Telephone telephoneCollectionOldTelephone : telephoneCollectionOld) {
if (!telephoneCollectionNew.contains(telephoneCollectionOldTelephone)) {
telephoneCollectionOldTelephone.setCustomerId(null);
telephoneCollectionOldTelephone = em.merge(telephoneCollectionOldTelephone);
}
}
for (Telephone telephoneCollectionNewTelephone : telephoneCollectionNew) {
if (!telephoneCollectionOld.contains(telephoneCollectionNewTelephone)) {
Customer oldCustomerIdOfTelephoneCollectionNewTelephone = telephoneCollectionNewTelephone.getCustomerId();
telephoneCollectionNewTelephone.setCustomerId(customer);
telephoneCollectionNewTelephone = em.merge(telephoneCollectionNewTelephone);
if (oldCustomerIdOfTelephoneCollectionNewTelephone != null && !oldCustomerIdOfTelephoneCollectionNewTelephone.equals(customer)) {
oldCustomerIdOfTelephoneCollectionNewTelephone.getTelephoneCollection().remove(telephoneCollectionNewTelephone);
oldCustomerIdOfTelephoneCollectionNewTelephone = em.merge(oldCustomerIdOfTelephoneCollectionNewTelephone);
}
}
}
utx.commit();
} catch (Exception ex) {
try {
utx.rollback();
} catch (Exception re) {
throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
}
String msg = ex.getLocalizedMessage();
if (msg == null || msg.length() == 0) {
Integer id = customer.getCustomerId();
if (findCustomer(id) == null) {
throw new NonexistentEntityException("The customer with id " + id + " no longer exists.");
}
}
throw ex;
} finally {
if (em != null) {
em.close();
}
}
}

public void destroy(Integer id) throws NonexistentEntityException, RollbackFailureException, Exception {
EntityManager em = null;
try {
utx.begin();
em = getEntityManager();
Customer customer;
try {
customer = em.getReference(Customer.class, id);
customer.getCustomerId();
} catch (EntityNotFoundException enfe) {
throw new NonexistentEntityException("The customer with id " + id + " no longer exists.", enfe);
}
Collection customerOrderCollection = customer.getCustomerOrderCollection();
for (CustomerOrder customerOrderCollectionCustomerOrder : customerOrderCollection) {
customerOrderCollectionCustomerOrder.setCustomerId(null);
customerOrderCollectionCustomerOrder = em.merge(customerOrderCollectionCustomerOrder);
}
Collection addressCollection = customer.getAddressCollection();
for (Address addressCollectionAddress : addressCollection) {
addressCollectionAddress.setCustomerId(null);
addressCollectionAddress = em.merge(addressCollectionAddress);
}
Collection telephoneCollection = customer.getTelephoneCollection();
for (Telephone telephoneCollectionTelephone : telephoneCollection) {
telephoneCollectionTelephone.setCustomerId(null);
telephoneCollectionTelephone = em.merge(telephoneCollectionTelephone);
}
em.remove(customer);
utx.commit();
} catch (Exception ex) {
try {
utx.rollback();
} catch (Exception re) {
throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
}
throw ex;
} finally {
if (em != null) {
em.close();
}
}
}

public List findCustomerEntities() {
return findCustomerEntities(true, -1, -1);
}

public List findCustomerEntities(int maxResults, int firstResult) {
return findCustomerEntities(false, maxResults, firstResult);
}

private List findCustomerEntities(boolean all, int maxResults, int firstResult) {
EntityManager em = getEntityManager();
try {
Query q = em.createQuery("select object(o) from Customer as o");
if (!all) {
q.setMaxResults(maxResults);
q.setFirstResult(firstResult);
}
return q.getResultList();
} finally {
em.close();
}
}

public Customer findCustomer(Integer id) {
EntityManager em = getEntityManager();
try {
return em.find(Customer.class, id);
} finally {
em.close();
}
}

public int getCustomerCount() {
EntityManager em = getEntityManager();
try {
return ((Long) em.createQuery("select count(o) from Customer as o").getSingleResult()).intValue();
} finally {
em.close();
}
}

}

Isn't it great to get all this code generated? No need to develop and debug it ourselves, letting us focus on implementing business logic.

NetBeans Book Almost Ready

2008-10-10T22:14:14-04:00

We are working on the final touches of my new Netbeans book. If everything goes well, it should be published later this month.

Today I received "prefinal" versions of the first few chapters. Prefinal versions are what the publisher will sent to the printers once the book is completed. They are sent to the author for a final inspection and "sanity check" before having the book printed.

I'm very excited about this book. NetBeans is such a nice IDE and I hope my book can help others learn how to use it to its full potential.

New NetBeans Book Available for Pre-Order

2008-10-06T20:30:17-04:00

I am pleased to announce that my new book, Java EE Development With NetBeans, is now available for pre-order.