文档章节

Spring+JSF+JPA(Hibernate)的环境搭建(二)

码上中国博客
 码上中国博客
发布于 2015/02/06 12:34
字数 1535
阅读 313
收藏 4

下面我们加入JPA支持,并且将JPA和Spring集成起来。

(1).首先加入persistence.xml文件

内容如下:

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
    http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
    version="1.0">
 
    <persistence-unit name="JSJDemoPU"
       transaction-type="RESOURCE_LOCAL">
       <provider>org.hibernate.ejb.HibernatePersistence</provider>
       <class>test.vo.Test</class>
       <properties>
           <!-- Hibernate 方言(只有Hibernate 才需要设置) -->
           <property name="hibernate.dialect"
              value="org.hibernate.dialect.MySQLDialect" />
           <!-- Hibernate 显示调试 SQL -->
           <property name="hibernate.show_sql" value="true" />
           <!-- Hibernate 格式化sql -->
           <property name="hibernate.format_sql" value="true" />
           <property name="hibernate.hbm2ddl.auto" value="update" />
       </properties>
    </persistence-unit>
 
</persistence>

(2).之后建立一个值对象

代码如下:

package mangerTeam.vo;
 
import java.io.Serializable;
import java.util.Set;
 
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.Lob;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
 
/**
 * 运动员实体
 *
 * @author 刘岩
 */
@Entity
@Table(name = "player")
public class PlayersVO implements Serializable {
 
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "id", unique = true, nullable = false)
    private Integer id;
 
    @Column(name = "name")
    private String name;
 
    @ManyToOne(optional=true, fetch = FetchType.LAZY)
    @JoinColumn(name = "teamId")
    private TeamVO teamVO;
 
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(nullable=false,name = "nationalityId")
    private NationalityVO nationalityVO;
 
    @Lob
    @Basic(fetch = FetchType.LAZY)
    @Column(name = "pic")
    private byte[] pic;
 
    @Lob
    @Basic(fetch = FetchType.LAZY)
    @Column(name = "mess")
    private String mess;
 
    @ManyToMany(cascade = CascadeType.REFRESH, fetch = FetchType.LAZY)
    @JoinTable(name = "plays_position", joinColumns = {@JoinColumn(name = "playerId") }, inverseJoinColumns = {@JoinColumn(name = "positionId") })
    private Set<PositionVO> positions;
 
    public Integer getId() {
       return id;
    }
 
    public void setId(Integer id) {
       this.id = id;
    }
   
    public String getName() {
       return name;
    }
 
    public void setName(String name) {
       this.name = name;
    }
 
    public Set<PositionVO> getPositions() {
       return positions;
    }
 
    public void setPositions(Set<PositionVO> positions) {
       this.positions = positions;
    }
 
    public TeamVO getTeamVO() {
       return teamVO;
    }
 
    public void setTeamVO(TeamVO teamVO) {
       this.teamVO = teamVO;
    }
 
    public NationalityVO getNationalityVO() {
       return nationalityVO;
    }
 
    public void setNationalityVO(NationalityVO nationalityVO) {
       this.nationalityVO = nationalityVO;
    }
 
    public byte[] getPic() {
       return pic;
    }
 
    public void setPic(byte[] pic) {
       this.pic = pic;
    }
 
    public String getMess() {
       return mess;
    }

(3).之后写DAO

无论你是用IDE生成的DAO还是自己写的DAO,代码大致如下:

@Transactional
public class PlayerDAO extends JpaDaoSupport implements IPlayerDAO {
    // property constants
    public static final String NAME = "name";
    public static final String MESS = "mess";
    public static final String PIC = "pic";
 
    public void save(PlayersVO entity) {
       logger.info("saving Player instance");
       try {
           getJpaTemplate().persist(entity);
           logger.info("save successful");
       } catch (RuntimeException re) {
           logger.error("save failed", re);
           throw re;
       }
    }
 
    public void delete(PlayersVO entity) { 
       logger.info("deleting Player instance");
       try {
           entity = getJpaTemplate().getReference(PlayersVO.class,
                  entity.getId());
           getJpaTemplate().remove(entity);
           logger.info("delete successful");
       } catch (RuntimeException re) {
           logger.error("delete failed", re);
           throw re;
       }
    }
    public PlayersVO update(PlayersVO entity) {
       logger.info("updating Player instance");
       try {
           PlayersVO result = getJpaTemplate().merge(entity);
           logger.info("update successful");
           return result;
       } catch (RuntimeException re) {
           logger.error("update failed", re);
           throw re;
       }
    }
 
    public PlayersVO findById(Integer id) {
       logger.info("finding Player instance with id: " + id);
       try {
           PlayersVO instance = getJpaTemplate().find(PlayersVO.class, id);
           return instance;
       } catch (RuntimeException re) {
           logger.error("find failed", re);
           throw re;
       }
    }
 
    @SuppressWarnings("unchecked")
    public List<PlayersVO> findByProperty(String propertyName,
           final Object value, final int... rowStartIdxAndCount) {
       logger.info("finding Player instance with property: " + propertyName
              + ", value: " + value);
       try {
           final String queryString = "select model from PlayersVO model where model."
                  + propertyName + "= :propertyValue";
           return getJpaTemplate().executeFind(new JpaCallback() {
              public Object doInJpa(EntityManager em)
                     throws PersistenceException {
                  Query query = em.createQuery(queryString);
                  query.setParameter("propertyValue", value);
                  if (rowStartIdxAndCount != null
                         && rowStartIdxAndCount.length > 0) {
 
                     // 有分页
                     int rowStartIdx = Math.max(0, rowStartIdxAndCount[0]);
 
                     // 开始页
                     if (rowStartIdx > 0) {
                         query.setFirstResult(rowStartIdx);
                     }
 
                     // 一页最大记录数目
                     if (rowStartIdxAndCount.length > 1) {
                         int rowCount = Math.max(0, rowStartIdxAndCount[1]);
                         if (rowCount > 0) {
                            query.setMaxResults(rowCount);
                         }
                     }
                  }
                  return query.getResultList();
              }
           });
       } catch (RuntimeException re) {
           logger.error("find by property name failed", re);
           throw re;
       }
    }
 
    public List<PlayersVO> findByName(Object name, int... rowStartIdxAndCount) {
       return findByProperty(NAME, name, rowStartIdxAndCount);
    }
 
    public List<PlayersVO> findByMess(Object mess, int... rowStartIdxAndCount) {
       return findByProperty(MESS, mess, rowStartIdxAndCount);
    }
 
    public List<PlayersVO> findByPic(Object pic, int... rowStartIdxAndCount) {
       return findByProperty(PIC, pic, rowStartIdxAndCount);
    }
 
    public List<PlayersVO> findAll(final int... rowStartIdxAndCount) {
       logger.info("finding all Player instances");
       try {
           final String queryString = "select model from PlayersVO model";
           return getJpaTemplate().executeFind(new JpaCallback() {
              public Object doInJpa(EntityManager em)
                     throws PersistenceException {
                  Query query = em.createQuery(queryString);
                  if (rowStartIdxAndCount != null
                         && rowStartIdxAndCount.length > 0) {
                     int rowStartIdx = Math.max(0, rowStartIdxAndCount[0]);
                     if (rowStartIdx > 0) {
                         query.setFirstResult(rowStartIdx);
                      }
 
                     if (rowStartIdxAndCount.length > 1) {
                         int rowCount = Math.max(0, rowStartIdxAndCount[1]);
                         if (rowCount > 0) {
                            query.setMaxResults(rowCount);
                         }
                     }
                  }
                  return query.getResultList();
              }
           });
       } catch (RuntimeException re) {
           logger.error("find all failed", re);
           throw re;
       }
    }
 
         
    public static IPlayerDAO getFromApplicationContext(ApplicationContext ctx) {
       return (IPlayerDAO) ctx.getBean("PlayerDAO");
    }
}

(4).配置Spring文件applicationContext.xml

内容如下:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"
    xmlns:tx="http://www.springframework.org/schema/tx" default-autowire="byName">
 
    <!--数据源连接池,使用dbcp-->
    <bean id="realPoolDataSource" class="org.apache.commons.dbcp.BasicDataSource"
       destroy-method="close">
 
       <!--基本连接设值-->
       <property name="driverClassName" value="org.gjt.mm.mysql.Driver" />
       <property name="url"
           value="jdbc:mysql://127.0.0.1:3306/jsjdemo?useUnicode=true&amp;characterEncoding=UTF-8" />
       <property name="username" value="root" />
       <property name="password" value="root" />
 
       <!--连接池参数设置-->
       <property name="maxIdle" value="20" />
       <property name="maxWait" value="1000" />
       <property name="defaultAutoCommit" value="false" />
       <property name="removeAbandoned" value="true" />
       <property name="removeAbandonedTimeout" value="120" />
 
    </bean>
 
    <!-- c3p0连接池 -->
    <bean id="c3p0DataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
       <property name="driverClass" value="org.gjt.mm.mysql.Driver" />
       <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/jsjdemo?useUnicode=true&amp;characterEncoding=UTF-8" />
       <!-- 当连接池耗尽时候,一次获得连接数-->
       <property name="acquireIncrement" value="5" />
       <!-- 连接池最大数 -->
       <property name="maxPoolSize" value="20" />
       <!-- 连接池最小数-->
       <property name="minPoolSize" value="5" />
       <!-- 用户名-->
       <property name="user" value="root" />
       <!-- 用户密码-->
       <property name="password" value="root"></property>
    </bean>
 
    <!--
       类似于hibernate的SessionFactory,指定由spring容器Bean,即:LocalContainerEntityManagerFactoryBean
    -->
    <bean id="entityManagerFactory"
       class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
       <property name="persistenceUnitName" value="JSJDemoPU" />
       <property name="dataSource" ref="c3p0DataSource" />
    </bean>
 
    <!--配置事务-->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
       <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>
 
    <!--支持dao事务注解-->
    <tx:annotation-driven transaction-manager="transactionManager" />
 
    <!-- Hibernate使用的SessionFactory -->
    <bean id="sessionFactory"
       class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
 
       <!--数据源配置-->
       <property name="dataSource">
           <ref bean="c3p0DataSource" />
       </property>
    </bean>
    <!--Spring注入Dao实现-->
 
    <bean id="testDAO" class="test.dao.TestDAO">
       <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>
 
    <bean id="TeamDAO" class="mangerTeam.dao.TeamDAO">
       <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>
    <bean id="PositionDAO" class="mangerTeam.dao.PositionDAO">
       <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>
    <bean id="PlayerDAO" class="mangerTeam.dao.PlayerDAO">
       <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>
    <bean id="NationalityDAO" class="mangerTeam.dao.NationalityDAO">
       <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>
</beans>

(5)修改faces-config.xml里面的内容

加入如下内容

<managed-bean>
       <managed-bean-name>playersVO</managed-bean-name>
       <managed-bean-class>
           mangerTeam.vo.PlayersVO
       </managed-bean-class>
       <managed-bean-scope>request</managed-bean-scope>
    </managed-bean>
 
    <managed-bean>
       <managed-bean-name>playerAction</managed-bean-name>
       <managed-bean-class>
           mangerTeam.action.PlayerAction
       </managed-bean-class>
       <managed-bean-scope>request</managed-bean-scope>
 
       <!--从Spring得到的DAO-->
        <managed-property>
           <property-name>playerDAO</property-name>
           <value>#{PlayerDAO}</value>
       </managed-property>
       <managed-property>
           <property-name>playersVO</property-name>
           <value>#{playersVO}</value>
       </managed-property>
    </managed-bean>

这样Spring的DAO就注入了该Action(我还是喜欢叫它Action),至于该Action的代码由于过长,就不在此列出,很简单。无非就是注入DAO,setter和getter呗。

到此JSF+Spring+JPA的环境算是集成起来了,项目代码结构图如下:

最后说一下JPA的缺点:

(1)必须使用在JDK1.5以上的环境,否则只能望JPA而兴叹。

(2)因为它是标准,还在不断的更新中,所以还是不太成熟,不敢保证之后会有很大的变动。

(3)和Hibernate一样,对于多个表(对象)的联合查询,效率比纯JDBC的执行sql要慢很多。

JSF的缺点:

(1)调试不是很方便。

(2)无论是sun的实现还是apache的实现,都存在比较多的bug。

(3)组件技术不如js开源框架灵活,有点鸡肋的感觉。




© 著作权归作者所有

共有 人打赏支持
码上中国博客

码上中国博客

粉丝 53
博文 74
码字总数 70310
作品 1
北京
后端工程师
私信 提问
加载中

评论(2)

码上中国博客
码上中国博客

引用来自“MartinBock”的评论

听你这么一说都不敢用jsf了,调试不方便·········坑爹啊
在浏览器中调试primefaces,简直太难了,主要是由于它对jquery和html封装性太强了。
MartinBockZhu
MartinBockZhu
听你这么一说都不敢用jsf了,调试不方便·········坑爹啊
Spring+JSF+JPA(Hibernate)的环境搭建(一)

前言 由于primefaces在国内使用的并不是太多,因此,国内对jsf做系统、详细的介绍的资料很少,即使有一些资料,也仅仅是对国外资料的简单翻译或者是仅仅讲表面现象(皮毛而已),它们的语句甚...

码上中国博客
2015/02/06
0
2
Hibernate环境搭建+struts整合

说明:本文档,是和struts2+hibernate的整合示例。 lib下还有struts2的jar包,本示例没有显示。struts2的搭建参考struts2的环境搭建 一下载hibernate的jar包,并将相关jar包导入的项目web-i...

无信不立
2014/08/14
0
0
新手上路之Hibernate:第一个Hibernate例子

一、Hibernate概述 (一)什么是Hibernate? hibernate核心内容是ORM(关系对象模型)。可以将对象自动的生成数据库中的信息,使得开发更加的面向对象。这样作为程序员就可以使用面向对象的思...

Airship
2016/12/12
0
0
Hibernate详细教程

一、搭建Hibernate环境 1.在src目录下创建hibernate.cfg.xml配置文件 PS:文件的名字不能改! 2. 编写实体类,以Person类为例 package test.Hibernate.model;...

唐僧他大叔
2017/01/15
0
0
Hibernate框架(一)——总体介绍

作为SSH三大框架之一的Hibernate,是用来把程序的Dao层和数据库打交道用的,它封装了JDBC的步骤,是我们对数据库的操作更加简单,更加快捷。利用Hibernate框架我们就可以不再编写重复的JDBC代...

凡尘里的一根葱
2015/11/10
0
0

没有更多内容

加载失败,请刷新页面

加载更多

Linux Wireshark普通用户启动使用方案

当系统安装好Wireshark后请正常启动是否可以进行正常使用,如果不行请参考下列指导 向系统添加一个用户组 sudo groupadd wireshark //如提示此组存在可跳过 将指定用户添加到这个组中 sudo...

CHONGCHEN
今天
2
0
CSS 选择器参考手册

CSS 选择器参考手册 选择器 描述 [attribute] 用于选取带有指定属性的元素。 [attribute=value] 用于选取带有指定属性和值的元素。 [attribute~=value] 用于选取属性值中包含指定词汇的元素。...

Jack088
今天
2
0
数据库篇一

数据库篇 第1章 数据库介绍 1.1 数据库概述  什么是数据库(DB:DataBase) 数据库就是存储数据的仓库,其本质是一个文件系统,数据按照特定的格式将数据存储起来,用户可以对数据库中的数据...

stars永恒
今天
4
0
Intellij IDEA中设置了jsp页面,但是在访问页面时却提示404

在Intellij IDEA中设置了spring boot的jsp页面,但是在访问时,却出现404,Not Found,经过查找资料后解决,步骤如下: 在Run/Debug Configurations面板中设置该程序的Working Directory选项...

uknow8692
昨天
4
0
day24:文档第五行增内容|每月1号压缩/etc/目录|过滤文本重复次数多的10个单词|人员分组|

1、在文本文档1.txt里第五行下面增加如下内容;两个方法; # This is a test file.# Test insert line into this file. 分析:给文档后增加内容,可以用sed 来搞定;也可以用while do done...

芬野de博客
昨天
4
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部