Recommended structure of database-backed JSF app.

Question

I'm learning how to put together a web application using JSF 2.0, Spring and hibernate. I've done a lot of reading on various sites on the 'right' way to do it, and I think I've got the right idea, but I just want to check that I've understood it correctly. (Of course this is more about the structure rather than any specific implementation.)
Here's what seems to be the case:
Hibernate is configured via spring.
POJOs for any persistent entities are mapped to hibernate via annotations (or xml), containing only trivial getters & setters. These methods are never accesses directly by JSF (i.e. these are not managed beans)
Each of these entities has a DAO that does create, read, update, delete (or whatever). These take only object ids (or other identifiers) for reads or entity objects for the other ones, i.e. they don't access all the setters of the POJOs. (As such, can be made generic to reduce code duplication.)
Optionally, each DAO can have a service object that presents the various database operations to the next layer, possibly performing checks and grouping operations together.
Via spring, the service objects are accessible to the JSF beans (or pages).
Now, suppose a simple use case where a user is entering a new record to the database via a web form. The JSF managed bean will be a POJO mirroring all the fields of the relevant entity bean (but not actually be an instance of one). These fields will be bound to the input fields of the form, and if they pass validation, the action (a method of the JSF managed bean) will create a new instance of the entity bean, copy all of its own field into this using its setters, then persist the newly created object with the service object (made available by spring).
Displaying a previously persisted bean would be a similar process in reverse; the JSF managed bean would read an entity bean from the service object, load all its own fields using the getters from the loaded entity bean, then populate the page with these values.
(Obviously this is a very simple case, I imagine there would be cases where the two beans would differ a bit, or perhaps more than simple get/set methods would be used, but I'm just starting out here)
Is this about right? It seems odd to me that one would duplicate all the fields. It should be possible to make the beans do a dual duty, acting as both the entity bean and the JSF managed bean. Hibernate would simply ignore any action methods, and presumably such cases are what the @transient annotation is for.
You'd end up with a single class that has both hibernate and JSF annotations on it.
Is that right?

Answer 1

There is a design forum.
I think you have a few too many keywords in there. Hopefully someone with experience end to end might clear that up.
You'd end up with a single class that has both hibernate and JSF annotations on it.Even if possible I suspect that no one is going to recommend that.