Spring与Hibernate Annotation的实现

最近实现了Spring2.0 　Hibernate3.2     Hibernate Annotation 3.3   GenericDao 整合实现

用起来还是很顺手的

代码给出如下

java 代码

1. package cn.feigme.model;   
2.   
3.   
4. /**  
5.  * @author Feigme   
6.  *  
7.  */  
8. import javax.persistence.Entity;   
9. import javax.persistence.GeneratedValue;   
10. import javax.persistence.GenerationType;   
11. import javax.persistence.Id;   
12. import javax.persistence.Table;   
13.   
14. /**  
15.  * 用户.带jpa annotation简版配置.  
16.  */  
17. @Entity  
18. @Table(name = "User")   
19. public class User {   
20.     private Integer id;   
21.   
22.     private String username;   
23.   
24.     private String password;   
25.   
26.     private String email;   
27.        
28.     @Id  
29.     @GeneratedValue(strategy = GenerationType.AUTO)   
30.     public Integer getId() {   
31.         return id;   
32.     }   
33.   
34.     public void setId(Integer id) {   
35.         this.id = id;   
36.     }   
37.   
38.     public String getEmail() {   
39.         return email;   
40.     }   
41.   
42.     public void setEmail(String email) {   
43.         this.email = email;   
44.     }   
45.   
46.     public String getUsername() {   
47.         return username;   
48.     }   
49.   
50.     public void setUsername(String username) {   
51.         this.username = username;   
52.     }   
53.   
54.     public String getPassword() {   
55.         return password;   
56.     }   
57.   
58.     public void setPassword(String password) {   
59.         this.password = password;   
60.     }   
61. }   

Hibernate　Annotation减少了XML文件，配制起来也非常方便

java 代码

1. package cn.feigme.dao;   
2.   
3. import java.io.Serializable;   
4.   
5. public interface IGenericDao<T, PK extends Serializable> {   
6.   
7.     PK save(T newInstance);   
8.        
9.     T find(PK id);   
10.        
11.     void update(T transientObject);   
12.        
13.     void delete(T persistentObject);   
14.        
15. }  

基于jdk5.0特性的　　generic dao　可以减少很多dao重复编码

java 代码

1. /**  
2.  * GenericDaoHibernateImpl.java  
3.  * cn.feigme.dao.impl  
4.  * @author Feigme   
5.  * 2007-8-26  
6.  */  
7. package cn.feigme.dao.impl;   
8.   
9. import java.io.Serializable;   
10. import cn.feigme.dao.IGenericDao;   
11.   
12. /**  
13.  * @author Feigme   
14.  *  
15.  */  
16. public abstract class GenericDaoHibernateImpl<T, PK extends Serializable> extends BaseDao implements IGenericDao<T,PK> {   
17.   
18.     private Class<T> persistentClass;   
19.        
20.     /*@SuppressWarnings("unchecked")  
21.     public GenericDaoHibernateImpl(Class<T> t) {  
22.         this.persistentClass = (Class<T>) ((ParameterizedType) getClass()     
23.                 .getGenericSuperclass()).getActualTypeArguments()[0];    
24.     }*/  
25.        
26.     public GenericDaoHibernateImpl(Class<T> t){   
27.         this.persistentClass = t;   
28.     }   
29.        
30.     public Class<T> getPersistentClass() {      
31.         return persistentClass;      
32.     }   
33.   
34.     public void delete(T persistentObject) {   
35.            
36.         this.getHibernateTemplate().delete(persistentObject);   
37.     }   
38.   
39.     @SuppressWarnings("unchecked")   
40.     public T find(PK id) {   
41.            
42.         return (T) this.getHibernateTemplate().get(getPersistentClass(), id);   
43.     }   
44.   
45.     @SuppressWarnings("unchecked")   
46.     public PK save(T newInstance) {   
47.            
48.         return (PK)this.getHibernateTemplate().save(newInstance);   
49.     }   
50.   
51.     public void update(T transientObject) {   
52.            
53.         this.getHibernateTemplate().update(transientObject);   
54.     }   
55.   
56. }   

generic dao的实现类，注意他的构造函数

java 代码

1. /**  
2.  * UserDao.java  
3.  * cn.feigme.dao  
4.  * @author Feigme   
5.  * 2007-8-27  
6.  */  
7. package cn.feigme.dao;   
8.   
9. import cn.feigme.model.User;   
10.   
11. /**  
12.  * @author Feigme   
13.  *  
14.  */  
15. public interface UserDao extends IGenericDao<User,Long> {   
16.   
17. }  

UserDao　就非常简单了，继承GenericDao就可以了，如果多的方法，直接写在这个dao中，

java 代码

1. /**  
2.  * UserDaoImpl.java  
3.  * cn.feigme.dao.impl  
4.  * @author Feigme   
5.  * 2007-8-27  
6.  */  
7. package cn.feigme.dao.impl;   
8.   
9. import cn.feigme.dao.UserDao;   
10. import cn.feigme.model.User;   
11.   
12. /**  
13.  * @author Feigme   
14.  *  
15.  */  
16. public class UserDaoImpl extends GenericDaoHibernateImpl<User, Long > implements UserDao {   
17.        
18.     /**  
19.      * 必须要有空构造函数  
20.      */  
21.     public UserDaoImpl() {   
22.         super(User.class);   
23.     }   
24. }   

这里有一点也是要特别注意的，至少我测试时出了些问题

java 代码

1. package test;   
2.   
3. import org.junit.After;   
4. import org.junit.Before;   
5. import org.junit.Test;   
6. import org.springframework.context.ApplicationContext;   
7. import org.springframework.context.support.ClassPathXmlApplicationContext;   
8.   
9. import cn.feigme.dao.UserDao;   
10. import cn.feigme.model.User;   
11.   
12. public class Mytest {   
13.   
14.     private UserDao dao;   
15.   
16.     @Before  
17.     public void setUp() throws Exception {   
18.         String[] config = new String[] {   
19.                 "spring/applicationContext.xml",   
20.                 "spring/dataAccessContext-hibernate.xml",   
21.                 "spring/serviceContext.xml"};   
22.   
23.         ApplicationContext ctx = new ClassPathXmlApplicationContext(config);   
24.         dao = (UserDao) ctx.getBean("userDao");   
25.     }   
26.   
27.     @After  
28.     public void tearDown() throws Exception {   
29.   
30.     }   
31.   
32.     @Test  
33.     public void save() {   
34.   
35.         User u = new User();   
36.         u.setUsername("feigme is me");   
37.         u.setEmail("feigme@163.com");   
38.         dao.save(u);   
39.     }   
40.   
41. }   

这就是简单点的测试类，整合时一定要把 jar包找齐，网上别人提供的很多例子都是不完全的，所以还是要多看看

包中的文档啊！