Summary of some common methods of HibernateTemplate integrated by Spring and Hibernate

1: get/load access to a single piece of data

1. Public Teacher getTeacherById (Long id ){
2. Return (Teacher) this. hibernateTemplate. get (Teacher. class, id );
3. }
5. Public Teacher getTeacherById (Long id ){
6. Return (Teacher) this. hibernateTemplate. load (Teacher. class, id );
7. }

2: find/iterate query operation

1. Public Iterator getTeachersByAge (int age ){
2. IteratorIterator=Null;
4. // Use the find Method
5. ListList= (List) this. hibernateTemplate (). find ("from Teacher t where t. age>? ", New Integer (age ));
6. Iterator=List. Iterator ();
8. // Use the iterator Method
9. Iterator=This. HibernateTemplate (). iterate ("from Teacher t where t. age>? ", New Integer (age ));
11. Return iterator;
12. }

The difference between find and iterato is that iterate uses N + 1 queries. for a large number of queries, for example, to query 10000 records, iterate needs to execute 10000 + 1 query, find and iterate should be based on the actual

For frequently written objects, use the find query. For some read-only data objects, use the iterate operation because the iterate operation uses the Hibernate cache mechanism.

3: save/update/saveOrUpdate/delete: save/update/delete

 

1. Public void save (Teacher teacher ){
2. This. hibernateTemplate. save (teacher );
3. }

1. Public void update (Teacher teacher ){
2. This. hibernateTemplate. update (teacher );
3. }

1. Public void update (Teacher teacher ){
2. This. hibernateTemplate. saveOrUpdate (teacher );
3. }

1. Public void update (Teacher teacher ){
2. This. hibernateTemplate. delete (teacher );
3. }

4: bulkUpdate: Batch delete or update

BulkUpdate provides batch deletion and update, which are directly converted to the corresponding update/delete SQL for batch deletion and update.

1. Public void batchDelete (String name, int age ){
2. This. hibernateTemplate. bulkUpdate ("delete Teacher whereName=? AndAge=? ", New Object [] {name, age });
3. }

1. Public void batchDelete (String name, String newName ){
2. This. hibernateTemplate. bulkUpdate ("update Teacher setName=? WhereName=? ", New Object [] {newName, name });
3. }

In this case, you must manually clear the cache of related objects in Hibernate (including Level 1 cache and level 2 cache) by using the bulkUpdate operation)

5: execute Core Method

1. Public Object execute (HibernateCallBack action, boolean exposeNativeSession) throws DataAccessException {
2. // Obtain a Session
3. SessionSession=GetSession();
4. // Whether the current session is in the transaction
5. BooleanExistingTransaction=SessionFactoryUtils. IsSessionTransactional (session, getSessionFactory ());
6. FlushModePreviusflushmode=Null;
8. Try {
9. Previusflushmode=ApplyFlushMode(Session, existingTransaction); // apply the flush Mode
10. EnableFilters (session );
12. // Session exposed to action
13. SessionSessionToExpose= (ExposeNativeSession? Session: createSessionProxy (session ));
14. // Execute action
15. ObjectResult=Action. DoInHibernate (sessionToExpose );
16. FlushIfNecessary (session, existingTransaction );
18. Return result;
20. } Catch (HibernateException ex ){
21. Throw convertHibernateAccessException (ex );
22. } Catch (SQLException ex ){
23. Throw convertJdbcAccessException (ex );
24. } Catch (RuntimeException ex ){
25. Throw ex;
26. } Finally {
27. // If the session is in the transaction, the session is not closed.
28. If (existingTransaction ){
29. DisableFilters (session );
30. If (previusflushmode! = Null ){
31. Session. setFlushMode (previusflushmode );
32. }
33. } Else {
34. // Release the session
35. SessionFactoryUtils. releaseSession (session, getSessionFactory ());
36. }
37. }
38. }

* HibernateCallBack, which is generally used to implement specific business logic

* ExposeNativeSession: A boolean value that must be exposed to the actual session Object of HibernateCallBack, rather than a proxy object.

6: Generally, the execute method is used only when the methods provided by HIberateTemplate cannot meet the requirements. Its usage is as follows,

1. Public void createDatabaseSchema () throws DataAccessException {
2. HibernateTemplateHibernateTemplate=NewHibernateTemplate (this. sessionFactory );
3. // Call the execute method of HibernateTempalte
4. HibernateTemplate.exe cute (new HibernateCallback (){
5. Public Object doInHibernate (Session session) throws HibernateException, SQLException {// doInHibernate method that implements HibernateCallback
6. // Specific implementation
7. ConnectionConn=Session. Connection ();
8. Final DialectDialect=Dialect. GetDialect (configuration. getProperties );
9. String []SQL=Configuration. GenerateSchemaCreationScript (dialect );
10. ExecuteSchemaScript (conn, SQL );
11. }
12. });
13. }

The focus of the execute method is to implement the doInHibernate method of HibernateCallback. It will pass a Session instance, which can be used to operate the database, from this we can see that the advantage of the execute method is that the application does not have to worry about session creation and release, but only needs to process the business logic of interest.