spring data jpa demo（hibernate实现的jpa）

最新推荐文章于 2022-02-01 21:12:50 发布

ppt0501

最新推荐文章于 2022-02-01 21:12:50 发布

阅读量7.9k

点赞数 4

分类专栏： java后台文章标签： spring data jpa

本文链接：https://blog.csdn.net/ppt0501/article/details/15336173

版权

java后台专栏收录该内容

25 篇文章 0 订阅

订阅专栏

一、依赖包

<dependency>
				<groupId>org.springframework.data</groupId>
				<artifactId>spring-data-jpa</artifactId>
				<version>1.3.4.RELEASE</version>
			</dependency>
			
			<dependency>
				<groupId>org.springside</groupId>
				<artifactId>springside-parent</artifactId>
				<version>${springside.version}</version>
    			<type>pom</type>
			</dependency>
			
			<dependency>
				<groupId>org.springside</groupId> 
				<artifactId>springside-core</artifactId>
				<version>${springside.version}</version>
			</dependency>
			
			<dependency>
			    <groupId>com.google.guava</groupId>
			    <artifactId>guava</artifactId>
			    <version>15.0</version>
			</dependency>

二、spring配置

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    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.0.xsd 
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.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.0.xsd">
    
    <context:annotation-config/>
    <context:component-scan base-package="com.csair"/>
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <jpa:repositories base-package="com.csair.jparepository"></jpa:repositories><!-- 实现了repository接口，自动创建代理 -->
	<bean id="dataSource_jdbc" class="org.springframework.jdbc.datasource.DriverManagerDataSource" >
		<property name="url" value="${url}"/>
		<property name="username" value="${username}"/>
		<property name="password" value="${password}"/>
	</bean> 
	
	<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="dataSource" ref="dataSource_jdbc"/>
		<property name="packagesToScan" value="com.csair.entity"/><!-- instead of the persistence.xml file -->
		<property name="jpaVendorAdapter" ref="hibernateJpaVendorAdapter"/>   <!-- No PersistenceProvider specified in EntityManagerFactory configuration -->
		<property name="jpaProperties">
			<props>
				<!-- 命名规则 My_NAME->MyName -->
				<!-- <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop> -->
				<prop key="hibernate.hbm2ddl.auto">none</prop>
				<prop key="hibernate.dialect">${hibernate.dialect}</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.format_sql">true</prop>
				

			</props>
		</property>
	</bean>
	
	<bean id="hibernateJpaVendorAdapter" class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
		<property name="databasePlatform" value="${hibernate.dialect}"/>
	</bean>
	
	<bean id="jpaTransactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory">
			<ref local="entityManagerFactory"/>
		</property>
	</bean> 
	<tx:annotation-driven transaction-manager="jpaTransactionManager"/> 
	
</beans>

三、实现使用SimpleJpaRepository

package com.csair.dao;

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

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
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.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service("springDataJpa")
public class SpringDataJpa {

	@PersistenceContext
	private EntityManager em;
	private static int MAX_CACHE_SIEZ = 200;
	Map<Class<?>, SimpleJpaRepository> cache = new CacheHashMap();
	
	/**
	 * 保存实体
	 * @param entity--要保存的实体
	 * @param entityClass--要保存的类型
	 * @return 保存后的实体
	 */
	public <T> T save(T entity, Class<T> entityClass) {
		JpaEntityInformation<T, ?> entityInfomation = JpaEntityInformationSupport.getMetadata(entityClass, em);
		if(entityInfomation.isNew(entity)) {
			em.persist(entity);
			return entity;
		} else {
			T t = em.merge(entity);
			return t;
		}
	}
	/**
	 * 根据id删除实体
	 * @param id
	 * @param entityClass
	 */
	@Transactional
	public <T, ID extends Serializable> void delete(ID id, Class<T> entityClass) {
		this.getRepository(entityClass).delete(id);
		
	}
	/**
	 * 根据id查询一个实体
	 * @param id
	 * @param entityClass
	 * @return
	 */
	public <T, ID extends Serializable> T findOne(ID id, Class<T> entityClass) {
		return this.getRepository(entityClass).findOne(id);
	}
	/**
	 * 查询所有实体
	 * @param entityClass
	 * @return
	 */
	public <T> Iterable<T> findAll(Class<T> entityClass) {
		return this.getRepository(entityClass).findAll();
	}
	/**
	 * 分页查询
	 * @param request
	 * @param entityClass
	 * @return
	 */
	public <T> Page<T> getPage(Pageable request, Class<T> entityClass) {
		return this.getRepository(entityClass).findAll(request);
	}
	
	/**
	 * 条件查询
	 * @param spec
	 * @param entityClass
	 * @return
	 */
	public <T> List<T> findAll(Specification<T> spec, Class<T> entityClass) {
		return this.getRepository(entityClass).findAll(spec);
	}
	/**
	 * 分页条件查询
	 * @param request
	 * @param spec
	 * @param entityClass
	 * @return
	 */
	public <T> Page<T> getPageByFilter(Pageable request, Specification<T> spec, Class<T> entityClass) {
		return this.getRepository(entityClass).findAll(spec, request);
	}
	
	/**
	 * 获取repository
	 * @param entityClass
	 * @return
	 */
	private <T, ID extends Serializable> SimpleJpaRepository<T, ID> getRepository(Class<T> entityClass) {
		if(cache.containsKey(entityClass)) {
			return cache.get(entityClass);
		}
		SimpleJpaRepository<T, ID> repository = new SimpleJpaRepository<T, ID>(JpaEntityInformationSupport.getMetadata(entityClass, em), em);
		cache.put(entityClass, repository);
		return repository;
	}
	/**
	 * 缓存
	 * @author ppt
	 */
	@SuppressWarnings("serial")
	private static class CacheHashMap extends LinkedHashMap<Class<?>, SimpleJpaRepository>{
		@Override
		protected boolean removeEldestEntry(Map.Entry eldest) {
	        return size() > MAX_CACHE_SIEZ;
	    }
	}

}

四、另外还可以直接实现Repository接口

package com.csair.jparepository;

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.csair.entity.UserAnotation;
@Service("userSerivce")
public interface UserSerivce extends Repository<UserAnotation, Integer>{

	@Query("from UserAnotation where id = ?")
	UserAnotation getUserOne(int id);
	
	@Transactional
	UserAnotation save(UserAnotation user);
	
	@Transactional
	void delete(Integer id);
	
	UserAnotation findOne(Integer id);
}

实现Repository自动帮助现实。

五、分页查询测试

分页
			Page<UserAnotation> page = springDataJpa.getPage(new PageRequest(1, 2, new Sort(Direction.DESC,"id")), UserAnotation.class);
			List<UserAnotation> list = page.getContent();
//			条件查询
			Map<String, SearchFilter> map = new HashMap<String, SearchFilter>();
			map.put("username", new SearchFilter("username", Operator.EQ, "ppt"));
			Specification<UserAnotation> spec = DynamicSpecifications.bySearchFilter(map.values(), UserAnotation.class);
			List<UserAnotation> list = springDataJpa.findAll(spec, UserAnotation.class);
//			分页条件查询
			PageRequest request = new PageRequest(0, 2, new Sort(Direction.DESC,"id"));
			Map<String, SearchFilter> map = new HashMap<String, SearchFilter>();
			map.put("username", new SearchFilter("username", Operator.EQ, "ppt"));
			Specification<UserAnotation> spec = DynamicSpecifications.bySearchFilter(map.values(), UserAnotation.class);
			Page<UserAnotation> page = springDataJpa.getPageByFilter(request, spec, UserAnotation.class);
			List<UserAnotation> list = page.getContent();
			System.out.println(list.toString());