BlogJava-Colorful Day-随笔分类-ORM

[导入]Hibernate POJO's good assistant-Commons for Eclipse

BlueO2 — Thu, 16 Mar 2006 03:19:00 GMT

POJO used by Hibernate needs to implement hashCode() and equals() method.That's a kind of stuffy work and will be done many many times during development.Some IDEs support automatical generation feature such as IDEA.Eclipse famous plug-in--MyElipse also suppots but it's not free of charge.
I think nearly all JAVAers know Apache Commons open source project.We can use Commons lib to generate hashCode() and equals() method.I wanna tell you that there is also a plugin for Eclipse called Commons4E which help you generate hasCode() and equals().
It also can generate toString() and compareTo() method.That's a smart plugin.Enjoy it.Link

文章来源:http://blueoxygen.dflying.net/3/archive/79_hibernate_pojos_good_assistant-commons_for_eclipse.html

BlueO2 2006-03-16 11:19 发表评论

[导入]Hibernate Performance Tuning

BlueO2 — Thu, 16 Mar 2006 03:19:00 GMT

Hibernate and Lazy Initialization

Hibernate object relational mapping offers both lazy and non-lazy modes of object initialization. Non-lazy initialization retrieves an object and all of its related objects at load time. This can result in hundreds if not thousands of select statements when retrieving one entity. The problem is compounded when bi-directional relationships are used, often causing entire databases to be loaded during the initial request. Of course one could tediously examine each object relationship and manually remove those most costly, but in the end, we may be losing the ease of use benefit sought in using the ORM tool.

The obvious solution is to employ the lazy loading mechanism provided by hibernate. This initialization strategy only loads an object's one-to-many and many-to-many relationships when these fields are accessed. The scenario is practically transparent to the developer and a minimum amount of database requests are made, resulting in major performance gains. One drawback to this technique is that lazy loading requires the Hibernate session to remain open while the data object is in use. This causes a major problem when trying to abstract the persistence layer via the Data Access Object pattern. In order to fully abstract the persistence mechanism, all database logic, including opening and closing sessions, must not be performed in the application layer. Most often, this logic is concealed behind the DAO implementation classes which implement interface stubs. The quick and dirty solution is to forget the DAO pattern and include database connection logic in the application layer. This works for small applications but in large systems this can prove to be a major design flaw, hindering application extensibility.

Being Lazy in the Web Layer

Fortunately for us, the Spring Framework has developed an out of box web solution for using the DAO pattern in combination with Hibernate lazy loading. For anyone not familiar with using the Spring Framework in combination with Hibernate, I will not go into the details here, but I encourage you to read Hibernate Data Access with the Spring Framework. In the case of a web application, Spring comes with both the OpenSessionInViewFilter and the OpenSessionInViewInterceptor. One can use either one interchangeably as both serve the same function. The only difference between the two is the interceptor runs within the Spring container and is configured within the web application context while the Filter runs in front of Spring and is configured within the web.xml. Regardless of which one is used, they both open the hibernate session during the request binding this session to the current thread. Once bound to the thread, the open hibernate session can transparently be used within the DAO implementation classes. The session will remain open for the view allowing lazy access the database value objects. Once the view logic is complete, the hibernate session is closed either in the Filter doFilter method or the Interceptor postHandle method. Below is an example of the configuration of each component:

Interceptor Configuration

> 
   id="urlMapping"     
     class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">    
        name="interceptors">
         >
               bean="openSessionInViewInterceptor"/>
         >
       >
        name="mappings">
  ...
  >
  ...
   name="openSessionInViewInterceptor"  
    class="org.springframework.orm.hibernate.support.OpenSessionInViewInterceptor">
        name="sessionFactory"> bean="sessionFactory"/>>
  >
>

Filter Configuration

-app>
 ...      
  >
    -name>hibernateFilter-name>
    -class>
      org.springframework.orm.hibernate.support.OpenSessionInViewFilter
    -class>
   >
  ...      
  -mapping>
    -name>hibernateFilter-name>
     -pattern>*.spring-pattern>
  -mapping>
  ...
-app>

Implementing the Hibernate DAO's to use the open session is simple. In fact, if you are already using the Spring Framework to implement your Hibernate DAO's, most likely you will not have to change a thing. The DAO's must access Hibernate through the convenient HibernateTemplate utility, which makes database access a piece of cake. Below is an example DAO.

Example DAO

public class HibernateProductDAO extends HibernateDaoSupport implements ProductDAO  {      
 
       public Product getProduct(Integer productId) {
              return (Product)getHibernateTemplate().load(Product.class, productId);
       }
 
       public Integer saveProduct(Product product) {
              return (Integer) getHibernateTemplate().save(product);
       }       
 
       public void updateProduct(Product product) {
              getHibernateTemplate().update(product);
       }
 }

Being Lazy in the Business Layer

Even outside the view, the Spring Framework makes it easy to use lazy load initialization, through the AOP interceptor HibernateInterceptor. The hibernate interceptor transparently intercepts calls to any business object configured in the Spring application context, opening a hibernate session before the call, and closing the session afterward. Let's run through a quick example. Suppose we have an interface BusinessObject:

public interface BusinessObject { 
     public void doSomethingThatInvolvesDaos(); 
}

"2">The class BusinessObjectImpl implements BusinessObject:

public class BusinessObjectImpl implements BusinessObject {
    public void doSomethingThatInvolvesDaos() {
        // lots of logic that calls
        // DAO classes Which access 
        // data objects lazily
    }
}

Through some configurations in the Spring application context, we can instruct the HibernateInterceptor to intercept calls to the BusinessObjectImpl allowing it's methods to lazily access data objects. Take a look at the fragment below:

>
     id="hibernateInterceptor" class="org.springframework.orm.hibernate.HibernateInterceptor">
          name="sessionFactory">
            bean="sessionFactory"/>
         >
    >
     id="businessObjectTarget" class="com.acompany.BusinessObjectImpl">
        name="someDAO"> bean="someDAO"/>>
    >
     id="businessObject" class="org.springframework.aop.framework.ProxyFactoryBean">
          name="target"> bean="businessObjectTarget"/>>
          name="proxyInterfaces">
           >com.acompany.BusinessObject>
         >
          name="interceptorNames">
           >
              >hibernateInterceptor>
           >
         >
     >            
>

When the businessObject bean is referenced, the HibernateInterceptor opens a hibernate session and passes the call onto the BusinessObjectImpl. When the BusinessObjectImpl has finished executing, the HibernateInterceptor transparently closes the session. The application code has no knowledge of any persistence logic, yet it is still able to lazily access data objects.

Being Lazy in your Unit Tests

Last but not least, we'll need the ability to test our lazy application from J-Unit. This is easily done by overriding the setUp and tearDown methods of the TestCase class. I prefer to keep this code in a convenient abstract TestCase class for all of my tests to extend.

public abstract class MyLazyTestCase extends TestCase {
 
        private SessionFactory sessionFactory;
        private Session session;
	
        public void setUp() throws Exception {
	    super.setUp();
	    SessionFactory sessionFactory = (SessionFactory) getBean(\"sessionFactory")" src="http://www.dflying.net/plugins/smileys/icons/default/wink_smile.gif" />;
	    session = SessionFactoryUtils.getSession(sessionFactory, true);
	    Session s = sessionFactory.openSession();
	    TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(s));
 
        }
 
        protected Object getBean(String beanName) {
            //Code to get objects from Spring application context
        }
	
        public void tearDown() throws Exception {
	    super.tearDown();
	    SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
	    Session s = holder.getSession(); 
	    s.flush();
	    TransactionSynchronizationManager.unbindResource(sessionFactory);
	    SessionFactoryUtils.closeSessionIfNecessary(s, sessionFactory);
        }
}

文章来源:http://blueoxygen.dflying.net/3/archive/84_hibernate_performance_tuning.html

BlueO2 2006-03-16 11:19 发表评论

Hibernate mapping summarize

BlueO2 — Wed, 22 Feb 2006 04:45:00 GMT

总结了Hibernate中实体对象与数据的映射方式……图文并茂，配置实例代码，为david吃饱了撑着之大作。

1 Entity's relation

1.1 One to One

一个对象的一个实例对应另一个对象的一个实例从数据库角度描述，一个表中的一条记录对应另外一个表中唯一一条记录

public class Image{
private Long id;
private String imgName;
private Blog value; //to store binary of image
......
}
Image.hbm.xml

public class Product{
private Long id;
private String name;
private double price;
private Image photo;
}

1.2 Many to One

一个对象对应另一个对象的多个实例，从数据库角度描述，是在一个数据表中的一条记录对应另外一个数据表中对条记录.

public class PersonalCompute{
private Long computerId;
private String cpu;
......
private Programmer owner;
}

1.3 One to Many

The same example as Many to One.But we stand at Programmer class's view point.
public class Programmer{
...
private Set computers = new HashSet();
}

inverse="true" cascade="all">

2 Collection

2.1 Map

...

showcase:
Team team1 = new Team();
team1.setName(xx);
team1.getMembers.put("index","content");
......
sess.save...

2.1.1 many-to-any

2.1.2 One to many

单单使用Map做存储往往无法表达复杂的对象,如果要讲对象 map进行映射:
One Team,multi-members
Public class Member{
...
private Team team;
}

...

showcase:
Team team = new Team();
team.setName("xx");
Member mem1 = new Member();
mem1.setXX
mem1.setXX
Member mem2 = new Member();
mem2.setXX
mem2.setXX
team.getMembers().put("xx",mem1);
team.getMembers().put("xx2",mem2);

2.1.3 many to many

teamRole is their common key of Map.
Team

id	name
2	team2

Member

di	name	age
1	davy	23

memberAtTeams

member	team	teamRole
1	2	coach

teamHasMembers

team	member	teamRole
2	1	coach

2.1.4 Composite-index

复杂Index 可以是一个类。
public class Position{
private String role;
private String scene;
public Position()....
getter...
setter...
}

...

index-many-to-one

index-many-to-many

index-many-to-any

2.1.5 composite-element

2.2 Set

<..

2.2.1 one-to-many

2.2.2 many-to-many

2.2.3 many-to-any

2.2.4 composite-element

2.3 List

2.3.1 one-to-many

2.3.2 many-to-many

2.3.3 many-to-many

2.3.4 composite-element

2.4 Bag

It can contains JDK's Collection and List interface type's object.

2.5 idBag

与bag相比多出了collection-id属性

2.6 array

public class Team{
//...
private String[] members;
}

3 Component

Public class Country{
//..
private Position position;
}

3.1 One-to-one

3.2 many-to-one

3.3 dynamic-component

4 Dynamic class

4.1 One-to-one

4.2 many-to-one

5 Mapping type

5.1 Java type to SQL type

5.2 3.0 enmu

5.3 user defined data type

need implements org.hibernate.usertype.CompositeUserType or org.hibernate.usertype.UserType interface.

6 Class Hierarchy's mapping

6.1 Subclasses are saved in on Table

6.1.1 discriminator

Sapmle:

Class AbstractParent{
String id;
/*important*/
String discriminator
}
Class ChildA{
String childA;
}
Class ChildB{
String childB;
}

=========DB=========

colum name	data type	memo
id	varchar
childA	varchar
childB	varchar
class_type	varchar	used to identify subclass:A B

========mapping config file====

id generator

· increment

· identity

· sequence

· hilo

· seqhilo

· uuid

· guid

· native

· assigned

· foreign

composite id

6.2 Subclasses are saved in separated Table

并不为父类Container建立映射文件 Box与Bottle的映射文件也如没有关系一样普通的建立但是对Container取得操作

List pcs = sess.createQuery("from com.be.david.Container").list();
if(!cs.isEmpty()){
...
}
会将Box与Container数据都取出来这是Hibernate默认隐式完成的

6.3 Parent Class and Subclasses are saved in separated Table

6.4 One PO multi-table

public Class Person{
牋牋燬tring id;
牋牋燬tring name;
牋牋燬tring sex;
牋牋燬tring address;
牋牋燬tring city;
牋牋燬tring zipcode;
}
we wanna save address related attributes(blue ones).Use join

牋
牋
牋 ...
牋

6.5 Class A Class B not inherited from Parent Class

6.5.1 subselect

We can use subselct to make ChildA and ChildB standalone.So how can we get all data including ChindA and ChildB?

select * from ChildA
union
select * from ChildB

BlueO2 2006-02-22 12:45 发表评论