SPRING+JPA+Hibernate配置方法
1.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:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd"> <!-- 扫描目录 -->
<context:component-scan base-package="com.genius"></context:component-scan>
<bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />
<context:property-placeholder location="classpath:jdbc.properties" ignore-unresolvable="true"/> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
destroy-method="close">
<property name="driverClass" value="${jdbc.driver}" />
<property name="jdbcUrl" value="${jdbc.url}" />
<property name="user" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
<property name="initialPoolSize" value="${connection_pools.initial_pool_size}" />
<property name="minPoolSize" value="${connection_pools.min_pool_size}" />
<property name="maxPoolSize" value="${connection_pools.max_pool_size}" />
<property name="maxIdleTime" value="${connection_pools.max_idle_time}" />
<property name="acquireIncrement" value="${connection_pools.acquire_increment}" />
<property name="checkoutTimeout" value="${connection_pools.checkout_timeout}" />
</bean> <bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="packagesToScan" value="com.genius.han.entity" />
<property name="persistenceProvider">
<bean class="org.hibernate.jpa.HibernatePersistenceProvider" />
</property>
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<property name="generateDdl" value="false" />
</bean>
</property>
<property name="jpaProperties">
<props>
<prop key="hibernate.dialect">${hibernate.dialect}</prop>
<prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
<prop key="hibernate.cache.use_second_level_cache">${hibernate.cache.use_second_level_cache}</prop>
<prop key="hibernate.cache.region.factory_class">${hibernate.cache.region.factory_class}</prop>
<prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>
<prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}</prop>
<prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">false</prop>
<prop key="hibernate.use_sql_comments">false</prop>
<prop key="hibernate.connection.isolation">2</prop>
<prop key="javax.persistence.validation.mode">none</prop>
</props>
</property>
</bean> <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean> <!-- 配置 Annotation 驱动,定义事务 -->
<tx:annotation-driven transaction-manager="transactionManager"
proxy-target-class="false" /> </beans>
jdbc.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/han?useUnicode=true&characterEncoding=UTF-8
jdbc.username=xxxx jdbc.password=xxxx #------------ ConnectionPools ------------
connection_pools.initial_pool_size=5
connection_pools.min_pool_size=5
connection_pools.max_pool_size=100
connection_pools.max_idle_time=600
connection_pools.acquire_increment=5
connection_pools.checkout_timeout=60000 hibernate.dialect=org.hibernate.dialect.MySQLDialect
hibernate.current_session_context_class=thread
hibernate.hbm2ddl.auto=update
hibernate.show_sql=true
hibernate.format_sql=false
hibernate.query.substitutions=Y hibernate.cache.use_second_level_cache=false
hibernate.cache.region.factory_class=org.hibernate.cache.impl.NoCachingRegionFactory
hibernate.cache.use_query_cache=false
hibernate.jdbc.fetch_size=50
hibernate.jdbc.batch_size=30
2. BaseDao
import java.io.Serializable; import javax.persistence.LockModeType;
import javax.persistence.Query; public interface BaseDao<T,ID extends Serializable> extends Serializable{ /**
* 查找实体对象
*
* @param id
* ID
* @return 实体对象,若不存在则返回null
*/
T find(ID id);
/**
* 查找实体对象
*
* @param id
* ID
* @param lockModeType
* 锁定方式
* @return 实体对象,若不存在则返回null
*/
T find(ID id, LockModeType lockModeType); /**
* 持久化实体对象
*
* @param entity
* 实体对象
*/
void persist(T entity); /**
* 合并实体对象
*
* @param entity
* 实体对象
* @return 实体对象
*/
T merge(T entity); /**
* 移除实体对象
*
* @param entity
* 实体对象
*/
void remove(T entity); /**
* 执行JPA原生sql查询
*
* @param sql
* */
public Query createNativeQuery(String sql); /**
* 刷新实体对象
*
* @param entity
* 实体对象
*/
void refresh(T entity); /**
* 刷新实体对象
*
* @param entity
* 实体对象
* @param lockModeType
* 锁定方式
*/
void refresh(T entity, LockModeType lockModeType); /**
* 获取实体对象ID
*
* @param entity
* 实体对象
* @return 实体对象ID
*/
ID getIdentifier(T entity); /**
* 判断是否为托管状态
*
* @param entity
* 实体对象
* @return 是否为托管状态
*/
boolean isManaged(T entity); /**
* 设置为游离状态
*
* @param entity
* 实体对象
*/
void detach(T entity); /**
* 锁定实体对象
*
* @param entity
* 实体对象
* @param lockModeType
* 锁定方式
*/
void lock(T entity, LockModeType lockModeType); /**
* 清除缓存
*/
void clear(); /**
* 同步数据
*/
void flush();
}
3. BaseDaoImpl
package com.genius.han.dao.impl; import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type; import javax.persistence.EntityManager;
import javax.persistence.LockModeType;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import javax.transaction.Transactional; import org.springframework.util.Assert;
import org.springframework.util.StringUtils; import com.genius.han.dao.BaseDao; @Transactional
public class BaseDaoImpl<T, ID extends Serializable> implements BaseDao<T, ID> { private static final long serialVersionUID = 1L; private Class<T> entityClass; @PersistenceContext
protected EntityManager entityManager; @SuppressWarnings("unchecked")
public BaseDaoImpl()
{
Type type = getClass().getGenericSuperclass();
Type[] parameterizedType = ((ParameterizedType) type).getActualTypeArguments();
entityClass = (Class<T>) parameterizedType[0];
} @Override
public T find(ID id)
{
if (id != null)
{
return entityManager.find(entityClass, id);
}
return null;
} @Override
public T find(ID id, LockModeType lockModeType)
{
if (id != null)
{
if (lockModeType != null)
{
return entityManager.find(entityClass, id, lockModeType);
}
else
{
return entityManager.find(entityClass, id);
}
}
return null;
} @Override
public void persist(T entity)
{
Assert.notNull(entity);
entityManager.persist(entity); } @Override
public T merge(T entity)
{
Assert.notNull(entity);
return entityManager.merge(entity);
} @Override
public void remove(T entity)
{
Assert.notNull(entity);
if (entity != null)
{
entityManager.remove(entity);
}
} @Override
public Query createNativeQuery(String sql)
{
if (!StringUtils.isEmpty(sql))
{
return entityManager.createNativeQuery(sql);
}
return null;
} @Override
public void refresh(T entity)
{
Assert.notNull(entity);
if (entity != null)
{
entityManager.refresh(entity);
}
} @Override
public void refresh(T entity, LockModeType lockModeType)
{
Assert.notNull(entity);
if (entity != null)
{
if (lockModeType != null)
{
entityManager.refresh(entity, lockModeType);
}
else
{
entityManager.refresh(entity);
}
} } @SuppressWarnings("unchecked")
@Override
public ID getIdentifier(T entity)
{
Assert.notNull(entity);
if (entity != null)
{
return (ID) entityManager.getEntityManagerFactory().getPersistenceUnitUtil()
.getIdentifier(entity);
}
return null;
} @Override
public boolean isManaged(T entity)
{
Assert.notNull(entity);
if (entity != null)
{
return entityManager.contains(entity);
}
return false;
} @Override
public void detach(T entity)
{
Assert.notNull(entity);
if (entity != null)
{
entityManager.detach(entity);
}
} @Override
public void lock(T entity, LockModeType lockModeType)
{
Assert.notNull(entity);
Assert.notNull(lockModeType);
if (entity != null && lockModeType != null)
{
entityManager.lock(entity, lockModeType);
}
} @Override
public void clear()
{
entityManager.clear();
} @Override
public void flush()
{
entityManager.flush();
} }
4 Common Dao
import org.springframework.stereotype.Repository; @Repository
public class EmployeeDAO extends BaseDaoImpl<EmployeeEntity, Long> {
public void save(EmployeeEntity entity){
persist(entity);
}
}
5 BaseEntity
package com.genius.han.entity; import java.io.Serializable;
import java.util.Date; import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;
import javax.persistence.Temporal;
import javax.persistence.TemporalType; import org.hibernate.search.annotations.DateBridge;
import org.hibernate.search.annotations.DocumentId;
import org.hibernate.search.annotations.Field;
import org.hibernate.search.annotations.Index;
import org.hibernate.search.annotations.Resolution;
import org.hibernate.search.annotations.Store; @MappedSuperclass
public abstract class BaseEntity implements Serializable { private static final long serialVersionUID = -67188388306700736L; /** ID */
private Long id; /** 创建日期 */
private Date createDate = new Date(); /** 修改日期 */
private Date modifyDate = new Date(); /**
* 获取ID
*
* @return ID
*/ @DocumentId
@Id
// MySQL/SQLServer: @GeneratedValue(strategy = GenerationType.AUTO)
// Oracle: @GeneratedValue(strategy = GenerationType.AUTO, generator = "sequenceGenerator")
@GeneratedValue(strategy = GenerationType.AUTO)
public Long getId() {
return id;
} public void setId(Long id) {
this.id = id;
} @Field(store = Store.YES, index = Index.UN_TOKENIZED)
@DateBridge(resolution = Resolution.SECOND)
@Column(name="CREATE_DATE",nullable = false, updatable = false)
@Temporal(TemporalType.TIMESTAMP)
public Date getCreateDate() {
return createDate;
} public void setCreateDate(Date createDate) {
this.createDate = createDate;
} @Field(store = Store.YES, index = Index.UN_TOKENIZED)
@DateBridge(resolution = Resolution.SECOND)
@Column(name="MODIFY_DATE",nullable = false)
@Temporal(TemporalType.TIMESTAMP)
public Date getModifyDate() {
return modifyDate;
} public void setModifyDate(Date modifyDate) {
this.modifyDate = modifyDate;
} /**
* 重写equals方法
*
* @param obj
* 对象
* @return 是否相等
*/
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (this == obj) {
return true;
}
if (!BaseEntity.class.isAssignableFrom(obj.getClass())) {
return false;
}
BaseEntity other = (BaseEntity) obj;
return getId() != null ? getId().equals(other.getId()) : false;
} /**
* 重写hashCode方法
*
* @return hashCode
*/
@Override
public int hashCode() {
int hashCode = 17;
hashCode += null == getId() ? 0 : getId().hashCode() * 31;
return hashCode;
} }
6.Common Entity
package com.genius.han.entity; import javax.persistence.Entity;
import javax.persistence.Table; @Entity
@Table(name="customerInfo")
public class CustomerInfoEntity extends BaseEntity{ /**
*
*/
private static final long serialVersionUID = -7920396843754746995L;
private String name;
private String gender;
private String email;
private String mobile_num; public CustomerInfoEntity(String name, String gender, String email,
String mobile_num) {
super();
this.name = name;
this.gender = gender;
this.email = email;
this.mobile_num = mobile_num;
} public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getMobile_num() {
return mobile_num;
}
public void setMobile_num(String mobile_num) {
this.mobile_num = mobile_num;
}
}
SPRING+JPA+Hibernate配置方法的更多相关文章
- 【JPA】两种不同的实现jpa的配置方法
两种不同的实现jpa的配置方法 第一种: com.mchange.v2.c3p0.ComboPooledDataSource datasource.connection.driver_class=co ...
- 【spring boot hibernate】hibernate命名策略spring.jpa.hibernate.naming-strategy不起作用
对于 spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.ImprovedNamingStrategy hibernate命名策略设置之后 ...
- Spring JPA 简单配置使用
JPA 常用配置: # JPA (JpaBaseConfiguration, HibernateJpaAutoConfiguration) spring.data.jpa.repositories.b ...
- Spring JPA 定义查询方法
Spring JPA 定义查询方法 翻译:Defining Query Methods 存储库代理有两种方式基于方法名派生特定域的查询方式: 直接从方法名派生查询 自定义查询方式 可用选项基于 ...
- springmvc+spring+jpa(hibernate)+redis+maven配置
废话不多少 项目结构 pom.xml配置例如以下 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi=& ...
- Spring整合Hibernate的方法
一.基本支持 Spring 支持大多数流行的 ORM 框架, 包括 Hibernate JDO, TopLink, Ibatis 和 JPA. Spring 对这些 ORM 框架的支持是一致的, 因此 ...
- spring的事务配置方法
spring事务的配置有两种方式 1.xml配置的声明式事务配置 (1)配置数据源信息dataSource(使用阿里的数据源) <bean id="dataSource" c ...
- spring + springMVC +hibernate 配置2
这种方式比较精简 配置项不多 spring采用自动扫描配置 ,分spring_springMVC.xml . hibernate_config.xml 两个文件 web.xml配置如下 <?x ...
- Spring+Hibernate整合配置 --- 比较完整的spring、hibernate 配置
Spring+Hibernate整合配置 分类: J2EE2010-11-25 17:21 16667人阅读 评论(1) 收藏 举报 springhibernateclassactionservlet ...
随机推荐
- Linux权限简析
- Flink 配置文件详解
前面文章我们已经知道 Flink 是什么东西了,安装好 Flink 后,我们再来看下安装路径下的配置文件吧. 安装目录下主要有 flink-conf.yaml 配置.日志的配置文件.zk 配置.Fli ...
- error C3867: “std::basic_string<char,std::char_traits<char>,std::allocator<char>>::c_str”: 函数调用缺少参数列表;请使用“&std::basic_string<char,std::char_traits<char>,std::allocator<char>>::c_str”创建指向成员的指针
这个问题找了很多没有找到满意的答案.仔细看了一下,是使用了c_str的问题. 我直接把使用string.c_str的地方使用char*代替即解决问题.
- 移动APP和传统软件测试的区别[转载]
目录 1. 移动App比PC 上的程序测试要复杂 2. 移动APP测试中如何设计Test Case 3. 让自己成为真实的用户 4. 关注用户体验测试 5. 少做UI自动化,多做后台接口的自动化 6. ...
- c程序查找字符出现次数
#include <stdio.h> int main(){ char str[100],ch,M,Empty; int i, frequency = 0; fgets(str, (siz ...
- [已解决]windows安装docker的问题
windows下载安装docker出现的问题 进入powershell后输入docker --version报错: could not read CA certificate "C:\\Us ...
- 二维RMQ hdu 2888
题目:点这里 题意:给出一个n*m的矩阵,然后又Q个询问:每个询问有x1,y1,x2,y2,x1,y1为子矩阵的左上角坐标,x2,y2为右上角的坐标.求此子矩阵中元素最大值,判断最大值是否在子矩阵四个 ...
- S1#Python之shebang
点1 - Python之shebang 一. shebang 在计算机科学中,Shebang是一个由井号和叹号构成的字符串行,其出现在文本文件的第一行的前两个字符. 在文件中存在Shebang的情况下 ...
- Codeigniter设置时区
Codeigniter 3.x,在application/config/config.php 末尾加上 date_default_timezone_set("Asia/Shanghai&qu ...
- wp api jwt 403 (Forbidden) -- JWT is not configurated properly, please contact the admin
需要在 wp-config.php 文件中配置 define('JWT_AUTH_SECRET_KEY', 'your-top-secrect-key'); 參考 403 (Forbidden) -- ...