求教一个springspring jpa hibernatee jpa配置的问题

来源：蜘蛛抓取(WebSpider) 时间：2017-09-19 08:17 标签： spring配置hibernate5
温馨提示！由于新浪微博认证机制调整，您的新浪微博帐号绑定已过期，请重新绑定！&&|&&
LOFTER精选
网易考拉推荐
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
阅读(1739)|
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
历史上的今天
loftPermalink:'',
id:'fks_095067',
blogTitle:'SpringMVC+JPA（Hibernate）+Tiles案例 一SpringMVC配置（基于注解）',
blogAbstract:'
基于注解的好处是，MVC中的Controller可以由任意的bean来实现，更加灵活，
实体bean的封装更加灵活。
1.配置Mapping管理器
书写& bookstore-servlet.xml
&?xml version=\"1.0\" encoding=\"UTF-8\"?& &beans xmlns=\"
{if x.moveFrom=='wap'}
{elseif x.moveFrom=='iphone'}
{elseif x.moveFrom=='android'}
{elseif x.moveFrom=='mobile'}
${a.selfIntro|escape}{if great260}${suplement}{/if}
{list a as x}
推荐过这篇日志的人：
{list a as x}
{if !!b&&b.length>0}
他们还推荐了：
{list b as y}
转载记录：
{list d as x}
{list a as x}
{list a as x}
{list a as x}
{list a as x}
{if x_index>4}{break}{/if}
${fn2(x.publishTime,'yyyy-MM-dd HH:mm:ss')}
{list a as x}
{if !!(blogDetail.preBlogPermalink)}
{if !!(blogDetail.nextBlogPermalink)}
{list a as x}
{if defined('newslist')&&newslist.length>0}
{list newslist as x}
{if x_index>7}{break}{/if}
{list a as x}
{var first_option =}
{list x.voteDetailList as voteToOption}
{if voteToOption==1}
{if first_option==false},{/if}&&“${b[voteToOption_index]}”&&
{if (x.role!="-1") },“我是${c[x.role]}”&&{/if}
&&&&&&&&${fn1(x.voteTime)}
{if x.userName==''}{/if}
网易公司版权所有&&
{list x.l as y}
{if defined('wl')}
{list wl as x}{/list}<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
您的访问请求被拒绝 403 Forbidden - ITeye技术社区
您的访问请求被拒绝
亲爱的会员，您的IP地址所在网段被ITeye拒绝服务，这可能是以下两种情况导致：
一、您所在的网段内有网络爬虫大量抓取ITeye网页，为保证其他人流畅的访问ITeye，该网段被ITeye拒绝
二、您通过某个代理服务器访问ITeye网站，该代理服务器被网络爬虫利用，大量抓取ITeye网页
请您点击按钮解除封锁&　　本文的目标是采用基于Java配置的方式搭建Spring+SpringMVC+SpringData+JPA。本文只是简单的演示一下具体的配置，没有任何繁琐复杂的逻辑业务，目的是体验一下Spring无XML该如何配置。最后展示一下SpringData提供的分页封装类Page的效果。
&-Dfile.encoding=UTF-8&
&4.3.2.RELEASE&
&1.10.2.RELEASE&
&5.2.2.Final&
&5.2.4.Final&
&4.3.11.Final&
&4.3.2.Final&
&org.springframework&
&spring-webmvc&
&${spring.version}&
&javax.el&
&javax.el-api&
&javax.servlet.jsp.jstl&
&javax.servlet.jsp.jstl-api&
&javax.servlet.jsp&
&javax.servlet.jsp-api&
&javax.servlet&
&standard&
&javaee-web-api&
&provided&
&com.fasterxml.jackson.dataformat&
&jackson-dataformat-xml&
&${jackson.version}&
&org.aspectj&
&aspectjweaver&
&aopalliance&
&aopalliance&
&org.springframework&
&spring-test&
&${spring.version}&
&ch.qos.logback&
&logback-classic&
&org.slf4j&
&slf4j-api&
&org.logback-extensions&
&logback-ext-spring&
&ch.qos.logback&
&logback-classic&
&org.slf4j&
&jcl-over-slf4j&
&org.springframework&
&spring-orm&
&${spring.version}&
&com.alibaba&
&com.alibaba&
&jconsole&
&com.alibaba&
&mysql-connector-java&
&org.springframework.data&
&spring-data-jpa&
&${spring.data.version}&
&org.hibernate&
&hibernate-entitymanager&
&org.springframework&
&spring-beans&
&org.springframework&
&spring-context&
&org.springframework&
&spring-core&
&org.springframework&
&spring-tx&
&org.springframework&
&spring-aop&
&org.hibernate&
&hibernate-ehcache&
&${hibernate5.version}&
&org.slf4j&
&slf4j-api&
&javax.el&
&org.hibernate&
&hibernate-core&
&${hibernate5.version}&
&org.springframework&
&spring-context-support&
&${spring.version}&
&com.google.code.gson&
&org.projectlombok&
　　说明：本文所使用框架版本大多为作文时的最新版本，其中Spring版本为4.3.2.RELEASE，JPA规范版本为2.1，采用Hibernate 5.2.2.Final作为实现，SpringData采用1.10.2.RELEASE版本。要求Serlvet容器必须支持Servlet3.0及以上，即使用tomcat的话必须是7以上，使用jetty的话则必须是8以上。
　　首先是Spring的配置，主要配置数据源、entityManagerFactory、transactionManager等。
　　需要用到如下两个配置文件：
db.properties
mysql.url = jdbc:mysql:///springmvc
mysql.driverClassName = com.mysql.jdbc.Driver
mysql.username = root
mysql.password =
druid.minIdle = 1
druid.maxActive = 10
druid.testWhileIdle = false
hbm.properties
hibernate.dialect = org.hibernate.dialect.MySQL5InnoDBDialect
hibernate.show_sql = true
hibernate.format_sql = true
hibernate.hbm2ddl.auto = update
## 二级缓存
hibernate.cache.use_second_level_cache = true
hibernate.cache.region.factory_class = org.hibernate.cache.ehcache.EhCacheRegionFactory
hibernate.cache.provider_configuration_file_resource_path = classpath:cache/ehcache.xml
hibernate.cache.use_query_cache = true
# 只有使用 @javax.persistence.Cacheable 注解标注的实体能够被缓存
jpa.shared-cache-mode = ENABLE_SELECTIVE
　　SpringConfig应用上下文配置类，该类通常对应着applicationContext.xml文件
package org.junbin.spring.javaconfig.
import com.alibaba.druid.pool.DruidDataS
import org.hibernate.cfg.E
import org.springframework.beans.factory.annotation.V
import org.springframework.context.annotation.*;
import org.springframework.data.jpa.repository.config.EnableJpaR
import org.springframework.orm.jpa.JpaTransactionM
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryB
import org.springframework.orm.jpa.vendor.HibernateJpaVendorA
import org.springframework.stereotype.C
import org.springframework.transaction.annotation.EnableTransactionM
import org.springframework.web.bind.annotation.ControllerA
import javax.persistence.SharedCacheM
import java.util.HashM
import java.util.M
* : Chung Junbin
* : &a href="mailto:"&发送邮件&/a&
* 　　特别注意：在 Spring 主配置（称为应用上下文配置）类，千万不要基于根目录扫描整个目录，否则它会将 config 目录中的
* 其他配置类也扫描并实例化，此时使用 JUnit 测试非 Web 环境下时提示没有找到 Web 上下文，导致单元测试失败。
* 　　即建议/要求 {@link ComponentScan#basePackages()} 应该具体到 repository 和 service 等 Component 组件的
* 包路径，而不是包含两者的上级目录
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = false, exposeProxy = true)
@EnableTransactionManagement(proxyTargetClass = false)
@EnableJpaRepositories(basePackages = {"org.junbin.spring.javaconfig.repository"},
entityManagerFactoryRef = "entityManagerFactory",
transactionManagerRef = "transactionManager")
@PropertySource(encoding = "UTF-8", value = {"classpath:bundle/db.properties", "classpath:bundle/hbm.properties"})
@ComponentScan(basePackages = {"org.junbin.spring.javaconfig.repository", "org.junbin.spring.javaconfig.service"}, excludeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class, ControllerAdvice.class})
public class SpringConfig {
* 数据源配置
@Value(value = "${mysql.url}")
@Value(value = "${mysql.driverClassName}")
private String driverClassN
@Value(value = "${mysql.username}")
@Value(value = "${mysql.password}")
@Value(value = "${druid.minIdle}")
private int minI
@Value(value = "${druid.maxActive}")
private int maxA
@Value(value = "${druid.testWhileIdle}")
private boolean testWhileI
* JPA 规范的 Hibernate 实现
@Value(value = "${hibernate.show_sql}")
private boolean showS
@Value(value = "${hibernate.format_sql}")
private boolean formatS
@Value(value = "${hibernate.hbm2ddl.auto}")
private String hbm2
@Value(value = "${hibernate.dialect}")
* 二级缓存
@Value(value = "${hibernate.cache.use_second_level_cache}")
private boolean useSecondLevelC
@Value(value = "${hibernate.cache.region.factory_class}")
private String cacheRegionF
@Value(value = "${hibernate.cache.provider_configuration_file_resource_path}")
private String cacheProviderConfigL
@Value(value = "${hibernate.cache.use_query_cache}")
private boolean useQueryC
@Value(value = "${jpa.shared-cache-mode}")
private String sharedCacheM
@Bean(name = "dataSource", initMethod = "init", destroyMethod = "close")
public DruidDataSource dataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setUrl(url);
dataSource.setDriverClassName(driverClassName);
dataSource.setUsername(username);
dataSource.setPassword(password);
dataSource.setMinIdle(minIdle);
dataSource.setMaxActive(maxActive);
dataSource.setTestWhileIdle(testWhileIdle);
return dataS
@Bean(name = "entityManagerFactory")
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
LocalContainerEntityManagerFactoryBean factoryBean = new
LocalContainerEntityManagerFactoryBean();
factoryBean.setDataSource(dataSource());
factoryBean.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
factoryBean.setPackagesToScan("org.junbin.spring.javaconfig.domain", "org.junbin.spring.javaconfig.converter.jpa");
Map&String, Object& jpaPropertyMap = new HashMap&&();
jpaPropertyMap.put(Environment.DIALECT, dialect);
jpaPropertyMap.put(Environment.SHOW_SQL, showSql);
jpaPropertyMap.put(Environment.FORMAT_SQL, formatSql);
jpaPropertyMap.put(Environment.HBM2DDL_AUTO, hbm2ddl);
jpaPropertyMap.put(Environment.USE_SECOND_LEVEL_CACHE, useSecondLevelCache);
jpaPropertyMap.put(Environment.CACHE_REGION_FACTORY, cacheRegionFactory);
jpaPropertyMap.put(Environment.CACHE_PROVIDER_CONFIG, cacheProviderConfigLocation);
jpaPropertyMap.put(Environment.USE_QUERY_CACHE, useQueryCache);
factoryBean.setJpaPropertyMap(jpaPropertyMap);
factoryBean.setSharedCacheMode(SharedCacheMode.valueOf(sharedCacheMode));
return factoryB
@Bean(name = "transactionManager")
public JpaTransactionManager transactionManager() {
return new JpaTransactionManager(entityManagerFactory().getObject());
　　配置SpringMVC，主要配置视图解析器以及配置静态资源映射。
　　SpringMVC Web上下文配置类，该类通常对应着serlvet-spring4mvc.xml配置文件
package org.junbin.spring.javaconfig.
import org.springframework.context.annotation.B
import org.springframework.ponentS
import org.springframework.context.annotation.C
import org.springframework.context.annotation.FilterT
import org.springframework.stereotype.C
import org.springframework.web.bind.annotation.ControllerA
import org.springframework.web.servlet.ViewR
import org.springframework.web.servlet.config.annotation.*;
import org.springframework.web.servlet.view.InternalResourceViewR
import org.springframework.web.servlet.view.JstlV
* : Chung Junbin
* : &a href="mailto:"&发送邮件&/a&
* 　　不使用 {@link EnableWebMvc} 注解而是直接继承于 {@link WebMvcConfigurationSupport} 或者
* {@link DelegatingWebMvcConfiguration}，之后通过覆盖方法可以实现更多可选功能
@Configuration
@ComponentScan(basePackages = {"org.junbin.spring.javaconfig.controller"}, useDefaultFilters = false,
includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {
Controller.class, ControllerAdvice.class
public class SpringMvcConfig extends WebMvcConfigurationSupport {
private static final String resourceHandler = "/resources/**";
private static final String resourceLocation = "/resources/";
@Bean(name = "viewResolver")
public ViewResolver viewResolver() {
InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
viewResolver.setPrefix("/WEB-INF/views/");
viewResolver.setSuffix(".jsp");
viewResolver.setViewClass(JstlView.class);
viewResolver.setContentType("text/ charset=UTF-8");
return viewR
protected void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler(resourceHandler).addResourceLocations(resourceLocation);
protected void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
configurer.enable();
　　接下来针对web.xml的配置类，前面之所以要求使用支持Servlet3.0以上的容器是因为这里我们将不使用web.xml配置文件，全部采用基于Java的方法来配置Servlet、Filter、Listener。
　　这里主要要配置logback的监听器、UTF-8的字符编码过滤器以及OpenEntityManagerInViewFilter。
　　WebXmlConfig配置类
package org.junbin.spring.javaconfig.
import ch.qos.logback.ext.spring.web.LogbackConfigL
import org.springframework.orm.jpa.support.OpenEntityManagerInViewF
import org.springframework.web.WebApplicationI
import org.springframework.web.filter.CharacterEncodingF
import javax.servlet.DispatcherT
import javax.servlet.FilterR
import javax.servlet.ServletC
import javax.servlet.ServletE
import java.util.EnumS
* : Chung Junbin
* : &a href="mailto:"&发送邮件&/a&
public class WebXmlConfig implements WebApplicationInitializer {
public void onStartup(ServletContext servletContext) throws ServletException {
servletContext.setInitParameter("logbackConfigLocation", "classpath:logback/logback.xml");
servletContext.addListener(LogbackConfigListener.class);
CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter("UTF-8", true);
FilterRegistration.Dynamic characterEncodingConfig = servletContext.addFilter(
"characterEncodingFilter", characterEncodingFilter
characterEncodingConfig.addMappingForUrlPatterns(
EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD, DispatcherType.INCLUDE),
OpenEntityManagerInViewFilter openEntityManagerInViewFilter = new OpenEntityManagerInViewFilter();
FilterRegistration.Dynamic openEntityManagerInViewConfig = servletContext.addFilter(
"openEntityManagerInViewFilter", openEntityManagerInViewFilter);
openEntityManagerInViewConfig.addMappingForUrlPatterns(
EnumSet.of(DispatcherType.FORWARD, DispatcherType.INCLUDE, DispatcherType.REQUEST),
　　在上面的配置中，我们并没有配置SpringMVC的DispatcherServlet，原因是DispatcherServlet比较特殊，我们可以通过继承WebApplicationInitializer的抽象实现类AbstractAnnotationConfigDispatcherServletInitializer来配置它。
　　WebInitializer类
package org.junbin.spring.javaconfig.
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletI
* : Chung Junbin
* : &a href="mailto:"&发送邮件&/a&
public class WebInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
* 　　配置 Spring 的 {@link org.springframework.web.servlet.DispatcherServlet}
* 的 {@code url-pattern}
protected String[] getServletMappings() {
return new String[]{"/"};
* 　　配置应用上下文，即所有不包括 SpringMVC 等 Web 配置之外的所有配置，
* 比如：Spring、Hibernate、AOP 等的配置类
protected Class&?&[] getRootConfigClasses() {
return new Class&?&[]{SpringConfig.class};
* 　　配置 SpringMVC 等 Web 上下文
protected Class&?&[] getServletConfigClasses() {
return new Class&?&[]{SpringMvcConfig.class};
　　接下来演示一下分页功能，首先创建User实体类。
package org.junbin.spring.javaconfig.
import javax.persistence.*;
import java.io.S
import java.time.LocalDateT
* : Chung Junbin
* : &a href="mailto:"&发送邮件&/a&
@Table(name = "user")
@Cacheable
public class User implements Serializable {
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "id", nullable = false, updatable = false)
private int
@Column(name = "username")
@Column(name = "create_time")
private LocalDateTime createT
@Column(name = "valid")
private boolean valid = true;
public User() {
public User(String username, LocalDateTime createTime) {
this.username =
this.createTime = createT
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", createTime=" + createTime +
", valid=" + valid +
public int getId() {
public void setId(int id) {
public String getUsername() {
public void setUsername(String username) {
this.username =
public LocalDateTime getCreateTime() {
return createT
public void setCreateTime(LocalDateTime createTime) {
this.createTime = createT
public boolean isValid() {
public void setValid(boolean valid) {
this.valid =
　　Repository接口，相当于DAO接口，但是使用SpringData时建议命名为Repository而不是DAO。
package org.junbin.spring.javaconfig.
import org.junbin.spring.javaconfig.domain.U
import org.springframework.data.jpa.repository.JpaR
* : Chung Junbin
* : &a href="mailto:"&发送邮件&/a&
public interface UserRepository extends JpaRepository&User, Integer& {
　　我们只需要简单声明接口即可，SpringData会自动生成相应的实现类。
　　跳过Service业务类，接下来是Controller类
package org.junbin.spring.javaconfig.
import com.google.gson.G
import com.google.gson.GsonB
import org.junbin.spring.javaconfig.converter.gson.GsonLocalDateTimeC
import org.junbin.spring.javaconfig.domain.U
import org.junbin.spring.javaconfig.service.IUserS
import org.springframework.beans.factory.annotation.A
import org.springframework.beans.factory.annotation.Q
import org.springframework.data.domain.P
import org.springframework.data.domain.PageR
import org.springframework.data.domain.P
import org.springframework.format.annotation.DateTimeF
import org.springframework.stereotype.C
import org.springframework.ui.M
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndV
import java.time.LocalDateT
* : Chung Junbin
* : &a href="mailto:"&发送邮件&/a&
@Controller
@RequestMapping(value = "/user")
public class UserController {
@Autowired
@Qualifier(value = "userService")
private IUserService userS
private final Gson gson = new GsonBuilder()
.registerTypeAdapter(LocalDateTime.class, new GsonLocalDateTimeConverter())
.create();
@RequestMapping(value = "/add", method = RequestMethod.GET)
public ModelAndView add(@RequestParam(value = "name") String name,
@RequestParam(value = "createTime")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime now) {
userService.save(new User(name, now));
return null;
@RequestMapping(value = "/add/and/show", method = RequestMethod.GET)
public String addRedirect(@RequestParam(value = "name") String name,
@RequestParam(value = "createTime")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime now) {
User user = userService.save(new User(name, now));
return "redirect:/user/" + user.getId() + "/show";
@RequestMapping(value = "/{id:\\d+}/delete", method = RequestMethod.GET)
@ResponseBody
public String delete(@PathVariable(value = "id") int id) {
userService.delete(id);
return "{\"status\":200}";
@RequestMapping(value = "/{id:\\d+}/show", method = RequestMethod.GET)
@ResponseBody
public String show(@PathVariable(value = "id") int id) {
return gson.toJson(userService.findOne(id));
@RequestMapping(value = "/page/{pageOffset:\\d+}/{pageSize:\\d+}", method = RequestMethod.GET)
public String page(@PathVariable(value = "pageOffset") int pageOffset,
@PathVariable(value = "pageSize") int pageSize,
Model model) {
Pageable pageable = new PageRequest(pageOffset, pageSize);
Page&User& userPage = userService.find(pageable);
model.addAttribute("page", userPage);
return "page";
　　自己在数据库中插入一些数据或者使用SpringData提供的批量插入方法或者使用上面Controller提供的GET请求插入数据后，我们访问http://localhost/user/page/0/10即可显示分页信息。如下图：
　　写作本文只是对Spring知识的一个补充，基于Java配置看起来虽然很不错，但是实际上个人并不是十分推崇这种做法。
　　首先，IDEA对基于Java配置的Spring处理的效果比基于XML配置的Spring差很多，比如代码提示——很多快捷的代码提示（诸如视图解析等）没有起作用；比如主动注入——我的IDEA上在注入UserRepository时提示没有找到合适的Bean；还有一些其他的问题。
　　其次，Hibernate（JPA规范的实现厂商）对主键生成策略AUTO的实现很奇怪，明明已经指定方言为MySQL了，它依然在生成主键时依然与Hibernate自动生成的一张存储主键的表（当然，有可能是因为Hibernate5对主键生成策略的实现不同！）。见下图，自动生成了一个hibernate_sequence的表来存储user表的主键值。
　　最后，一些Spring的其他功能在基于Java配置时不起作用，比如自定义的PropertyEditor，当然包括Spring原生的PropertyEditor也不起作用了，因为根本就不需要用到这些配置。从另一方面也可以看成是好处。
原创声明：
本文为个人原创，如有错误与不妥，欢迎提出！
另外，未经许可，谢绝转载。
源码地址1：
源码地址2：
编写日期：
发布日期：
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：4867次
排名：千里之外
(window.slotbydup = window.slotbydup || []).push({
id: '4740881',
container: s,
size: '200,200',
display: 'inlay-fix'1.applicationContext.xml
1 &?xml version="1.0" encoding="UTF-8"?&
2 &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"&
12 &!-- 扫描目录 --&
&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.boPooledDataSource"
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 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" /&
&/property&
&property name="jpaProperties"&
&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&
&/property&
&bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"&
&property name="entityManagerFactory" ref="entityManagerFactory" /&
&!-- 配置 Annotation 驱动，定义事务 --&
&tx:annotation-driven transaction-manager="transactionManager"
proxy-target-class="false" /&
72 &/beans&
jdbc.properties
1 jdbc.driver=com.mysql.jdbc.Driver
2 jdbc.url=jdbc:mysql://localhost:3306/han?useUnicode=true&characterEncoding=UTF-8
3 jdbc.username=xxxx 4 jdbc.password=xxxx
7 #------------ ConnectionPools ------------
8 connection_pools.initial_pool_size=5
9 connection_pools.min_pool_size=5
10 connection_pools.max_pool_size=100
11 connection_pools.max_idle_time=600
12 connection_pools.acquire_increment=5
13 connection_pools.checkout_timeout=60000
16 hibernate.dialect=org.hibernate.dialect.MySQLDialect
17 hibernate.current_session_context_class=thread
18 hibernate.hbm2ddl.auto=update
19 hibernate.show_sql=true
20 hibernate.format_sql=false
21 hibernate.query.substitutions=Y
23 hibernate.cache.use_second_level_cache=false
24 hibernate.cache.region.factory_class=org.hibernate.cache.impl.NoCachingRegionFactory
25 hibernate.cache.use_query_cache=false
26 hibernate.jdbc.fetch_size=50
27 hibernate.jdbc.batch_size=30
2. BaseDao
1 import java.io.S
3 import javax.persistence.LockModeT
4 import javax.persistence.Q
6 public interface BaseDao&T,ID extends Serializable& extends Serializable{
* 查找实体对象
* @param id
* @return 实体对象，若不存在则返回null
T find(ID id);
* 查找实体对象
* @param 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
1 package com.genius.han.dao.
3 import java.io.S
4 import java.lang.reflect.ParameterizedT
5 import java.lang.reflect.T
7 import javax.persistence.EntityM
8 import javax.persistence.LockModeT
9 import javax.persistence.PersistenceC
10 import javax.persistence.Q
11 import javax.transaction.T
13 import org.springframework.util.A
14 import org.springframework.util.StringU
16 import com.genius.han.dao.BaseD
18 @Transactional
19 public class BaseDaoImpl&T, ID extends Serializable& implements BaseDao&T, ID& {
private static final long serialVersionUID = 1L;
private Class&T& entityC
@PersistenceContext
protected EntityManager entityM
@SuppressWarnings("unchecked")
public BaseDaoImpl()
Type type = getClass().getGenericSuperclass();
Type[] parameterizedType = ((ParameterizedType) type).getActualTypeArguments();
entityClass = (Class&T&) parameterizedType[0];
public T find(ID id)
if (id != null)
return entityManager.find(entityClass, id);
return null;
public T find(ID id, LockModeType lockModeType)
if (id != null)
if (lockModeType != null)
return entityManager.find(entityClass, id, lockModeType);
return entityManager.find(entityClass, id);
return null;
public void persist(T entity)
Assert.notNull(entity);
entityManager.persist(entity);
public T merge(T entity)
Assert.notNull(entity);
return entityManager.merge(entity);
public void remove(T entity)
Assert.notNull(entity);
if (entity != null)
entityManager.remove(entity);
public Query createNativeQuery(String sql)
if (!StringUtils.isEmpty(sql))
return entityManager.createNativeQuery(sql);
return null;
public void refresh(T entity)
Assert.notNull(entity);
if (entity != null)
entityManager.refresh(entity);
public void refresh(T entity, LockModeType lockModeType)
Assert.notNull(entity);
if (entity != null)
if (lockModeType != null)
entityManager.refresh(entity, lockModeType);
entityManager.refresh(entity);
@SuppressWarnings("unchecked")
public ID getIdentifier(T entity)
Assert.notNull(entity);
if (entity != null)
return (ID) entityManager.getEntityManagerFactory().getPersistenceUnitUtil()
.getIdentifier(entity);
return null;
public boolean isManaged(T entity)
Assert.notNull(entity);
if (entity != null)
return entityManager.contains(entity);
return false;
public void detach(T entity)
Assert.notNull(entity);
if (entity != null)
entityManager.detach(entity);
public void lock(T entity, LockModeType lockModeType)
Assert.notNull(entity);
Assert.notNull(lockModeType);
if (entity != null && lockModeType != null)
entityManager.lock(entity, lockModeType);
public void clear()
entityManager.clear();
public void flush()
entityManager.flush();
4 Common Dao
1 import org.springframework.stereotype.R
4 @Repository
5 public class EmployeeDAO extends BaseDaoImpl&EmployeeEntity, Long&
public void save(EmployeeEntity entity){
persist(entity);
5 BaseEntity
1 package com.genius.han.
4 import java.io.S
5 import java.util.D
7 import javax.persistence.C
8 import javax.persistence.GeneratedV
9 import javax.persistence.GenerationT
10 import javax.persistence.Id;
11 import javax.persistence.MappedS
12 import javax.persistence.T
13 import javax.persistence.TemporalT
19 import org.hibernate.search.annotations.DateB
20 import org.hibernate.search.annotations.DocumentId;
21 import org.hibernate.search.annotations.F
22 import org.hibernate.search.annotations.I
23 import org.hibernate.search.annotations.R
24 import org.hibernate.search.annotations.S
29 @MappedSuperclass
30 public abstract class BaseEntity implements Serializable {
private static final long serialVersionUID = -00736L;
/** 创建日期 */
private Date createDate = new Date();
/** 修改日期 */
private Date modifyDate = new Date();
* @return ID
@DocumentId
// MySQL/SQLServer: @GeneratedValue(strategy = GenerationType.AUTO)
// Oracle: @GeneratedValue(strategy = GenerationType.AUTO, generator = "sequenceGenerator")
@GeneratedValue(strategy = GenerationType.AUTO)
public Long getId() {
public void setId(Long 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 createD
public void setCreateDate(Date createDate) {
this.createDate = createD
@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 modifyD
public void setModifyDate(Date modifyDate) {
this.modifyDate = modifyD
* 重写equals方法
* @param obj
* @return 是否相等
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)
return getId() != null ? getId().equals(other.getId()) : false;
* 重写hashCode方法
* @return hashCode
public int hashCode() {
int hashCode = 17;
hashCode += null == getId() ? 0 : getId().hashCode() * 31;
return hashC
&mon Entity
1 package com.genius.han.
3 import javax.persistence.E
4 import javax.persistence.T
7 @Table(name="customerInfo")
8 public class CustomerInfoEntity extends BaseEntity{
private static final long serialVersionUID = -4746995L;
private String mobile_
public CustomerInfoEntity(String name, String gender, String email,
String mobile_num) {
this.name =
this.gender =
this.email =
this.mobile_num = mobile_
public String getName() {
public void setName(String name) {
this.name =
public String getGender() {
public void setGender(String gender) {
this.gender =
public String getEmail() {
public void setEmail(String email) {
this.email =
public String getMobile_num() {
return mobile_
public void setMobile_num(String mobile_num) {
this.mobile_num = mobile_
阅读(...) 评论()

我要回帖

更多关于 spring配置hibernate5 的文章

 

随机推荐