`
feigme
  • 浏览: 153058 次
  • 性别: Icon_minigender_1
  • 来自: 球面世界
社区版块
存档分类
最新评论

Spring与Hibernate Annotation的实现

    博客分类:
  • Java
阅读更多
最近实现了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包找齐,网上别人提供的很多例子都是不完全的,所以还是要多看看

包中的文档啊!

分享到:
评论
6 楼 peijunlin2008 2010-02-23  
把源代码发出来,学习一下!
5 楼 feigme 2008-01-31  
这个是jdk5.0有的特性,泛型要用到的
4 楼 javado 2007-12-29  
T 和里面的PK是什么啊?
3 楼 feigme 2007-09-08  
全部都是从Eclipse中拷过来的,并且测试过了
当然借鉴了网上的资料
不过代码部分都是自己写的哈
2 楼 bulargy 2007-09-05  
我日,还你以为你代码都是原创的,说几天不见功力大增,搞了半天好多都是贴的。日日日!!!
1 楼 bulargy 2007-09-05  
这个好东东!

相关推荐

Global site tag (gtag.js) - Google Analytics