精华内容
下载资源
问答
  • Spring与Hibernate集成

    2019-03-26 01:27:11
    NULL 博文链接:https://pan33.iteye.com/blog/1147543
  • Spring与Hibernate整合

    万次阅读 2017-11-10 21:09:26
    本章先介绍Spring与Hibernate整合的目的,然后采用对Emp表的CURD作为综合案例,介绍两大框架整合的步骤、关键整合点、整合之后如何操作数据库。最后采用Spring的声明式事务对Hibernate进行管理,增加程序的健壮性。...

    本章简介

    第1章、第2章中分别介绍了 Spring的控制反转和面向切面编程,我们了解了依赖注入的含义、依赖注入的方式、面向切面的编程以及4种通知。本章先介绍Spring与Hibernate整合的目的,然后采用对Emp表的CURD作为综合案例,介绍两大框架整合的步骤、关键整合点、整合之后如何操作数据库。最后采用Spring的声明式事务对Hibernate进行管理,增加程序的健壮性。

    JAVA就业套餐课:https://edu.csdn.net/combo/detail/1230

    核心技能部分

     

    第1章 

    1.1 Spring与Hibernate整合简介 

    当我们用JDBC编程的时候,数据库操作的代码非常繁琐,后来学习Hibernate,数据库的操作代码大大简化,但代码仍然比较繁琐,我们可以充分使用Spring依赖注入和AOP简化Hibernate应用。

    Spring在资源管理、DAO 的实现及事务策略方面提供与Hibernate 的集成,通过IOC对Hibernate提供一流的支持,并在解决典型的 Hibernate整合问题中展现了突出的作用。Spring提供的支持都遵循其通用的事务及DAO异常体系。

    在实际应用开发中,web程序的依赖关系是这样的:Action依赖Biz,Biz依赖DAO,DAO依赖SessionFactory,SessionFactory依赖DataSource。可以使用Spring的依赖注入来管理这些对象。事务处理在实际应用中非常重要,如果在每个涉及数据库操作的方法中都加入事务控制代码,那将是一件很痛苦的事情,而Spring AOP可以很好的解决这个问题。

     

     

     

    Spring 向不同的事务 API提供一致的编程模型,提供比传统事务 API更简单且易用的编程式事务管理 API,能够整合数据访问,支持声明式事务管理。

    1.1 Spring与Hibernate整合

    我们以操作emp表为例,来探索两大框架的整合过程。

    1.1.1 处理SessionFactory 

    Spring与Hibernate集成开发主要包括两种方式,二者的区别在于配置文件的使用。

    1.将Spring与Hibernate各自的配置文件进行合并

    两种方式都可以使用MyEclipse工具完成,操作步骤如下:

    步骤1 添加Spring特性,如图4.1.2所示。

     

     

     

    步骤2 勾选Spring支持包,如图4.1.3所示。

     

     

     

     

     

     

     

     

    步骤6 把Hibernate配置放入现有的Spring配置文件,生成sessionFactory,如图4.1.7所示。

     

     

     

     

    步骤7 确定数据库信息,完成配置,如图4.1.8所示。

     

     

     

     

    2. Spring与Hibernate分别使用各自的配置文件

    当需要将Spring的配置文件与Hibernate配置文件分开配置的时候,只有步骤5和步骤6不一样,分别将两个步骤替换如下:

    步骤5 勾选单独的Hibernate配置文件,如图4.1.9所示。

     

     

     

     

    步骤6 生成Hibernate配置文件和sessionFactory,如图4.1.10所示。

     

     

     

     

    合并后的配置文件如示例4.1所示。

    示例4.1

     

     

     

    <!-- dataSource的配置 -->

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">

    <property name="driverClassName" value="oracle.jdbc.OracleDriver">

    </property>

    <property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:orcl">

    </property>

    <property name="username" value="scott"></property>

    <property name="password" value="tiger"></property>

    </bean>

    <!-- sessionFactory的配置 -->

    <bean id="sessionFactory"

    class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

    <property name="dataSource">

    <ref bean="dataSource" />

    </property>

    <property name="hibernateProperties">

    <props>

    <prop key="hibernate.dialect">

    org.hibernate.dialect.Oracle9Dialect

    </prop>

    <!—显示sql语句 -->

    <prop key="hibernate.show_sql">

    true

    </prop>

    </props>

    </property>

           <!—映射文件的配置-->

    <property name="mappingResources">

    <list>

    <value>entity/Emp.hbm.xml</value>

    </list>

    </property>

    </bean>

    两个文件单独配置时,Spring配置如示例4.2所示。

    示例4.2

    <!-- 加载Hibernate配置 -->

    <!-- 定义Hibernate的SessionFactory bean -->

    <bean id="sessionFactory"

    class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

    <!-- 使用Spring提供的LocalSessionFactoryBean,传入一个Hibernate配置文件的位置 -->

    <property name="configLocation" value="file:src/hibernate.cfg.xml">

    </property>

    </bean>

    无论使用哪种整合方式,在Spring配置文件中都有一个sessionFactory,我们知道Hibernate对数据库的操作依靠session完成,而sessionFactory正是用来产生session。

    1.1.1 使用HibernateTemplate简化DAO

     

     

    Spring提供多种数据库访问技术的DAO支持,可以使用相同的访问模式,使用不同的数据库访问技术。这种DAO支持大大地减少数据库访问的代码量,提高开发效率。接下来我们设计如示例4.3所示的DAO接口。

    示例4.3

    public interface EmpDao {

    public void addEmp(Emp emp);

    public void delEmp(short empNo);

    public void updateEmp(Emp emp);

    public Emp get(short empNo);

    public List searchEmp(Emp emp);

    public List searchEmp(String hql);

    }

    我们可以使用Spring提供的HibernateTemplate来简化EmpDao的实现。如示例4.4所示。

    示例4.4

    public class EmpDaoImpl extends HibernateDaoSupport implements EmpDao {

    public void addEmp(Emp emp) {

    super.getHibernateTemplate().save(emp);

    }

    public void delEmp(short empNo) {

    super.getHibernateTemplate().delete(this.get(empNo));

    }

    public Emp get(short empNo) {

    Emp emp = (Emp) super.getHibernateTemplate().get(Emp.class, empNo);

    return emp;

    }

    public List searchEmp(final Emp condition) {

    List list = super.getHibernateTemplate().executeFind(

    new HibernateCallback() {

    public Object doInHibernate(Session session)

    throws HibernateException, SQLException {

    // 构建查询

    Criteria c = session.createCriteria(Emp.class);

    if (condition != null) {

    // 构造Criteria查询条件的代码

    }

    return c.list();

    }

    });

    return list;

    }

    public List searchEmp(String hql) {

    return super.getHibernateTemplate().find(hql);

    }

    public void updateEmp(Emp emp) {

    super.getHibernateTemplate().update(emp);

    }

    }

    在示例4.4现中,我们发现Spring提供的HibernateDaoSupport类可以简化Hibernate的开发。HibernateDaoSupport类提供了getHibernateTemplate()方法获得HibernateTemplate对象,HibernateTemplate对象提供了非常多的方法,如表4-1-1所示。

    表4-1-1 HibernateTemplate常用的方法

    编号

    方法

    功能

    1

    find(String queryString)

    根据HQL查询字符串来返回集合示例

    2

    save(Object entity)

    保存新的示例

    3

    update(Object entity)

    根据给定的持久化对象更新记录

    4

    delete(Object entity)

    删除指定持久化实例

    5

    deleteAll(Collection entities)

    删除集合内全部持久化类实例

    6

    get(Class entityClass,Serializable id)

    根据主键加载特定持久化类的实例

    7

    saveOrUpdate(Object entity)

    根据实例状态,选择保存或更新

    我们并没有在示例4.4中看到有关SessionFactory的代码,Spring为HibernateDaoSupport类提供了setSessionFactory方法,我们将通过这个setter方法向DAO类注入SessionFactory。配置方式如示例4.5所示。

    示例4.5

    <!--EmpDaoImpl的配置 -->

    <bean id="EmpDao" class="dao.impl.EmpDaoImpl">

    <!-- 注入sessionFactory -->

    <property name="sessionFactory" ref="sessionFactory"></property>

    </bean>

    1.1.2 业务层的处理

    我们已经完成了EmpDao的定义,将EmpDao注入到empBiz中需要在EmpBiz中增加EmpDao属性及对应setter和getter方法。

    代码如示例4.6所示。

    示例4.6

    public class EmpBizImpl implements EmpBiz {

    private EmpDao EmpDao;

    public void addEmp(Emp emp) {

    EmpDao.addEmp(emp);

    }

    public void delEmp(short empNo) {

    EmpDao.delEmp(empNo);

    }

    public Emp get(short empNo) {

    return EmpDao.get(empNo);

    }

    public List searchEmp(Emp condition) {

    return EmpDao.searchEmp(condition);

    }

    public List searchAllEmp() {

    String hql="from Emp";

    return EmpDao.searchEmp(hql);

    }

    public void updateEmp(Emp emp) {

    EmpDao.updateEmp(emp);

    }

    //setter & getter

    }

    在Spring配置文件中,我们需要在业务逻辑中注入DAO,如示例4.7所示。

    示例4.7

    <bean id="empBiz" class="biz.impl.EmpBizImpl">

    <property name="EmpDao" ref="EmpDao"></property>

    </bean>

    1.1 声明式事务

    之前我们编写的程序,事务都是在DAO层控制,在实际应用开发中显然是不合适的。比如某银行的业务逻辑方法中需要对DAO进行多次调用,如示例4.8所示。

    示例4.8

    public void  transferAccount(CardVo from,CardVo to,double money)

    {

    from.setMoney(from.getMoney()+money);

    cardDAO.update(from);//修改转账人账户

    to.setMoney(to.getMoney()-money);

    cardDAO.update(to);//修改收款账户

    RecordVO record=new RecordVO(from,to,money);

    recordDAO.add(record);//增加交易记录

    }

    这个业务方法中执行了三个持久化操作,根据业务需求要求这三个操作要么全部成功,要么都不能成功,也就是:客观上需要对业务逻辑层的方法进行事务控制。

    事务处理是企业应用开发中不能回避的一个重要问题。在Hibernate风行之前,JDBC是数据持久化的主要手段,为了达到在业务逻辑层进行事务控制,一个通用的做法是将Connection对象以参数的形式传来传去。业务逻辑层应该只出现描述业务逻辑的代码,Connection在业务逻辑层的出现破坏了三层结构的基本原则。另外一个做法是将业务逻辑放到DAO层实现,DAO层依据业务逻辑创建方法,编写复杂的业务逻辑代码,这样进行架构设计的系统很快就会尝到苦果。

    事务是系统开发过程中的一个方面,散步在系统里,我们可以通过AOP来实现。

    1.1.1 事务通知

    使用Spring的声明式事务,我们无需编写程序代码,所有的工作都在配置文件中完成,这种不需要编程的事务称为“声明式事务”。配置事务通知需要先声明一个事务管理器,我们可以新建一个aop.xml文件,将事务配置放在该配置文件中。如示例4.9所示。

    示例4.9

    <!-- 事务管理器的配置 -->

    <bean id="txManager"

    class="org.springframework.orm.hibernate3.HibernateTransactionManager">

    <property name="sessionFactory">

    <!-- 注入applicationContext.xml中配置的sessionFactory -->

    <ref bean="sessionFactory" />

    </property>

    </bean>

    接下来可以使用 Spring带有的一个<tx:advice>标签,该标签会创建一个事务通知,我们所需要的就是创建一个切入点,该切入点配置所有带事务的方法并引用事务性通知。事务通知的配置如示例4.10所示,该示例采用Spring2.x方式,需要加入命名空间的引用。

    示例4.10

    <!-- 事务通知的配置,需要指定一个事务管理器 -->

    <tx:advice id="txAdvice" transaction-manager="txManager">

    <!-- 定义属性,声明事务规则 -->

    <tx:attributes>

    <!-- 对get/find/search/query开头的方法要求只读事务 -->

    <tx:method name="get*" propagation="SUPPORTS" read-only="true" />

    <tx:method name="search*" propagation="SUPPORTS" read-only="true" />

    <tx:method name="find*" propagation="SUPPORTS" read-only="true" />

    <tx:method name="query*" propagation="SUPPORTS" read-only="true" />

    <!-- 对add/del/update/do开头的方法要求必须运行在事务环境中 -->

    <tx:method name="del*" propagation="REQUIRED" />

    <tx:method name="add*" propagation="REQUIRED" />

    <tx:method name="update*" propagation="REQUIRED" />

    <tx:method name="do*" propagation="REQUIRED" />

    <!-- 对其他方法采用如下配置 -->

    <tx:method name="*" propagation="REQUIRED" read-only="true" />

    </tx:attributes>

    </tx:advice>

    在<tx:advice>标签内设值id和transaction-manager属性,id是advice Bean的标识,而transaction-manager引用一个事务管理器。

    除了这两个属性外,还可以通过<tx:attributes/>标签配置事务属性。<tx:method>的propagation属性表示事务的传播行为,REQUIRED表示如果存在一个事务,则支持当前事务,如果当前没有事务,则开启一个新的事务。SUPPORTS表示如果存在一个事务,则支持当前事务,如果当前没有事务,则按非事务方式执行。<tx:method> 的属性name="*"表示匹配所有其他的方法readOnly表示启用只读事务。这样数据库库就可以采取合适的优化措施避免不必要的操作。

    1.1.2 事务通知和切入点组合

    我们已经定义一个id为txAdvice的事务通知,接下来,我们需要将事务通知和切入点组合,最合适的切入点是biz的方法,可以是接口中声明的方法,也可以直接将切入点定义为biz实现的方法。代码片段如示例4.11所示。

    示例4.11

    <!-- 将事务通知和切入点组合 -->

    <aop:config>

    <aop:pointcut expression="execution(* biz.*.*(..))" id="pc" />

    <aop:advisor advice-ref="txAdvice" pointcut-ref="pc" />

    </aop:config>

    上面的代码表示biz包下所有类的所有方法都应用事务规则。至此,Spring与 Hibernate的整合完成。数据库操作还是需要Hibernate完成,Spring起到管理的作用,比如Spring管理各个Bean,管理Hibernate的事务。这样的代码不但简介,而且健壮性也得到了很好的保证,是企业应用开发的首选。

    对以上整合的测试代码如示例4.12所示。

    示例4.12

    public static void main(String[] args) throws ParseException {

    ApplicationContext context = new ClassPathXmlApplicationContext(

    new String[] { "applicationContext.xml", "aop.xml" });

    EmpBiz empBiz = (EmpBiz) context.getBean("empBiz");

    Emp emp = new Emp();

    emp.setEmpno((short) 1000);

    emp.setEname("张翠山");

    emp.setJob("主管");

    emp.setMgr((short) 7879);

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

    Date hiredate = sdf.parse("2001-12-12");

    emp.setHiredate(new Timestamp(hiredate.getTime()));

    emp.setSal(8000.0);

    emp.setComm(2000.0);

    emp.setDeptno((byte) 20);

    empBiz.addEmp(emp);//添加新员工

    }

    添加之后,数据库的记录如图4.1.11所示:

     

     

     

     

     

    测试查询所有的员工,如示例4.13所示。

    示例4.13

    List<Emp> empList = empBiz.searchAllEmp();

    for (Emp emp : empList) {

    System.out.println(emp.getEmpno() + "\t" + emp.getEname() + "\t"

    + emp.getSal() + "\t" + emp.getComm());

    }

    测试结果如图4.1.12所示。

     

     

     

    1.1 使用工具生成Spring DAO

     

    开发过程中,一般通过反向工程生成表对应的实体对象,同时也可以勾选Spring DAO选项,通过MyEclipse生成实体对象的DAO。操作如图4.1.13所示。

     

     

     

     

    生成的DAO代码如示例4.14所示。

    示例4.14

    public class EmpDao extends HibernateDaoSupport {

    private static final Log log = LogFactory.getLog(EmpDao.class);

    // property constants

    public static final String ENAME = "ename";

    public static final String JOB = "job";

    public static final String MGR = "mgr";

    public static final String SAL = "sal";

    public static final String COMM = "comm";

    public static final String DEPTNO = "deptno";

    protected void initDao() {

    // do nothing

    }

    public void save(Emp transientInstance) {

    log.debug("saving Emp instance");

    try {

    getHibernateTemplate().save(transientInstance);

    log.debug("save successful");

    } catch (RuntimeException re) {

    log.error("save failed", re);

    throw re;

    }

    }

    public void delete(Emp persistentInstance) {

    log.debug("deleting Emp instance");

    try {

    getHibernateTemplate().delete(persistentInstance);

    log.debug("delete successful");

    } catch (RuntimeException re) {

    log.error("delete failed", re);

    throw re;

    }

    }

    public Emp findById(java.lang.Short id) {

    log.debug("getting Emp instance with id: " + id);

    try {

    Emp instance = (Emp) getHibernateTemplate().get("orm.Emp", id);

    return instance;

    } catch (RuntimeException re) {

    log.error("get failed", re);

    throw re;

    }

    }

    public List findByExample(Emp instance) {

    log.debug("finding Emp instance by example");

    try {

    List results = getHibernateTemplate().findByExample(instance);

    log.debug("find by example successful, result size: "

    + results.size());

    return results;

    } catch (RuntimeException re) {

    log.error("find by example failed", re);

    throw re;

    }

    }

    public List findByProperty(String propertyName, Object value) {

    log.debug("finding Emp instance with property: " + propertyName

    + ", value: " + value);

    try {

    String queryString = "from Emp as model where model."

    + propertyName + "= ?";

    return getHibernateTemplate().find(queryString, value);

    } catch (RuntimeException re) {

    log.error("find by property name failed", re);

    throw re;

    }

    }

    public List findByEname(Object ename) {

    return findByProperty(ENAME, ename);

    }

    public List findByJob(Object job) {

    return findByProperty(JOB, job);

    }

    public List findByMgr(Object mgr) {

    return findByProperty(MGR, mgr);

    }

    public List findBySal(Object sal) {

    return findByProperty(SAL, sal);

    }

    public List findByComm(Object comm) {

    return findByProperty(COMM, comm);

    }

    public List findByDeptno(Object deptno) {

    return findByProperty(DEPTNO, deptno);

    }

    public List findAll() {

    log.debug("finding all Emp instances");

    try {

    String queryString = "from Emp";

    return getHibernateTemplate().find(queryString);

    } catch (RuntimeException re) {

    log.error("find all failed", re);

    throw re;

    }

    }

    public Emp merge(Emp detachedInstance) {

    log.debug("merging Emp instance");

    try {

    Emp result = (Emp) getHibernateTemplate().merge(detachedInstance);

    log.debug("merge successful");

    return result;

    } catch (RuntimeException re) {

    log.error("merge failed", re);

    throw re;

    }

    }

    public void attachDirty(Emp instance) {

    log.debug("attaching dirty Emp instance");

    try {

    getHibernateTemplate().saveOrUpdate(instance);

    log.debug("attach successful");

    } catch (RuntimeException re) {

    log.error("attach failed", re);

    throw re;

    }

    }

    public void attachClean(Emp instance) {

    log.debug("attaching clean Emp instance");

    try {

    getHibernateTemplate().lock(instance, LockMode.NONE);

    log.debug("attach successful");

    } catch (RuntimeException re) {

    log.error("attach failed", re);

    throw re;

    }

    }

    public static EmpDao getFromApplicationContext(ApplicationContext ctx) {

    return (EmpDao) ctx.getBean("EmpDao");

    }

    }

    以上代码我们可以看到,使用工具生成的DAO中有大量的方法,这些方法我们可以直接在业务层调用,也会在配置文件中自动配置。这些方法的功能描述见表4-1-2所示。

    表4-1-2 DAO的方法及功能描述

    方法名称

    描述

    void save(Emp transientInstance)

    根据对象添加

    delete(Emp persistentInstance)

    根据对象删除

    findById(java.lang.Short id)

    根据ID查询对象

    findByExample(Emp instance)

    根据对象查询,查询条件为对象的属性值

    findByEname(Object ename)

    根据员工名查询

    findAll()

    查询所有员工

    merge(Emp detachedInstance)

    合并session中存在相同ID的对象

    attachDirty(Emp instance)

    添加与修改,相当于saveOrUpdate

    attachClean(Emp instance)

    将传入的对象状态设值为Transient状态


    本章总结

     

    Ø Spring整合Hibernate

    n 配置SessionFactory

    n HibernateTemplate

    n HibernateDaoSupport

    Ø 声明式事务管理

    n 配置事物管理器HibernateTransactionManager

    n 使用<tx:advice>结合事务管理器配置事物通知

    n 在<tx:advice>内使用<tx:attributes>和<tx:method>针对不同的方法配置事物属性

    Ø 使用工具自动生成 Spring DAO

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    任务实训部分

     

    1:完成银行账户系统的框架搭建

    训练技能点

    Ø sessionFactory的配置

    Ø HibernateTemplate的使用

    需求说明

    某银行系统需要开发一个小系统,该系统能查看账户信息、销户、开户、转账、查看交易记录等功能,要求使用Spring+Hibernate实现。该系统两张表,分别是账户信息表、交易记录表,账户信息表的字段说明如表4-2-1所示。

    表4-2-1 账户信息表(ACCOUNT)

    编号

    字段名称

    字段说明

    1

    ACCOUNT_ID

    账户ID,主键使用序列seq_account,number(10)

    2

    USER_NAME

    账户名,varchar2(20);

    3

    MONEY

    账户余额,number(6)

    4

    CREATEDATE

    开户时间,date

    交易记录表的字段说明如表4-2-2所示。

    表4-2-2 交易记录表(TBL_RECORD)

    编号

    字段名称

    字段说明

    1

    RECORD_ID

    交易编号,主键使用序列seq_record,number(10)

    2

    FROMACCOUNT

    转出帐号,number(10)

    3

    TOACCOUNT

    转入帐号,number(10)

    4

    RECORD_DATE

    交易时间,date

    5

    REMARK

    备注 varchar2(80)

     

     

    实现思路

    (1) 创建数据表。

    (2) 为项目添加Spring和Hibernate支持。

    (3) 编写实体类和映射文件。

    (4) 定义DAO接口和实现。

    (5) 定义Biz接口和实现。

    关键代码

    (1) 配置文件的配置。

     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">

    <property name="driverClassName" value="oracle.jdbc.OracleDriver">

    </property>

    <property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:orcl">

    </property>

    <property name="username" value="scott"></property>

    <property name="password" value="tiger"></property>

    </bean>

    <bean id="sessionFactory"

    class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

    <property name="dataSource">

    <ref bean="dataSource" />

    </property>

    <property name="hibernateProperties">

    <props>

    <prop key="hibernate.dialect">

    org.hibernate.dialect.Oracle9Dialect

    </prop>

    <prop key="hibernate.show_sql">

    true

    </prop>

    </props>

    </property>

    <property name="mappingResources">

    <list>

    <value>orm/Account.hbm.xml</value>

    <value>orm/TblRecord.hbm.xml</value>

    </list>

    </property>

    </bean>

    (2)  实体类和映射文件。

    //账户实体类

     public class Account implements java.io.Serializable {

    private Long accountId;//账户编号

    private String userName;//账户名

    private Integer money;//余额

    private Timestamp createdate;//开户时间

    //setter & getter

    }

    //交易记录实体

    public class TblRecord implements java.io.Serializable {

    private Long recordId;//交易编号

    private Long fromaccount;//转账账户编号

    private Long toaccount;//收款帐号

    private Timestamp recordDate;//转账时间

    private String remark;//备注

    //setter & getter

    }

    (3) 定义DAO接口和实现,DAO实现需要继承HibernateDaoSupport,但不写方法和方法体。

    //账户DAO

    public interface AccountDAO {

    }

    //交易记录DAO

    public interface RecordDAO {

    }

    (4) 定义Biz接口和实现,Biz的实现类需要增加两个属性,AccountDAO和RecordDAO,并生成setter和getter方法,但不添加任何方法和方法体。

    //业务逻辑接口

    public interface BankBiz {

    }

    2:声明式事务配置

    训练技能点

    Ø 声明式事务

    需求说明

    完善框架搭建,增加Biz和DAO的配置件和声明式事务。

    实现思路

    (1) 增加Biz和DAO的配置。

    (2) 编写配置文件,增加声明式事务配置。

    3:实现银行系统的开户和查看账户信息功能

    训练技能点

    Ø HibernateTemplate的使用

    需求说明

    实现开户和账户信息查询功能。

    实现思路

    (1) 完善DAO层的实现,编写方法和方法体。

    (2) 完善Biz层的实现,编写方法和方法体。

    (3) 编写测试代码,测试开户和账户信息查看功能。

    关键代码

    (1)在DAO中增加以下方法声明,并实现DAO的方法。

    //RecordDAO中的方法声明

    public TblRecord get(long id);

    public void addRecord(TblRecord record);//增加交易记录

    public void delRecord(long recordId);//删除交易记录

    //AccountDAO中的方法声明

    public Account get(long id);//根据主键查询账户信息

    public void addAccount(Account account);//添加账户信息

    public void delAccount(long id);//根据主键删除账户信息

    public void updateAccount(Account account);//修改账户信息

    public List findAllAccount();//查询所有账户信息

    (2) 在Biz中增加以下方法声明,并实现Biz的方法。

    //BankBiz接口中添加的方法声明

    public Account findAccountById(long id);//查询账户信息

    public void doAddAcount(Account account);//用户开户

    //BankBiz方法的实现

    public void doAddAcount(Account account) {

    accountDAO.addAccount(account);

    }

    public Account findAccountById(long id) {

    return accountDAO.get(id);

    }

    4:完善银行系统,增加转账功能

    训练技能点

    Ø HibernateTemplate的使用

    Ø 业务逻辑层的实现

    需求说明

    实现转账功能。

    实现思路

    (1) 在Biz接口中增加转账方法声明。

    (2) 实现转账方法。

    (3) 编写测试代码,测试转账功能。

    关键代码

    (1)在Biz接口中增加转账方法声明。

    //BankBiz中声明转账方法

    public boolean doTransferAccount(long from,long to,int money);//转账

     (2) 实现转账方法。

    public boolean doTransferAccount(long from, long to, int money) {

    boolean result = false;

    // 根据编号获取账户信息

    Account from_Account = accountDAO.get(from);

    Account to_Account = accountDAO.get(to);

    if (from_Account!=null&&from_Account.getMoney() > money)// 如果余额大于转账金额

    {

    if (to_Account != null)// 如果收款帐号存在

    {

       //扣除转账人账户余额

    //添加收款人账户余额

    //记录交易记录

    result = true;

    }

    }

    return result;

    }

     


    巩固练习

     

    一.选择题

        以下关于Spring对Hibernate提供支持的说法中,错误的是()。

        A. Spring提供了基类大大简化了程序代码

        B. Spring提供的基类支持分页查询

        C. Spring提供的基类需要注入sessionFactory才能正常运行

        D. Spring提供的基类不需要注入sessionFactory

    2. Spring整合Hibernate后,能够用于保存数据的方法有()。

        A. save

        B. load

        C. saveOrUpdate

        D. merge

    3. Spring整合Hibernate后,以下关于findByCriteria方法的说法中,正确的是()。

        A. 参数是HQL

        B. 参数是Restrictions对象

        C. 参数是DetachedCriteria对象

        D. 该方法不支持分页

    4. 以下关于 Spring与Hibernate集成的说法中,错误的是()。

        A. 通过集成Spring与Hibernate,以Spring管理程序的依赖关系,将SessionFactory注入 DataSource

        B. 通过Spring,在Biz层代码中无须直接实例化DAO类,而是通过注入获得

        C. 通过Spring,在DAO类中无须实例化SessionFactory,而是通过注入获得

    D. Spring提供HibemateDaoSupport类简化Hibernate的使用

    5.关于声明式事务,下面说法错误的是()。

    A.Spring采用AOP方式实现声明式事务

    B.声明式事务是非侵入式的,可以不修改原来代码就给系统增加事务支持

    C.配置声明式事务必须tx和aop两个命名空间的支持

    D.事务有编程式事务和非编程式事务,声明式事务是非编程式事务

    二.操作题

    1.结合EMP的CURD,编写一个业务方法,实现员工的分页查询,每页显示5条员工信息。

    2.查看课外书籍,使用注解重构实训任务的声明式事务。

    3.升级实训任务,实现交易记录的分页查询。

    提示:分页查询的实现

    List list = super.getHibernateTemplate().executeFind(

    new HibernateCallback() {

    public Object doInHibernate(Session session)

    throws HibernateException, SQLException {

    String hql = "from TblRecord record where  record.fromaccount=" + fromId;

    Query query = session.createQuery(hql);

    query.setFirstResult(firstResult);

    query.setMaxResults(5);

    return query.list();

    }

    });

    4.重构“会员账户管理系统”,使用Hibernate实现DAO层开发,并编写测试代码,测试业务逻辑层的功能。要求使用声明式事务,每项业务操作都必须有日志记录。

     

     

     

    展开全文
  • NULL 博文链接:https://chenming47.iteye.com/blog/437199
  • spring 与hibernate集成

    2010-05-17 14:44:04
    spring 与hibernate集成方法 spring 与hibernate集成方法
  • NULL 博文链接:https://quicker.iteye.com/blog/674029
  • spring-boot 集成hibernate

    2017-01-10 18:50:06
    spring-boot 集成hibernate,使用druid数据库连接池,dao继承HibernateDaoSupport 的实现,
  • SpringHibernate集成

    千次阅读 2018-10-25 13:42:11
    9 SpringHibernate集成  单独属于hibernate时候需要创建一个hibernate.cfg.xml 来数据库连接信息,现在都交给spring管理在applicationContext.xml  中配置  1 配置连接池  2 配置sessionFactory ...
    1 创建一个普通的java项目,修改为web项目

     

    创建web目录
    
                     - 创建WEB-INF目录
    
                               -创建classes目录
    
                               -创建lib目录
    
    修改buildpath路径为classes

    3. 再拷贝一个web.xml文件到WEB-INF目录下

    4. 在创建一个resources来装配置文件  

    5. 拷贝applicationContext.xml db.properties 到resources目录下

    6.添加依赖包

            hibernate的依赖包, required下的所有包,还有数据库驱动包和连接池包

             spring的依赖包 

    7.准备Domain实体类和映射文件

    创建Employee文件和employee.hbm.xml映射文件

    package com.lxx.ssh.domain;
    
    import lombok.Getter;
    import lombok.Setter;
    import lombok.ToString;
    
    @Getter @Setter @ToString
    public class Employee {
    
    		private Long id;
    		private String name;
    		private Integer age;
    }
    
    <?xml version="1.0"?>
    <!DOCTYPE hibernate-mapping PUBLIC 
    	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    	"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    
    <hibernate-mapping package="com.lxx.ssh.domain">
    	
    	<class name="Employee" table="employee">
    		<id name="id">
    			<generator class="native"/>
    		</id>
    		<property name="name"/>
    		<property name="age"/>
    		
    	</class>
    	
    </hibernate-mapping>
    

     

    8.创建DAO

        创建EmployeeDAO

       

    package com.lxx.ssh.dao;
    
    import java.util.List;
    
    import com.lxx.ssh.domain.Employee;
    
    public interface IEmployeeDAO {
    
    	public void save(Employee e);
    	public void delete(Employee e);
    	public void update(Employee e);
    	public Employee get(Long id);
    	public List<Employee> listAll();
    
    }
    

     

        创建EmployeeDAOImpl实现类和测试类

     

    9 Spring和Hibernate集成

     单独属于hibernate时候需要创建一个hibernate.cfg.xml 来数据库连接信息,现在都交给spring管理在applicationContext.xml

     中配置

            1 配置连接池

            2 配置sessionFactory

               2.1)配置DataSource属性,管理连接池,

    	<!-- 属性占位符 引入classpath:db.properties -->
    	<context:property-placeholder location="classpath:db.properties"
    		system-properties-mode="NEVER" />
    
    	<!-- 配置连接池 -->
    	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
    		init-method="init" destroy-method="close">
    		<property name="driverClassName" value="${jbdc.driverClassName}" />
    		<property name="url" value="${jbdc.url}" />
    		<property name="username" value="${jbdc.username}" />
    		<property name="password" value="${jbdc.password}" />
    	</bean>
    

     

     

     

                   2.2)配置hibernateProperties属性,表示hibernate的属性配置(方言,是否打印SQL,格式化SQL等)

    <!--配置sessionFactory LocalSessionFactoryBean 创建spingbean实例4种方法第四种 -->
    	<bean id="sessionFactory"
    		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
    		<!-- 配置连接池 -->
    		<property name="dataSource" ref="dataSource" />
    
    
    		<!-- 配置Hibernate的属性配置 -->
    		<property name="hibernateProperties">
    			<value>
    				<!-- -->
    				hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
    				<!-- -->
    				hibernate.show_sql=true
    				<!-- -->
    				hibernate.hbm2ddl.auto=update
    			</value>
    		</property>
    
    
    		<!-- 之前的hib.cfg.xml需要管联映射文件,现在映射文件在这里 
    			映射文件的位置 
    		-->
    		<property name="mappingLocations" value="com/lxx/ssh/domain/*.hbm.xml"/>
    
    	</bean>

     

                       2.3)映射文件的位置

     

    <!-- 配置DAO -->
    	<bean id="employeeDAO" class="com.lxx.ssh.dao.impl.EmployeeDAOImpl">
    		<property name="sessionFactory" ref="sessionFactory"/>
    	</bean>

     

                       2.4)配置事务管理器

                                因为 方法必须有事务

          Session session = sessionFactory.getCurrentSession();

                

     

     

     

     

     

     

     

     

     

     

     

     

     

     

                                    

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • Spring 与hibernate集成

    2019-03-06 01:30:43
    博文链接:https://shaqiang32.iteye.com/blog/201919
  • Spring+Hibernate集成环境中使用EhCache缓存做的开发测试,在线程中打开数据库查询数据,及关闭数据库后查询数据的结果.
  • Spring与Hibernate集成声明式事务.ppt
  • 此文档只说明简单的框架集成,各个框架的高级特性未涉及,此文档适合有框架使用基础的开发人员查看,新手可能需要参考其他资料。
  • 包含springmvc+spring+hibernate集成所需要的所有的jar包
  • 工作需要用到spring boot jpa(表主键类型为字符串且程序能指定主键值)。 网上找不到这样的例子,只好我自已整理一份了。 该demo基于spring boot 2.0.0.RELEASE构建是个可以运行的最基本的例子,它会自动创建SQLite...
  • cxf+spring+hibernate集成整合jar包
  • Spring集成Hibernate

    千次阅读 2019-08-28 23:32:48
    一、Spring集成Hibernate Hibernate是在开发者社区很流行的开源持久化框架。它不仅提供了基本的对象关系映射,还提供了ORM工具所应具有的所有复杂功能,比如缓存、延迟加载、预先抓取以及分布式缓存。 1.1 声明...

    一、Spring中集成Hibernate

    Hibernate是在开发者社区很流行的开源持久化框架。它不仅提供了基本的对象关系映射,还提供了ORM工具所应具有的所有复杂功能,比如缓存、延迟加载、预先抓取以及分布式缓存。

    1.1 声明Hibernate的Session工厂

    在这里插入图片描述

    1.2 构建不依赖于Spring的Hibernate代码

    在这里插入图片描述
    为了给不使用模板的Hibernate Repository添加异常转换功能,我们只需在Spring应用上下文中添加一个PersistenceExceptionTranslationPostProcessorbean:
    在这里插入图片描述
    PersistenceExceptionTranslationPostProcessor是一个bean 后置处理器(bean post-processor),它会在所有拥有@Repository注解的类上添加一个通知器(advisor),这样就会捕获任何平台相关的异常并以Spring非检查型数据访问异常的形式重新抛出。

    二、Spring与Java持久化API(JPA)

    2.1 配置实体管理器工厂

    简单来讲,基于JPA的应用程序需要使用EntityManagerFactory的实现类来获取EntityManager实例。JPA定义了两种类型的实体管理器:

    • 应用程序管理类型(Application-managed):当应用程序向实体管理器工厂直接请求实体管理器时,工厂会创建一个实体管理器。在这种模式下,程序要负责打开或关闭实体管理器并在事务中对其进行控制。这种方式的实体管理器适合于不运行在JavaEE容器中的独立应用程序。
    • 容器管理类型(Container-managed):实体管理器由Java EE创建和管理。应用程序根本不与实体管理器工厂打交道。相反,实体管理器直接通过注入或JNDI来获取。容器负责配置实体管理器工厂。这种类型的实体管理器最适用于Java EE容器,在这种情况下会希望在persistence.xml指定的JPA配置之外保持一些自己对JPA的控制。

    这两种实体管理器工厂分别由对应的Spring工厂Bean创建:

    • LocalEntityManagerFactoryBean生成应用程序管理类型的EntityManager-Factory;
    • LocalContainerEntityManagerFactoryBean生成容器管理类型的Entity-ManagerFactory。

    配置应用程序管理类型的JPA

    对于应用程序管理类型的实体管理器工厂来说,它绝大部分配置信息来源于一个名为persistence.xml的配置文件。这个文件必须位于类路径下的META-INF目录下。
    persistence.xml的作用在于定义一个或多个持久化单元。持久化单元是同一个数据源下的一个或多个持久化类。简单来讲,persistence.xml列出了一个或多个的持久化类以及一些其他的配置如数据源和基于XML的配置文件。如下是一个典型的persistence.xml文件:
    在这里插入图片描述
    因为在persistence.xml文件中包含了大量的配置信息,所以在Spring中需要配置的就很少了。可以通过以下的@Bean注解方法在Spring中声明LocalEntityManagerFactoryBean:
    在这里插入图片描述

    使用容器管理类型的JPA

    容器管理的JPA采取了一个不同的方式。当运行在容器中时,可以使用容器(在我们的场景下是Spring)提供的信息来生成EntityManagerFactory。

    你可以将数据源信息配置在Spring应用上下文中,而不是在persistence.xml中了。例如,如下的@Bean注解方法声明了在Spring中如何使用LocalContainerEntity-ManagerFactoryBean来配置容器管理类型的JPA:
    在这里插入图片描述
    这里,我们使用了Spring配置的数据源来设置dataSource属性。任何javax.sql.DataSource的实现都是可以的。尽管数据源还可以在persistence.xml中进行配置,但是这个属性指定的数据源具有更高的优先级。

    jpaVendorAdapter属性用于指明所使用的是哪一个厂商的JPA实现。Spring提供了多个JPA厂商适配器:

    • EclipseLinkJpaVendorAdapter
    • HibernateJpaVendorAdapter
    • OpenJpaVendorAdapter

    在本例中,我们使用Hibernate作为JPA实现,所以将其配置为Hibernate-JpaVendorAdapter:
    在这里插入图片描述
    persistence.xml文件的主要作用就在于识别持久化单元中的实体类。但是从Spring 3.1开始,我们能够在LocalContainerEntityManagerFactoryBean中直接设置packagesToScan属性:
    在这里插入图片描述

    从JNDI获取实体管理器工厂

    还有一件需要注意的事项,如果将Spring应用程序部署在应用服务器中,EntityManagerFactory可能已经创建好了并且位于JNDI中等待查询使用。在这种情况下,可以使用Spring jee命名空间下的<jee:jndi-lookup>元素来获取对EntityManagerFactory的引用:
    在这里插入图片描述
    在这里插入图片描述

    2.2 编写基于JPA的Repository

    在这里插入图片描述
    需要注意的是EntityManagerFactory属性,它使用了@PersistenceUnit注解,因此,Spring会将EntityManagerFactory注入到Repository之中。有了EntityManagerFactory之后,JpaSpitterRepository的方法就能使用它来创建EntityManager了,然后EntityManager可以针对数据库执行操作。

    将EntityManager的代理注入到Repository之中

    在这里插入图片描述

    三、借助Spring Data实现自动化的JPARepository

    为了要求Spring Data创建SpitterRepository的实现,我们需要在Spring配置中添加一个元素。如下的程序清单展现了在XML配置中启用Spring Data JPA所需要添加的内容:
    在这里插入图片描述
    <jpa:repositories>元素掌握了Spring Data JPA的所有魔力。就像<context:component-scan>元素一样,<jpa:repositories>元素也需要指定一个要进行扫描的base-package。不过,<context:component-scan>会扫描包(及其子包)来查找带有@Component注解的类,而<jpa:repositories>会扫描它的基础包来查找扩展自SpringData JPA Repository接口的所有接口。如果发现了扩展自Repository的接口,它会自动生成(在应用启动的时候)这个接口的实现。

    如果要使用Java配置的话,那就不需要使用<jpa:repositories>元素了,而是要在Java配置类上添加@EnableJpaRepositories注解。如下就是一个Java配置类,它使用了@EnableJpaRepositories注解,并且会扫描com.habuma.spittr.db包:
    在这里插入图片描述

    3.1 定义查询方法

    在这里插入图片描述
    我们并不需要实现findByUsername()。方法签名已经告诉Spring Data JPA足够的信息来创建这个方法的实现了。
    当创建Repository实现的时候,Spring Data会检查Repository接口的所有方法,解析方法的名称,并基于被持久化的对象来试图推测方法的目的。本质上,Spring Data定义了一组小型的领域特定语言(domain-specific language ,DSL),在这里,持久化的细节都是通过Repository方法的签名来描述的。

    Repository方法是由一个动词、一个可选的主题(Subject)、关键词By以及一个断言所组成。
    示例:
    在这里插入图片描述
    我们可以看到,这里的动词是read,与之前样例中的find有所差别。Spring Data允许在方法名中使用四种动词:get、read、find和count。其中,动词get、read和find是同义的,这三个动词对应的Repository方法都会查询数据并返回对象。而动词count则会返回匹配对象的数量,而不是对象本身。

    3.2 声明自定义查询

    如果所需的数据无法通过方法名称进行恰当地描述,那么我们可以使用@Query注解,为Spring Data提供要执行的查询。对于findAllGmailSpitters()方法,我们可以按照如下的方式来使用@Query注解:
    在这里插入图片描述
    3.3 混合自定义的功能
    有些时候,我们需要Repository所提供的功能是无法用Spring Data的方法命名约定来描述的,甚至无法用@Query注解设置查询来实现。尽管Spring Data JPA非常棒,但是它依然有其局限性,可能需要我们按照传统的方式来编写Repository方法:也就是直接使用EntityManager。

    如果你需要做的事情无法通过Spring Data JPA来实现,那就必须要在一个比Spring Data JPA更低的层级上使用JPA。好消息是我们没有必要完全放弃Spring Data JPA。我们只需在必须使用较低层级JPA的方法上,才使用这种传统的方式即可,而对于Spring Data JPA知道该如何处理的功能,我们依然可以通过它来实现。

    当Spring Data JPA为Repository接口生成实现的时候,它还会查找名字与接口相同,并且添加了Impl后缀的一个类。如果这个类存在的话,Spring Data JPA将会把它的方法与Spring Data JPA所生成的方法合并在一起。对于SpitterRepository接口而言,要查找的类名为SpitterRepositoryImpl。

    为了阐述该功能,假设我们需要在SpitterRepository中添加一个方法,发表Spittle数量在10,000及以上的Spitter将会更新为Elite状态。使用Spring Data JPA的方法命名约定或使用@Query均没有办法声明这样的方法。最为可行的方案是使用如下的eliteSweep()方法。
    在这里插入图片描述
    SpitterRepositoryImpl没有什么特殊之处,它使用被注入的EntityManager来完成预期的任务。
    注意,SpitterRepositoryImpl并没有实现SpitterRepository接口。Spring Data JPA负责实现这个接口。SpitterRepositoryImpl(将它与Spring Data的Repository关联起来的是它的名字)实现了SpitterSweeper接口,它如下所示:
    在这里插入图片描述
    我们还需要确保eliteSweep()方法会被声明在SpitterRepository接口中。要实现这一点,避免代码重复的简单方式就是修改SpitterRepository,让它扩展SpitterSweeper:
    在这里插入图片描述
    如前所述,Spring Data JPA将实现类与接口关联起来是基于接口的名称。但是,Impl后缀只是默认的做法,如果你想使用其他后缀的话,只需在配置@EnableJpa-Repositories的时候,设置repositoryImplementationPostfix属性即可:
    在这里插入图片描述
    如果在XML中使用<jpa:repositories>元素来配置Spring DataJPA的话,我们可以借助repository-impl-postfix属性指定后缀:
    在这里插入图片描述
    我们将后缀设置成了Helper,Spring Data JPA将会查找名为SpitterRepository-Helper的类,用它来匹配SpitterRepository接口。

    展开全文
  • spring+springMVC+hibernate集成,包括配置文件applicationContext.xml、web.xml、springMVC-servlet.xml
  • NULL 博文链接:https://ajita.iteye.com/blog/1418557
  • springMVC+spring+hibernate+jquery分页完整项目,完整代码
  • 包含struts1+spring+hibernate集成jar包,不用再去一个一个收集下载啦~
  • 包含springmvc+spring+hibernate集成所需要的所有的jar包
  • 1)Demo 学习要点简介: 1.Spring MVC ModelAndView 2.数据库DAO基类的模式 2)Demo 导入说明: 1.Eclipse Encoding:UTF-8 2.内附Oracle建表等可执行语句
  • 网上找不到这样的例子,只好我自已整理一份了。 该demo是基于maven集成spring5、hibernate5、spring-data-jpa2、H2的可以运行的最基本的main例子。 希望能对大家有帮助。
  • 使用spring+mvc+hibernate集成redis缓存,如有需要详细使用阅读内容可以访问我的博客来查看http://blog.csdn.net/wohuozheng?ref=toolbar
  • NULL 博文链接:https://xwhoyeah.iteye.com/blog/517879
  • 简单的JSF+Hibernate+Spring集成项目 This project is very easy to understand JSF,Spring and Hibernate integration. 项目结构 如果你想使用这个项目。你几乎不需要改变。 1.Go to WEB-INF/...
  • springhibernate集成Demo

    2013-01-15 16:31:13
    spring2.5和hibernate3.3集成的小Demo.
  • Spring集成Hibernate所需全部jar包,包括mysql驱动,Spring的全部包,Hibernate全部包,AOP的包
  • 主要给大家介绍了关于Spring集成Struts与Hibernate的相关资料,文中介绍的非常详细,对大家具有一定的参考价值,需要的朋友们下面来一起看看吧。
  • 本资源主要是结合博文 Spring+Hibernate: 声明式事务 http://blog.csdn.net/ManagementAndJava/article/details/78050519 的源代码,主要是讲解了spring4.3和hibernate5.2.11集成实现原理;

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 66,209
精华内容 26,483
关键字:

关于spring与hibernate集成

spring 订阅