Hibernate configuration points

1. Two configuration files:

A. hibernate. cfg. xml and B. hibernate. properties

A can contain the configuration of the ing file, while hard codes in B adds the ing file.

A. Configuration config = new Configuration (). config ();

B. Configuration config = new Configuration ();

Config. addClass (TUser. class );

2. You do not have to use the hibernate. cfg. xml or hibernate. properties file names. You do not have to put the configuration file under Classes,

 
 

  
  
File file=new File("c://sample//myhibernate.xml");  
  
  
Configuration config=new Configuration().config(file);  
 
 

3. session. Flush () forces the database to synchronize immediately. When a transaction is used, it does not need to be flush. The transaction commit will automatically call flush when the session is closed.

4. Hibernate always uses the object type as the Field Type

5. XDoclet specifically sets up hibernate doclet, that is, adding some java docTag to the java code, and then letting XDoclet analyze the java code to generate a ing file;

6. The HQL clause is case-insensitive, but the class name and attribute name must be case sensitive.

7. Relationship: Constrained: constraint, indicating whether a foreign key foreigh key exists in the primary key of the master table.

Property-ref: name of the property associated with the main control class in the association class. The default value is the primary key property name of the association class.

One-to-multiple deployment must be configured on one side, and one-to-multiple deployment must be configured on both sides.

8. lazy = false: the passive records are recorded by hibernate and stored in the Collection type attribute specified by the master.

9. Collection of java. util. Set or net. sof. hibernate. collecton. Bag Type

10. Important: inverse: used to identify the passive end of a bidirectional Association.

Inverse = false) is responsible for maintaining the association. Default Value: false

11. batch-size: the number of data records read at a time when the feature is loaded with latency.

12. When one-to-multiple master vertices are updated through the primary prosecution)

 
 

  
  
User. getAddresses (). add (addr); session. save (user); // cascade update through the master object
 
 

13. In the one-to-one relationship, setting the active side as inverse = false will help improve the performance. When one party sets the link, inverse = true, that is, the master control is handed over to multiple parties, so that multiple parties can take the initiative to obtain the foreign key from one party, and then one insert can be completed.

 
 

  
  
Addr. setUser (user); // sets the associated TUser object
  
  
User. getAddresses (). add (addr );
  
  
Session. save (user); // cascade update
 
 

14. Only the party with the primary prosecution is concerned with the access to the other party's attributes. The passive party does not care about the other party's attributes.

15. The configuration attributes of one-to-one and one-to-one nodes are different:

The one-to-multiple relationship has the following attributes: lazy and inverse:

Column: fields associated with the target table in the intermediate ing table

Class: class Name, associated with the target class

Outer-join: whether to use outer join

Note: access is the read method for setting the attribute value.

Column is the associated field.

16. many to many. Note that both parties must set inverse and lazy. cascade can only be set to insert-update.

In many-to-many relationships, because the association relationship is referenced by two tables, the two tables must be saved simultaneously when the relationship state is saved.

 
 

  
  
group1.getRoles().add(role1);  
  
  
 
  
  
role1.getGroups().add(group1);   
  
  
 
  
  
session.save(role1);  
  
  
 
  
  
session.save(group1);  
 
 

17. About vo and po

After hibernate capacity processing, vo becomes a po (the reference of this vo will be saved by the container and flush when the session is closed, so if the po is transferred to other places, it is dangerous. vo and po are converted to each other: BeanUtils. copyProperties (anotherUser, user );

18. For the save operation, if the object has been associated with the Session, that is, it is added to the Session object container), no specific operation is required. In the subsequent Session. flush process, Hibernate will traverse the objects in the object container, find the starting and changing objects, generate and execute the corresponding update statement.

19. if we adopt the delayed loading mechanism, but want to implement the non-delayed Loading Function in some cases, that is, after the Session is closed, you can still operate on the addresses attribute Hibernate of the user. the initialize method can implement this function by forcibly loading correlated objects: this is precisely why we must use JDK Collection interfaces such as Set and Map when writing POJO ), the reason for declaring the Collection attribute is not specific to JDK Collection implementation classes such as HashSet and HashMap.

20. transaction: the session is obtained from sessionFactory, and its automatic submission attribute is closed (AutoCommit = false). If the jdbc operation is performed, the session is not explicitly called. beginTransaction () does not execute transaction operations.

Jdbc transaction: A transaction based on the same session (that is, the same connection;

Jta transaction: Cross-session cross-connection) transaction.

There are three implementation methods for jta transactions:

A,

 
 

  
  
UserTransaction tx=new InitialContext().lookup("...");   
  
  
tx.commit();  
 
 

B. hibernate encapsulation method: (not recommended)

 
 

  
  
Transaction tx=session.beginTransaction();   
  
  
tx.commit();  
 
 

C. Use the transaction technology of sessionBean of ejb. You only need to declare the method that requires jta transaction in the release descriptor as require.

21. pessimistic lock, optimistic lock:

Optimistic locks are generally implemented by version. Note that the version node must appear after the id.

22. In Hibernate, you can use the Criteria. setFirstResult and Criteria. setFetchSize methods to set the paging range.

The Query interface also provides the same method. hibernate mainly implements this function in the dialect class.

23.

 
 

  
  
cache   
  
  
……   
  
  
net.sf.ehcache.hibernate.Provider　 
 
 

You also need to configure the ecache itself

Then, specify the cache policies for each ing object in the ing file.

....

**************************************** *************

Query. list () and Query. iterate (): For query. list () always obtains all records through an SQL statement, reads them, and fills them in pojo for return; but query. iterate () is to first obtain the IDs of all records that meet the query conditions through a Select SQL statement, and then perform cyclic operations on this id set, use a separate Select SQL statement to retrieve the records corresponding to each id, and then enter the records in POJO to return the results.

That is to say, the list operation requires an SQL statement. For iterate operations, n + 1 SQL statement is required. The list method does not read data from the Cache. But iterator does.

24. ThreadLocal: it maintains a private variable space for each thread. In fact, the implementation principle is to maintain a Map in JVM. The Map key is the current thread object, and the value is the object instance saved by the thread through the ThreadLocal. set Method. When the thread calls the ThreadLocal. get method, ThreadLocal retrieves the corresponding objects in the Map based on the reference of the current thread object.

In this way, ThreadLocal isolates variables of different threads by distinguishing the references of various thread objects.

25. Hibernate Official Development Manual standard example:

 
 

  
  
public class HibernateUtil {   
  
  
private static SessionFactory sessionFactory;   
  
  
static {   
  
  
try {  
  
  
// Create the SessionFactory sessionFactory =  
  
  
new Configuration().configure().buildSessionFactory();  
  
  
 } catch (HibernateException ex)  
  
  
{  
  
  
throw new RuntimeException( "Configuration problem: " + ex.getMessage(), ex );  
  
  
 }  
  
  
 }  
  
  
public static final ThreadLocal session = new ThreadLocal();  
  
  
public static Session currentSession() throws HibernateException {  
  
  
Session s = (Session) session.get();   
  
  
// Open a new Session, if this Thread has none yet if (s == null) {  
  
  
s = sessionFactory.openSession(); session.set(s);  
  
  
}  
  
  
return s;   
  
  
}   
  
  
public static void closeSession() throws HibernateException  
  
  
{  
  
  
Session s = (Session) session.get();  
  
  
session.set(null);  
  
  
if (s != null) s.close();  
  
  
}  
  
  
} 
 
 

26. Reuse session through filter:

 
 

  
  
public class PersistenceFilter implements Filter {  
  
  
protected static ThreadLocal hibernateHolder = new ThreadLocal();  
  
  
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)  
  
  
throws IOException, ServletException{  
  
  
hibernateHolder.set(getSession());  
  
  
try {  
  
  
……  
  
  
chain.doFilter(request, response);  
  
  
……  
  
  
}  
  
  
finally {  
  
  
Session sess = (Session)hibernateHolder.get();  
  
  
if (sess != null) {  
  
  
hibernateHolder.set(null);  
  
  
try {  
  
  
sess.close();  
  
  
}  
  
  
catch (HibernateException ex) {  
  
  
throw new ServletException(ex);  
  
  
}  
  
  
}  
  
  
}  
  
  
}  
  
  
……  
  
  
} 
 
 

27. The parameterized transaction management function of Spring is quite powerful. In Spring Framework-based application development, I suggest using containers to manage transactions as much as possible to obtain the optimal readability of Data logic code.

 
 

  
  
public class UserDAO extends HibernateDaoSupport implements IUserDAO {  
  
  
public void insertUser(User user){  
  
  
getHibernateTemplate().saveOrUpdate(user);  
  
  
}  
  
  
} 
 
 

The preceding UserDAO implements the custom IUserDAO interface and extends the abstract class:

HibernateDaoSupport HibernateSupport associates HibernateTemplate with SessionFactory instances.

HibernateTemplate encapsulates Hibernate Session operations, while the HibernateTemplate.exe cute method is the core of an encapsulation mechanism.

* In the spring configuration file, the entire content of hibernate. cfg. xml is transplanted.