SPRING-DATA-JPA 全局DAO配置

最新推荐文章于 2023-05-16 22:00:10 发布
最新推荐文章于 2023-05-16 22:00:10 发布
阅读量1.2w 收藏 4
点赞数 3
分类专栏： 事务-SpringDataJpa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z69183787/article/details/42528397
版权

配置文件：spring-jpa.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"
	xmlns:c="http://www.springframework.org/schema/c" xmlns:util="http://www.springframework.org/schema/util"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">

	<!--
		BoneCP教程见http://www.cnblogs.com/zhwl/archive/2013/07/23/3208550.html
	-->

	
	<!-- JPA实体管理器工厂 -->
	<bean id="entityManagerFactory"
		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="dataSource" ref="${springJPA.dataSource}" />
		<property name="persistenceProvider" ref="persistenceProvider" />
		<property name="jpaVendorAdapter" ref="jpaVendorAdapter" />
		<property name="jpaDialect" ref="jpaDialect" />
		<property name="packagesToScan" value="${springJPA.packagesToScan}" />
		<property name="jpaProperties">
			<props>
				<prop key="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</prop>
				<prop key="hibernate.connection.driver_class">oracle.jdbc.OracleDriver</prop>
				<prop key="hibernate.max_fetch_depth">3</prop>
				<prop key="hibernate.jdbc.fetch_size">18</prop>
				<prop key="hibernate.jdbc.batch_size">10</prop>
				<prop key="hibernate.hbm2ddl.auto">${springJPA.jpaProperties.hibernate.hbm2ddl.auto}</prop>
				<prop key="hibernate.show_sql">false</prop>
				<prop key="hibernate.format_sql">false</prop>
				<prop key="javax.persistence.validation.mode">none</prop>
				<!-- 查询缓存 -->
				<prop key="hibernate.cache.use_query_cache">true</prop> 
				<prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</prop>
				<!--若为ALL，则默认全部开启二级缓存 ，实体上的@cacheable都不用打-->
				<prop key="javax.persistence.sharedCache.mode">ENABLE_SELECTIVE</prop>
				<prop key="hibernate.generate_statistics">true</prop>
			</props>
		</property>
	</bean>

	
	<!-- 用于指定持久化实现厂商类 -->
	<bean id="persistenceProvider" class="org.hibernate.ejb.HibernatePersistence" />
	
	<!-- 用于设置JPA实现厂商的特定属性 -->
	<bean id="jpaVendorAdapter" class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
		<property name="database" value="${springJPA.jpaVendorAdapter.database}" />
	</bean>
	
	<!-- 用于指定一些高级特性 -->
	<bean id="jpaDialect" class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
	
	<!-- 事务管理器 -->
	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory" />
	</bean>


	
	<!-- 启用 annotation事务-->
	<tx:annotation-driven />

	<!-- 配置Spring Data JPA扫描目录-->
	<jpa:repositories base-package="com.wonders.**.dao"
		entity-manager-factory-ref="entityManagerFactory"
		transaction-manager-ref="transactionManager"
		repository-impl-postfix="Impl"
		factory-class="com.wonders.frame.core.dao.DefaultRepositoryFactoryBean">
	</jpa:repositories>


</beans>

工厂bean：DefaultRepositoryFactoryBean 

/**
 * 
 */
package com.wonders.frame.core.dao;
import java.io.Serializable;
import javax.persistence.EntityManager;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.support.JpaRepositoryFactoryBean;
import org.springframework.data.repository.core.support.RepositoryFactorySupport;

/**
 *
 *
 */
public class DefaultRepositoryFactoryBean<T extends JpaRepository<S, ID>, S, ID extends Serializable>
		extends JpaRepositoryFactoryBean<T, S, ID> {
	/**
     * Returns a {@link RepositoryFactorySupport}.
     *
     * @param entityManager
     * @return
     */
	protected RepositoryFactorySupport createRepositoryFactory(EntityManager entityManager) {
 
    	return new DefaultRepositoryFactory(entityManager);
    }
}

工厂类：DefaultRepositoryFactory 

package com.wonders.frame.core.dao;

import java.io.Serializable;

import javax.persistence.EntityManager;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.support.JpaEntityInformation;
import org.springframework.data.jpa.repository.support.JpaRepositoryFactory;
import org.springframework.data.querydsl.QueryDslPredicateExecutor;
import org.springframework.data.querydsl.QueryDslUtils;
import org.springframework.data.repository.core.RepositoryMetadata;
import org.springframework.util.Assert;

import com.wonders.frame.core.dao.impl.GenericRepositoryImpl;

/**
 * 
 *
 */
public class DefaultRepositoryFactory extends JpaRepositoryFactory {

	private final EntityManager entityManager;
    
	public DefaultRepositoryFactory(EntityManager entityManager) {
		super(entityManager);
		Assert.notNull(entityManager);
		this.entityManager = entityManager;
		
	}
	
	@Override
	protected <T, ID extends Serializable> JpaRepository<?, ?> getTargetRepository(RepositoryMetadata metadata, EntityManager entityManager) {

		//TODO
		JpaEntityInformation<?, Serializable> entityInformation = getEntityInformation(metadata.getDomainClass());
		return new GenericRepositoryImpl(entityInformation, entityManager); // custom implementation
	}
  
    @Override
    protected Class<?> getRepositoryBaseClass(RepositoryMetadata metadata) {
 
    	return GenericRepositoryImpl.class;
    }
}

自定义扩展接口：GenericRepository 

package com.wonders.frame.core.dao;

import java.io.Serializable;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;

import javax.persistence.Query;

import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.NoRepositoryBean;
import org.springframework.transaction.annotation.Transactional;

import com.wonders.frame.core.model.vo.SimplePage;



/**

 * @

 * 针对spring data jpa所提供的接口{@link JpaRepository}再次扩展

 * @NoRepositoryBean是必须的

 */

@NoRepositoryBean
public interface GenericRepository<T, ID extends Serializable> 
	extends JpaRepository<T, ID>,JpaSpecificationExecutor<T> {
	
	List<T> findAll(HashMap<String,Object> queryParams,
			LinkedHashMap<String, String> orderby);


	SimplePage<T> findByPage(HashMap<String,Object> queryParams,
			LinkedHashMap<String, String> orderby, Integer pageSize,Integer pageNum);
	
	SimplePage<T> findByPageWithSql(String sql,
			HashMap<String, Object> queryParams, Integer pageSize,
			Integer pageNum);

	SimplePage<T> findByPageWithWhereHql(String whereHql,
			HashMap<String, Object> queryParams, Integer pageSize,
			Integer pageNum);


	SimplePage<T> findByPage(HashMap<String, Object> queryParams,
			String orderby, Integer pageSize, Integer pageNum);

	/**
	 * 
	 * 根据sql语句查询，结果是实体的集合
	 * 
	 * @param sql
	 * 
	 * @param entityClass
	 * 
	 * @return
	 */

	public List<T> findAllBySql(Class<T> entityClass, String sql);
	
	public String getUniqueResultBySql(String sql,HashMap<String,Object> queryParams);
	
	//public List<T> findByAttachIds(String[] ids);
	
//	@Transactional
//	public void updateModelNameAndModelId(String modelName, Integer modelId, String[] ids);
}


自定义扩展实现类：GenericRepositoryImpl ，其中的其他方法都是全局共享方法，即每个继承自定义扩展接口的用户接口均可使用这些函数 

package com.wonders.frame.core.dao.impl;

import java.io.Serializable;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.Query;

import org.apache.log4j.Logger;
import org.springframework.data.jpa.repository.support.JpaEntityInformation;
import org.springframework.data.jpa.repository.support.JpaEntityInformationSupport;
import org.springframework.data.jpa.repository.support.SimpleJpaRepository;
import org.springframework.data.repository.NoRepositoryBean;
import org.springframework.data.repository.query.Param;
import org.springframework.transaction.annotation.Transactional;

import com.wonders.frame.core.dao.GenericRepository;
import com.wonders.frame.core.model.vo.PageInfo;
import com.wonders.frame.core.model.vo.SimplePage;
import com.wonders.frame.core.utils.ReflectUtil;



/**
 * {@link GenericRepository}接口实现类，并在{@link SimpleJpaRepository}基础上扩展。
 * @param <T> ORM对象
 * @param <ID> 主键ID	
 */
@NoRepositoryBean   // 必须的
public class GenericRepositoryImpl<T, ID extends Serializable> extends
		SimpleJpaRepository<T, ID> implements GenericRepository<T, ID> {

	static Logger logger = Logger.getLogger(GenericRepositoryImpl.class);
    private final EntityManager em;
    private final Class<T> entityClass;
    private final String entityName;
    

	/**
	 * 构造函数
     * @param domainClass
     * @param em
     */
	public GenericRepositoryImpl(final JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager) {
		
		super(entityInformation, entityManager);
		this.em = entityManager;
		this.entityClass=entityInformation.getJavaType();
		this.entityName=entityInformation.getEntityName();
	}
	
	/**
	 * 构造函数
	 * @param domainClass
	 * @param em
	 */
	public GenericRepositoryImpl(Class<T> domainClass, EntityManager em) {
        this(JpaEntityInformationSupport.getMetadata(domainClass, em), em); 
    }
	
	@Override
    public List<T> findAll(HashMap<String,Object> queryParams,
    		LinkedHashMap<String, String> orderby){        
		 
		String whereHql=buildWhereQuery(queryParams);
		String orderHql=buildOrderby(orderby);
	
		String hql = "select o from "+entityName+" o where o.removed=0"; 
		Query query=createQuery(hql+whereHql+orderHql,queryParams);

		List<T> list=(List<T>)query.getResultList();
		return list;    
	}
	
    
    @Override
	public SimplePage<T> findByPage(HashMap<String,Object> queryParams,
			LinkedHashMap<String, String> orderby, Integer pageSize,Integer pageNum) {
    	
    	return findByPage(queryParams,buildOrderby(orderby), pageSize, pageNum);

	}
    @Override
    public SimplePage<T> findByPage(HashMap<String,Object> queryParams,
			String orderby, Integer pageSize,Integer pageNum) {
               		 
		String whereHql=buildWhereQuery(queryParams);
		String orderHql=orderby;
		
		String hql="select count(*) from "+ entityName+ " o where o.removed=0 "; 
		Query query=createQuery(hql+whereHql+orderHql,queryParams);
		PageInfo pageInfo=new PageInfo(((Long)query.getSingleResult()).intValue(),pageSize);
		pageInfo.refresh(pageNum);
        

        hql = "select o from "+ entityName+ " o where o.removed=0 ";
        query=createQuery(hql+whereHql+orderHql,queryParams);
        query.setFirstResult(pageInfo.getStartRecord()).setMaxResults(pageInfo.getPageSize());  

        return new SimplePage<T>(pageInfo,query.getResultList());
	}
    
    private Query createQuery(String hql,HashMap<String,Object> queryParams){
    	Query query = em.createQuery(hql);
		setQueryParams(query, queryParams);
		return query;
    }
	@Override
	public SimplePage<T> findByPageWithWhereHql(String whereHql, HashMap<String,Object> queryParams, Integer pageSize,Integer pageNum) {
        
		String hql="select count(*) from "+ entityName+ " o where o.removed=0 ";  
		if(whereHql==null){
			whereHql="";
		}

		Query query = em.createQuery(hql+whereHql);
		setQueryParams(query, queryParams);
		PageInfo pageInfo=new PageInfo(((Long)query.getSingleResult()).intValue(),pageSize);
		pageInfo.refresh(pageNum);
        

        hql = "select o from "+ entityName+ " o where o.removed=0 ";
        query = em.createQuery(hql+whereHql);        
        setQueryParams(query, queryParams);
        query.setFirstResult(pageInfo.getStartRecord()).setMaxResults(pageInfo.getPageSize());  

        return new SimplePage<T>(pageInfo,query.getResultList());
	}
	
	@Override
	public SimplePage<T> findByPageWithSql(String sql, HashMap<String,Object> queryParams, Integer pageSize,Integer pageNum) {

		Query query = em.createNativeQuery("select count(*) from ("+sql+")");  
		setQueryParams(query, queryParams);
		
		PageInfo pageInfo=new PageInfo(((Long)query.getSingleResult()).intValue(),pageSize);
		pageInfo.refresh(pageNum);
		
		query = em.createNativeQuery(sql);
		setQueryParams(query, queryParams);
        query.setFirstResult(pageInfo.getStartRecord()).setMaxResults(pageInfo.getPageSize());  

		return new SimplePage<T>(pageInfo,query.getResultList());
	}
	
	private void setQueryParams(Query query, HashMap<String, Object> queryParams){
		if(queryParams!=null && queryParams.size()>0){
			for(String key : queryParams.keySet()){
				Class clazz=ReflectUtil.getFieldType(this.entityClass, key.replaceAll("_s","").replaceAll("_e", "").replaceAll("_in", ""));
				if(clazz!=null && clazz.equals(String.class) && !key.endsWith("_in")){
					query.setParameter(key, '%'+queryParams.get(key).toString()+'%');
				}else{
					query.setParameter(key, queryParams.get(key));
				}

			}
		}
	}

	private String buildOrderby(LinkedHashMap<String, String> orderby) {
		// TODO Auto-generated method stub
		StringBuffer orderbyql = new StringBuffer("");
		if(orderby!=null && orderby.size()>0){
			orderbyql.append(" order by ");
			for(String key : orderby.keySet()){
				orderbyql.append("o.").append(key).append(" ").append(orderby.get(key)).append(",");
			}
			orderbyql.deleteCharAt(orderbyql.length()-1);
		}
		
		return orderbyql.toString();
	}
	
	private String buildWhereQuery(HashMap<String, Object> queryParams) {
		// TODO Auto-generated method stub
		StringBuffer whereQueryHql = new StringBuffer("");
		if(queryParams!=null && queryParams.size()>0){
			for(String key : queryParams.keySet()){
//				if(key.equalsIgnoreCase("id")){
//					whereQueryHql.append(" and ").append("o.").append(key).append(" in(:").append(key).append(")");
//				}else 
				if(key.endsWith("_s")){
					whereQueryHql.append(" and ").append("o.").append(key.replace("_s", "")).append(" >=:").append(key);
				}else if(key.endsWith("_e")){
					whereQueryHql.append(" and ").append("o.").append(key.replace("_e", "")).append(" <=:").append(key);
				}else if(key.endsWith("_in")){
					whereQueryHql.append(" and ").append("o.").append(key.replace("_in", "")).append(" in:").append(key);
				}else{
					Class clazz=ReflectUtil.getFieldType(this.entityClass, key);
					if(clazz!=null && clazz.equals(String.class)){
						whereQueryHql.append(" and ").append("o.").append(key).append(" like :").append(key);
					}else{
						whereQueryHql.append(" and ").append("o.").append(key).append(" =:").append(key);
					}
					
				}
			}
		}
		
		return whereQueryHql.toString();
	}

	@Override
	public List<T> findAllBySql(Class<T> entityClass, String sql) {
          //创建原生SQL查询QUERY实例,指定了返回的实体类型
          Query query =  em.createNativeQuery(sql,entityClass);
          //执行查询，返回的是实体列表,
          List<T> EntityList = query.getResultList();
		return EntityList;
	}

	public String getUniqueResultBySql(String sql,HashMap<String,Object> queryParams){
		Query query =  em.createNativeQuery(sql);
		for(String key : queryParams.keySet()){
			query.setParameter(key, queryParams.get(key));
		}
        //执行查询，返回的是实体列表,
        String result = (String)query.getSingleResult();
       return result;
	}

//	public List<T> findByAttachIds(String[] ids){
//		String idsString ="";
//		if(ids==null || ids.length<1) return null;
//		for(int i=0; i<ids.length; i++){
//			try {
//				Long.valueOf(ids[i]);
//			} catch (NumberFormatException e) {
//				return null;
//			}
//			idsString += ids[i] +",";
//		}
//		idsString = idsString.substring(0,idsString.length()-1);
//		String hql ="from Attach t where t.removed='0' and t.id in ("+idsString+")";
//		Query query=createQuery(hql, null);
//		List<T> list=(List<T>)query.getResultList();
//		return list;    
//	}
//	
//	@Transactional
//	public void updateModelNameAndModelId(String modelName, Integer modelId, String[] ids){
//		String idsString ="";
//		if(ids==null || ids.length<1) return;
//		for(int i=0; i<ids.length; i++){
//			try {
//				Long.valueOf(ids[i]);
//			} catch (NumberFormatException e) {
//				return;
//			}
//			idsString += ids[i] +",";
//		}
//		idsString = idsString.substring(0,idsString.length()-1);
//		String hql ="update Attach a set a.modelName ="+modelName+", a.modelId ="+modelId+" where a.id in ("+idsString+")";
//		createQuery(hql, null).executeUpdate();
//	}

}

使用范例：自定义接口继承 扩展接口 

package com.wonders.frame.cpq.dao;

import java.util.List;

import javax.persistence.QueryHint;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.jpa.repository.QueryHints;
import org.springframework.data.repository.query.Param;
import org.springframework.transaction.annotation.Transactional;

import com.wonders.frame.core.dao.GenericRepository;
import com.wonders.frame.cpq.model.bo.CpqMain;

public interface CpqMainDao extends GenericRepository<CpqMain, Integer>{

	public Page<CpqMain> findAll(Pageable pageable);
		
	@Query("select a from CpqMain a where a.removed = 0 and a.id =?")
	public CpqMain findById(Integer id);
	
	@Transactional  
	@Modifying 
	@Query("update CpqMain a set a.removed = 1 where a.id =:id")
	public Integer removeById(@Param("id")Integer id);
	
	
    @QueryHints({ @QueryHint(name = "org.hibernate.cacheable", value ="true") })  
    public List<CpqMain> findAll();  

    
}


OkidoGreen
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
JPA踩坑记：Spring Data Jpa 更新为null的问题(save方法保存时null值会被更新到数据库)
adu003的博客
04-03 1万+
关键字: JPA更新为null,JPA save null,JPA保存为null 今天使用jpa的save方法时发现null字段也会被更新到数据库，这个直接把数据库数据覆盖的行为很可怕，果断研究了一下怎样能不保存null值。 解决方案： 实体类加@DynamicInsert(true)/@DynamicUpdate(true)注解; 扩展SimpleJpaRepository覆盖save方...
spring-data-jpa-example:Spring Data JPA 示例
06-22
spring-data-jpa-example 使用 spring 数据 JPA 的简单应用程序示例。安装指南安装 Java jdk 1.8 安装 Maven 3.x 设置环境变量 JAVA_HOME 设置环境变量 MAVEN_HOME 将 JAVA_HOME\bin 和 MAVEN_HOME\bin 放在环境变量...
使用queryParams获取参数
热门推荐
博客
01-15 3万+
jquery使用queryParams拿参数： 注：只放上了重点说明问题的代码 //使用isBackUp:$("#isBackUp").val()拿到了参数 &lt;input type="text" id="isBackUp" name="isBackUp" class="input_text" value="${param[
Spring Data常用类介绍系列一
最新发布
qq_31273845的博客
05-16 235
对于spring Data的一些常用类的介绍，一些常用方法的意思，目前可能不是很全面，后面会不断完善
Spring技术内幕之Spring Data JPA-自定义Repository实现
diaojin6880的博客
07-04 395
1.自定义Repository方法接口,让接口的实现类来继承这个中间接口而不是Repository接口package com.data.jpa.dao; import java.io.Serializable;import java.util.List;import java.util.Map; import org.springframework.da...
Spring Data JPA 原理与实战第二天 掌握Repoitory和DQM
fegus的博客
05-20 1327
02 Spring Data Common 之 Repoitory 如何全面掌握？ 通过上一课时，我们知道了 Spring Data 对整个数据操作做了很好的封装，其中 Spring Data Common 定义了很多公用的接口和一些相对数据操作的公共实现（如分页排序、结果映射、Autiting 信息、事务等），而 Spring Data JPA 就是 Spring Data Common 的关系数据库的查询实现。 所以本课时我们来了解一下 Spring Data Common 的核心内容——Reposi
spring-data-jpa-2.0.9.RELEASE-API文档-中文版.zip
06-25
赠送jar包：spring-data-jpa-2.0.9.RELEASE.jar； 赠送原API文档：spring-data-jpa-2.0.9.RELEASE-javadoc.jar； 赠送源代码：spring-data-jpa-2.0.9.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-data-jpa...
SpringBoot中使用Spring-data-jpa分页查询
04-27
SpringBoot是一款基于Spring框架的开发框架，而Spring-data-JPA是在Hibernate的基础上实现JPA规范的ORM框架。使用SpringBoot和Spring-data-jpa进行分页查询可以大大简化编码流程并提高开发效率。 在使用Spring-data...
spring-boot-starter-data-jpa-1.5.8.RELEASE.jar
02-27
java运行依赖jar包
spring-data-jpa
10-08
spring-data-jpa spring data jap
SpringBoot整合spring-data-jpa的方法
08-19
主要介绍了SpringBoot整合spring-data-jpa的方法，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
Spring Boot中使用Spring-data-jpa的配置方法详解
08-26
今天小编就为大家分享一篇关于Spring Boot中使用Spring-data-jpa的配置方法详解，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
spring-data-jpa-extra:带有模板动态查询的spring数据jpa（例如
05-23
spring-data-jpa-extra可以解决三个问题： 动态本地查询支持，例如mybatis 返回类型可以是任何东西没有代码，只有sql例子首先添加ComponentScan 通过java bean @ComponentScan ({ " com.slyak " , " your.base....
spring -data-jpa-crud
11-20
demo为spring boot项目 环境： 目前的程序环境是spring boot项目，JDK8.0，MySQL Connector / J 8.0（8.0版本支持java8及其以上的版本，支持5.6...Spring Data JPA 自动提供CRUD的实现，能够部分解放工程师们的工作量。
spring-data-jpa-demo:一个关于Spring-data-JPA使用的demo,附带Spring Data JPA的一系列入门文章，详见http
05-14
spring-data-jpa-demo一个关于Spring-data-JPA使用的demo1、2、3、4、5、6、7、8、9、9.1、例子 10、11、12、13、请通过社区SpringForAll（）获取文章更新Spring For All 是什么「文艺版」关于Spring 的一切「接地气...
反射方式获取JPA Entity的属性和值
嗡汤圆的博客
08-09 3459
在记录日志或者调试的时候，往往需要输出数据库查询或者写入的值，或者在接口交互的时候，可能需要将实体转成JSON串传递出去。 在JPA中是以Entity的示例方式传递的。但是如果直接使用Entity.toString() 方法的话，输出的结果是entity@内存地址的形式，无法得知Entity的内部具体的属性和值。以下描述采用反射方式获取Entity的字段和值的方法：反射工具类以将实体转为JSON
自定义Spring Data JPA存储库
最佳 Java 编程
05-11 422
Spring Data是一个非常方便的库。 但是，由于该项目是一个相当新的项目，因此功能不佳。 默认情况下，Spring Data JPA将基于SimpleJpaRepository提供DAO的实现。 在最近的项目中，我开发了一个定制的存储库基类，以便可以在其上添加更多功能。 您可以根据需要向该存储库基类添加特定于供应商的功能。 组态 您必须在spring bean配置文件中添加以下配...
springboot 长连接_Spring Boot实战之 数据持久化操作的3种集成实现
weixin_39827589的博客
11-28 724
作者：liuxiaopeng链接：https://www.cnblogs.com/paddix/p/8178943.html上篇文章中已经通过一个简单的HelloWorld程序讲解了Spring boot的基本原理和使用。本文主要讲解如何通过spring boot来访问数据库，本文会演示三种方式来访问数据库，第一种是JdbcTemplate，第二种是JPA，第三种是Mybatis。之前已经提到过...
Jpa实体类篇
面对疾风吧
01-04 998
Jpa实体类篇，定义公用实体类，公用字段属性，自定义主键规则等
spring-boot-starter-data-jpa,spring-data-jpa 一起用会冲突吗
04-04
`spring-boot-starter-data-jpa` 包含了 `spring-data-jpa`，是一个 Spring Boot 的 starter 包，它提供了使用 JPA 进行数据访问的自动配置。 如果你想自定义 JPA 的配置，可以使用 `spring-data-jpa` 包中提供的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值