`
feigme
  • 浏览: 155144 次
  • 性别: 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  
这个好东东!

相关推荐

    spring+hibernate annotation 完整示例,带数据库脚本

    这个"spring+hibernate annotation 完整示例,带数据库脚本"的项目,旨在提供一个全面的示例,帮助开发者了解如何在实际项目中结合Spring和Hibernate使用注解来实现数据访问。下面我们将深入探讨这些知识点。 1. **...

    spring加入hibernate annotation方式.zip

    本文将深入探讨如何将Spring与Hibernate结合,采用注解方式来进行配置和开发,以实现高效的数据访问。 首先,让我们了解Spring框架。Spring是一个开源的Java平台,它简化了企业级应用开发,通过依赖注入(DI)和...

    sping hibernate Annotation(注释配置) demo(例子)

    本文将深入探讨如何结合 Spring 的注解配置与 Hibernate 实现数据持久化,通过一个实际的 demo 示例来阐述整个过程。 首先,Spring 框架以其依赖注入(Dependency Injection, DI)和面向切面编程(Aspect-Oriented ...

    jquery easyUI+struts2+spring+hibernate基于annotation实现的CRM

    【标题】:“jQuery EasyUI+Struts2+Spring+Hibernate基于注解实现的CRM系统” 在IT领域,CRM(Customer Relationship Management,客户关系管理)系统是企业用来优化与客户交互和管理的重要工具。本项目利用一系列...

    hibernate annotation spring 中文参考文档

    Hibernate Annotations与Spring的结合使用,使得开发更高效,例如通过Spring的@Autowired可以自动装配Hibernate的SessionFactory或EntityManager,实现数据访问层的便捷操作。"hibernate_reference"文档则可能包含对...

    spring与hibernate的整合

    总结来说,Spring 与 Hibernate 的整合主要涉及 SessionFactory 的配置、DAO 类的实现以及事务管理。通过 Spring 的 IoC 容器管理数据访问资源,可以使应用更加解耦,同时利用 Spring 的事务管理功能,可以简化事务...

    SSH2 annotation 实现struts2.1.6 spring2.5.6 hibernate3.3 全注解开发

    在IT行业中,SSH2是一个常见的框架组合,由Struts2、Spring和Hibernate三个组件组成,用于构建企业级的Java Web应用程序。在这个特定的项目中,开发者选择了SSH2的特定版本:Struts2.1.6、Spring2.5.6和Hibernate3.3...

    完整版spring hibernate整合采用annotation

    总的来说,"完整版spring hibernate整合采用annotation"是一个涵盖多个知识点的主题,包括Spring注解驱动开发、Hibernate的ORM注解、Spring与Hibernate的整合配置、事务管理以及相关的开发工具使用。通过深入学习和...

    spring和hibernate的Annotation

    在IT领域,Spring和Hibernate是两个非常重要的框架,它们分别在依赖注入和对象关系映射(ORM)方面扮演着核心角色。在这个名为“springAndHibernateAnnotation”的小项目中,我们将探讨如何结合使用Spring的注解驱动...

    spring_hibernate_annotation的三种实现

    以下将详细介绍"spring_hibernate_annotation的三种实现"。 1. **基于XML的配置** 在早期的Spring和Hibernate集成中,通常使用XML配置文件来定义Bean和数据源,以及映射信息。Spring的`applicationContext.xml`...

    spring整合hibernate实现事务处理

    在`Spring_1800_Spring_Hibernate_Transaction_Annotation`这个压缩包文件中,很可能包含了使用注解方式实现Spring整合Hibernate事务处理的相关示例代码和配置文件。通过阅读和理解这些代码,你可以更好地掌握这一...

    JSF+Spring+Hibernate(Annotation)

    JSF+Spring+Hibernate(Annotation)的login小实例,建议入门的朋友看看,老鸟就免了,呵呵。环境:SQLSever2000+jdk5.0+spring2.0+hibernate3.2+jsf

    Spring与hibernate 整合 简单示例

    总结来说,Spring与Hibernate的整合使得Java开发人员能够更方便地管理数据库操作,并利用Spring的强大功能进行事务管理和组件装配。通过这个简单的示例,我们可以了解到如何配置Spring的环境,定义实体类,创建DAO和...

    Hibernate Annotation入门

    **Hibernate Annotation 入门** Hibernate 是一款非常流行的Java对象关系映射(ORM)框架,它允许开发者使用面向对象的方式操作数据库。而Hibernate Annotation是Hibernate的一个重要特性,它通过在Java类和字段上...

    Spring与Hibernate集成---声明式事务

    本文将深入探讨如何将Spring与Hibernate进行集成,并重点介绍声明式事务的配置与使用。 Spring框架是一个全面的企业级应用开发框架,它提供依赖注入(DI)和面向切面编程(AOP)等功能,简化了Java应用的复杂性。另...

    SpringMVC Spring Hibernate 框架整合 Annotation Maven Project

    Hibernate是Java领域最流行的ORM框架之一,它将Java对象与数据库表进行映射,通过对象的方式来操作数据库。Hibernate提供了一套强大的API,包括Session、SessionFactory、Query等,使得开发者可以进行CRUD(创建、...

    struts+spring+hibernate三大框架整合

    3. **DAO层的实现**:Spring的`HibernateTemplate`或`HibernateOperations`可以简化DAO层的代码,但更推荐使用`HibernateJpaVendorAdapter`配合JPA的`EntityManager`,因为JPA提供了更丰富的ORM功能,并且与多种持久...

    spring3、 hibernate4 配置声明式事务管理(annotation方式)

    Hibernate本身也支持事务管理,但通常与Spring集成时,我们使用Spring的事务管理。`HibernateTransactionManager`是Spring提供的专门用于管理Hibernate事务的类,它会自动处理Hibernate Session和JDBC Connection的...

Global site tag (gtag.js) - Google Analytics