spring data jpa demo（hibernate实现的jpa）

<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>

<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>

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;
}
}

}

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);
}

分页
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());