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

最新推荐文章于 2016-08-31 18:13:51 发布
最新推荐文章于 2016-08-31 18:13:51 发布
阅读量126 收藏
点赞数
文章标签： java 数据库 python
原文链接：https://my.oschina.net/guopengfei/blog/376052
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

下面我们加入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的环境算是集成起来了，项目代码结构图如下：

123247_jV3m_2303434.jpg

最后说一下JPA的缺点：

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

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

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

JSF的缺点：

（1）调试不是很方便。

（2）无论是sun的实现还是apache的实现，都存在比较多的bug。

（3）组件技术不如js开源框架灵活，有点鸡肋的感觉。




转载于:https://my.oschina.net/guopengfei/blog/376052

weixin_34075551
关注
hibernate(jpa)+spring
qq_33854869的博客
07-13 545
项目中用到了hibernate,抽个时间记录下(前面有个简陋的介绍spring+redis+hibernate,此篇对hibernate有个更为详细的使用). Hibernate是一种ORM(Object Relational Mapping)映射工具，能够建立面向对象的域模型和关系数据模型之间的映射 Object Mapping（Hibernate） Relational 面向对象领域
Spring对Hibernate和JPA的支持
07-15 1098
a、延迟加载（Lazy loading） b、预先抓取（Eager fetching） c、级联（Cascading） 一些可用的框架提供了如上这样的服务，这些服务的通用名称是对象/关系映射（object-relationalmapping，ORM）。在持久层使用ORM工具，可以节省数千行的代码和大量的开发时间。ORM工具能够把你的注意力从容易出错的SQL代码转向如何实现应用程序的真正需求...
jsf基础教程+JPA教程
11-15
jsf基础教程+JPA教程一个简单的jsp框架。STRUS和spring,hibernet虽好，但还是以JSF,jpa为标准。
JSF+EJB+JPA总体思路
weixin_34205826的博客
12-14 574
前言: JSF+EJB+JPA 其实我并没有想象中的难,只是想做好，建立在正确的地方应用,真正的困难. 良好的技术，在错误的地方做应用,这是唯一能够被垃圾. 用. 重量级企业应用能够使用这个主要的3层结构的实现,来添加很多其它的企业级应用.而这些基本上不怎么须要改动,能够说是能够独立开来维护的部分.至于耦合性,关键看怎样建立应用了,这个又和项目開始的分析和设计密切相关. 目的: 建立...
notes_JPA_JSF:使用JSF和JPA实施来重建Notes项目
05-16
笔记_JPA_JSF 使用JSF和JPA实施来重建Notes项目
JSF+EJB+JPA
04-25
这是一个经典javaee项目，使用JSF+EJB+JPA框架来完成的一个基于网络聊天室的dnf拍卖系统，里面含有两个项目，从网络聊天室可以直接进入拍卖系统。
JSF+Spring+JPA(Hibernate实现)的环境搭建
11-14
### JSF+Spring+JPA(Hibernate实现)的环境搭建 #### 一、概述 根据提供的文件信息，本文旨在深入探讨如何构建一个基于JSF、Spring 和 JPA（使用 Hibernate 实现）的技术栈。该技术栈被视为Struts2+Spring+...
JSF+Spring+JPA_Hibernate实现_的环境搭建
09-24
这篇文档"JSF+Spring+JPA_Hibernate实现_的环境搭建.pdf"将引导你一步步建立这样的开发环境，让我们深入探讨其中涉及的知识点。 首先，**JavaServer Faces (JSF)** 是一种Java EE标准的MVC（模型-视图-控制器）框架...
jsf+spring2.5+jpa(hibernate)的jar包
06-01
这是jsf+spring2.5+jpa(hibernate)的jar包，很多人为了jsj环境而配置半天，在此提供jar包共享。注：除了ajax4jsf和tomahawk-1.1.3.jar，因为csdn只让我上传20mb，大家自己可以下一下自己试试。
JSF2.1+Spring3.1+JPA(Hibernate3.6)配置实例
pickpocket的专栏
12-16 128
      首先搭建环境，就不具体说了，我用的是eclipse（不是myeclipse），导入必要的jar包，需要特别注意，Spring的两个AOP的jar包也要倒进去，一开始我认为Aop跟我都应用无关，所以没有导入这两个包，带来不少麻烦。       这里主要讲配置。有两种情况：Pure JPA + Spring和Spring JpaDaoSupport。这两种情况大同小异，主要是细节上有些...
Spring+JSF+JPA(Hibernate)的环境搭建（一）
weixin_34107955的博客
02-06 251
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring与JSF2的整合配置的整理
问题，总是可以解决滴
01-12 3264
目的：在JSF2中可以使用Spring中的Bean，可以通过注解方式配置使用。环境：在JSF2.2，Spring3.2.7版本测试通过。配置过程概述： 整合过程主要包括一下三个方面的配置：web.xml配置，faces-config.xml配置，ManagedBean的配置
eclipse创建JSF整合JPA过程
樂淵的博客
08-31 1451
eclipse需要较新的版本 1.打开创建窗口如下 选择之后点击next 2.持续点击next至该窗口，配置完成后点击finish 3在新建的项目上右击选择Configure-->Convert to JPA Project （我的eclipse版本是 neon，mars2好像可以的，其他的没试） 4点击next出现
No Dialect mapping for JDBC type: -1
bawking
07-18 160
@SuppressWarnings("unchecked") public List findAll(final int... rowStartIdxAndCount) { LogUtil.log("finding all ReturnDidQuery instances", Level.INFO, null); try { final String queryStrin...
JSF+EJB+JPA 应用连接基础结构建设
yilyi的专栏
06-29 288
序言: JSF+EJB+JPA 其实没有想象中的难,不过要做好应用以及在合适的地方建立应用,才是真正的难点. 好的技术在不合适的地方做了应用,那也只能是垃圾. 所以这个东西并不适合于太小规模的企业应用. 重量级企业应用可以使用这个基本的3层结构的实现,来增加更多的企业级应用.而这些基本上不怎么需要修改,可以说是可以独立开来维护的部分.至于耦合性,关键看如何建立应用了,这个又和项目开始的分析和设计密...
Web编程学习二: 使用JPA结合JSF来创建Web应用
Unplugged
03-30 6765
昨天做了一个使用JSF的一个helloworld的小练习，它并没有和后端数据交互。 今天我来加上JPA来持久化数据对象，前台依然使用JSF来展现，做一个完整的Web应用。 这个应用的功能是用户输入用户名和密码后，通过JPA来查询后台数据库进行校验，如果成功则进入欢迎页面。 开发环境： Eclipse Juno， JSF2.1, JPA框架：EclipseLink 2.
JPA入门例子(采用JPA的hibernate实现版本)
热门推荐
hmk2011的专栏
03-30 17万+
<br />（1）、JPA介绍：<br />      JPA全称为Java Persistence API ，Java持久化API是Sun公司在Java EE 5规范中提出的Java持久化接口。JPA吸取了目前Java持久化技术的优点，旨在规范、简化Java对象的持久化工作。使用JPA持久化对象，并不是依赖于某一个ORM框架。 <br />     为什么要使用JAP?<br />      在说为什么要使用JPA之前，我们有必要了解为什么要使用ORM技术。<br />ORM 是Object-Relati
JSF+Spring+JPA环境搭建教程
"JSF+Spring+JPA(Hibernate实现)的环境搭建" 本文主要讨论了如何构建一个基于JSF（JavaServer Faces）、Spring和JPA（Java Persistence API，使用Hibernate实现）的开发环境，这一组合被视为Struts2+Spring+...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值