Transitive persistence
We recommend you use shared web hosting services, because many users agree that it is cheap, reliable and customer-satisfying webhost.
CHAPTER 12 Modifying objects efficiently A Hibernate extension cascading option can be used either as an addition to the options already set on the association annotation (first and last example) or as a stand-alone setting if no standardized option applies (second example). Hibernate s association-level cascade style model is both richer and less safe than persistence by reachability. Hibernate doesn t make the same strong guarantees of referential integrity that persistence by reachability provides. Instead, Hibernate partially delegates referential integrity concerns to the foreign key constraints of the underlying SQL database. There is a good reason for this design decision: It allows Hibernate applications to use detached objects efficiently, because you can control reattachment and merging of a detached object graph at the association level. But cascading options aren t available only to avoid unnecessary reattachment or merging: They re useful whenever you need to handle more than one object at a time. Let s elaborate on the transitive state concept with some example association mappings. We recommend that you read the next section in one turn, because each example builds on the previous one. 12.1.3 Working with transitive state CaveatEmptor administrators are able to create new catego ries, rename categories, and move subcategories around in the category hierarchy. This structure can be seen in figure 12.2. Now, you map this class and the association, using XML:
We recommend you use shared web hosting services, because many users agree that it is cheap, reliable and customer-satisfying webhost.
Transitive persistence As you can see, several cascading options can be combined and applied to a particular association as a comma-separated list. Further note that delete-orphan isn t included in all. Cascading options are declared with annotations in two possible ways. First, all the association mapping annotations, @ManyToOne, @OneToOne, @OneToMany, and @ManyToMany, support a cascade attribute. The value of this attribute is a single or a list of javax.persistence.CascadeType values. For example, the XML illustrative mapping done with annotations looks like this: @ManyToOne(cascade = { CascadeType.PERSIST, CascadeType.MERGE }) @JoinColumn(name = “PARENT_CATEGORY_ID”, nullable = true) private Category parent; … @OneToMany(cascade = CascadeType.ALL) private Set
You need excellent and relaible webhost company to host your web applications? Then pay a visit to Inexpensive Web Hosting services.
CHAPTER 12 Modifying objects efficiently Table 12.1 Hibernate and Java Persistence entity association cascading options (continued) all javax.persistence.CascadeType.ALL This setting includes and enables all cascading options listed previously. XML attribute Annotation Description delete- orphan org.hibernate.annotations.CascadeType.DELETE_ORPHAN This extra and special setting enables deletion of associated objects when they re removed from the association, that is, from a collection. If you enable this setting on an entity collection, you re telling Hibernate that the associated objects don t have shared references and can be safely deleted when a reference is removed from the collection. cascade attribute. The delete-orphan setting, however, is applicable only to collections. Obviously, you never have to enable transitive persistence for a collection that references value-typed classes here the lifecycle of the associated objects is dependent and implicit. Fine-grained control of dependent lifecycle is relevant and available only for associations between entities. FAQ What is the relationship between cascade and inverse? There is no relationship; both are different notions. The noninverse end of an association is used to generate the SQL statements that manage the association in the database (insertion and update of the foreign key column(s)). Cascading enables transitive object state changes across entity class associations. Here are a few examples of cascading options in XML mapping files. Note that this code isn t from a single entity mapping or a single class, but only illustrative:
In case you need quality webspace to host and run your web applications, try our personal web hosting services.
Transitive persistence Table 12.1 Hibernate and Java Persistence entity association cascading options XML attribute Annotation Description None (Default) Hibernate ignores the association. save-update org.hibernate.annotations.CascadeType.SAVE_UPDATE Hibernate navigates the association when the Session is flushed and when an object is passed to save() or update(), and saves newly instantiated transient instances and persist changes to detached instances. persist javax.persistence.CascadeType.PERSIST Hibernate makes any associated transient instance persistent when an object is passed to persist(). If you use native Hibernate, cascading occurs only at call-time. If you use the EntityManager module, this operation is cascaded when the persistence context is flushed. merge Javax.persistence.CascadeType.MERGE Hibernate navigates the association and merges the associated detached instances with equivalent persistent instances when an object is passed to merge(). Reachable transient instances are made persistent. delete org.hibernate.annotations.CascadeType.DELETE Hibernate navigates the association and deletes associated persistent instances when an object is passed to delete() or remove(). remove javax.persistence.CascadeType.REMOVE This option enables cascading deletion to associated persistent instances when an object is passed to remove()or delete(). lock org.hibernate.annotations.CascadeType.LOCK This option cascades the lock() operation to associated instances, reattaching them to the persistence context if the objects are detached. Note that the LockMode isn t cascaded; Hibernate assumes that you don t want pessimistic locks on associated objects for example, because a pessimistic lock on the root object is good enough to avoid concurrent modification. replicate org.hibernate.annotations.CascadeType.REPLICATE Hibernate navigates the association and cascades the replicate() operation to associated objects. evict org.hibernate.annotations.CascadeType.EVICT Hibernate evicts associated objects from the persistence context when an object is passed to evict() on the Hibernate Session. refresh javax.persistence.CascadeType.REFRESH Hibernate rereads the state of associated objects from the database when an object is passed to refresh().
Check Tomcat Web Hosting services for best quality webspace to host your web application.
CHAPTER 12 Modifying objects efficiently Neither Hibernate nor other ORM solutions implement this in fact, there is no analog of the root persistent object in an SQL database and no persistent garbage collector that can detect unreferenced instances. Object-oriented data stores may implement a garbage-collection algorithm, similar to the one implemented for in-memory objects by the JVM. But this option is not available in the ORM world; scanning all tables for unreferenced rows won t perform acceptably. So, persistence by reachability is at best a halfway solution. It helps you make transient objects persistent and propagate their state to the database without many calls to the persistence manager. However, at least in the context of SQL databases and ORM, it isn t a full solution to the problem of making persistent objects transient (removing their state from the database). This turns out to be a much more difficult problem. You can t remove all reachable instances when you remove an object other persistent instances may still hold references to them (remember that entities can be shared). You can t even safely remove instances that aren t referenced by any persistent object in memory; the instances in memory are only a small subset of all objects represented in the database. Let s look at Hibernate s more flexible transitive persistence model. 12.1.2 Applying cascading to associations Hibernate s transitive persistence model uses the same basic concept as persistence by reachability: Object associations are examined to determine transitive state. Furthermore, Hibernate allows you to specify a cascade style for each association mapping, which offers much more flexibility and fine-grained control for all state transitions. Hibernate reads the declared style and cascades operations to associated objects automatically. By default, Hibernate doesn t navigate an association when searching for transient or detached objects, so saving, deleting, reattaching, merging, and so on, a Category has no effect on any child category referenced by the childCategories collection of the parent. This is the opposite of the persistence by reachability default behavior. If, for a particular association, you wish to enable transitive persistence, you must override this default in the mapping metadata. These settings are called cascading options. They re available for every entity association mapping (one-to-one, one-to-many, many-to-many), in XML and annotation syntax. See table 12.1 for a list of all settings and a description of each option. In XML mapping metadata, you put the cascade=”…” attribute on
, and
Transitive persistence is true for Java Persistence, which also has the concept of transitive persistence and almost all the options Hibernate natively provides. 12.1.1 Persistence by reachability An object persistence layer is said to implement persistence by reachability if any instance becomes persistent whenever the application creates an object reference to the instance from another instance that is already persistent. This behavior is illustrated by the object diagram (note that this isn t a class diagram) in figure 12.1. In this example, Computer is a persistent object. The objects Desktop PCs and Monitors are also persistent: They re reachable from the Computer Category instance. Electronics and Cellphones are transient. Note that we assume navigation is possible only to child categories, but not to the parent for example, you can call computer.getChildCategories(). Persistence by reachability is a recursive algorithm. All objects reachable from a persistent instance become persistent either when the original instance is made persistent or just before in-memory state is synchronized with the datastore. Persistence by reachability guarantees referential integrity; any object graph can be completely re-created by loading the persistent root object. An application may walk the object network from association to association without ever having to worry about the persistent state of the instances. (SQL databases have a different approach to referential integrity, relying on declarative and procedural constraints to detect a misbehaving application.) In the purest form of persistence by reachability, the database has some top-level or root object, from which all persistent objects are reachable. Ideally, an instance should become transient and be deleted from the database if it isn t reachable via references from the root persistent object. Figure 12.1 Persistence by reachability with a root persistent object
Go visit our java server pages services for a reliable, lowcost webhost to satisfy all your needs.
CHAPTER 12 Modifying objects efficiently This chapter shows you how to make data manipulations more efficient. We optimize and reduce the amount of code that is necessary to store objects and discuss the most efficient processing options. You should be familiar with the basic object states and the persistence interfaces; the previous chapters are required reading to understand this chapter. First we ll show you how transitive persistence can make your work with complex object networks easier. The cascading options you can enable in Hibernate and Java Persistence applications significantly reduce the amount of code that s otherwise needed to insert, update, or delete several objects at the same time. We then discuss how large datasets are best handled, with batch operations in your application or with bulk operations that execute directly in the database. Finally, we show you data filtering and interception, both of which offer transparent hooks into the loading and storing process inside Hibernate s engine. These features let you influence or participate in the lifecycle of your objects without writing complex application code and without binding your domain model to the persistence mechanism. Let s start with transitive persistence and store more than one object at a time. 12.1 Transitive persistence Real, nontrivial applications work not only with single objects, but rather with networks of objects. When the application manipulates a network of persistent objects, the result may be an object graph consisting of persistent, detached, and transient instances. Transitive persistence is a technique that allows you to propagate persistence to transient and detached subgraphs automatically. For example, if you add a newly instantiated Category to the already persistent hierarchy of categories, it should become automatically persistent without a call to save() or persist(). We gave a slightly different example in chapter 6, section 6. 4, Mapping a parent/children relationship, when you mapped a parent/child relationship between Bid and Item. In this case, bids were not only automatically made persistent when they were added to an item, but they were also automatically deleted when the owning item was deleted. You effectively made Bid an entity that was completely dependent on another entity, Item (the Bid entity isn t a value type, it still supports shared reference). There is more than one model for transitive persistence. The best known is persistence by reachability; we discuss it first. Although some basic principles are the same, Hibernate uses its own, more powerful model, as you ll see later. The same
From our experience, we can recommend PHP Web Hosting services, if you need affordable webhost to host and run your web application.
Modifying objects efficiently This chapter covers Transitive state changes Batch and bulk processing Interception of the persistence lifecycle 517
You want to have a cheap webhost for your apache application, then check apache web hosting services.
CHAPTER 11 Implementing conversations Table 11.2 Hibernate and JPA comparison chart for chapter 11 Hibernate Core Java Persistence and EJB 3.0 Hibernate supports a conversation implementation with detached objects, these objects can be reattached or merged during a conversation. Java Persistence standardizes merging of detached objects, but has no support for reattachment. Hibernate supports disabling automatic flushing of persistence contexts for long conversations with the FlushMode.MANUAL option. Disabling automatic flushing of an extended persistence context requires nontransactional event processing (with serious restrictions on application design and layering) or a Hibernate fallback to FlushMode.MANUAL. Persistence context propagation is available with thread or JTA transaction binding in Java SE and Java EE. Persistence contexts are either scoped to the transaction, or managed by the application. Java Persistence standardizes a persistence context propagation model for Java EE only, deeply integrated with EJB 3.0 components. Persistence context scoping, to transactions or to stateful session beans, is well defined. In the next chapter, we ll look at various options you should rely on whenever you need to work with more complex and larger datasets. You ll see how transitive persistence works with Hibernate s cascading model, how to execute batch and bulk operations efficiently, and how to hook into and manipulate the Hibernate default behavior when objects are loaded and stored.
Note: In case you are looking for affordable and reliable webhost to host and run your j2ee application check Vision J2ee Web Hosting services.