我现在经常用到Spring JPA Data
和逆向工程一样方便
GitHub地址:https://github.com/binlian/binglian-Spring-JPA-Data
它有自己的定义规则,可以不用在写那些SQL语句了,
可以根据id name来查询 两个一起查询等
public Employee findByName(String name);
这传代码就是 根据name查询数据
Maven jar引入 放入pom.xml
<!--spring data jpa-->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>1.8.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>4.3.6.Final</version>
</dependency>
配置文件
bean-new.xml
其实这些配置都是一环扣一环的
<prop key="hibernate.show_sql">true</prop> 打印SQL语句
<prop key="hibernate.format_sql">true</prop> 这个是代码格式化
<?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:jpa="http://www.springframework.org/schema/data/jpa"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
<!--1 配置数据源-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
<property name="url" value="jdbc:mysql://localhost:3306/jdbc"/>
</bean>
<!--2 配置EntityManagerFactory-->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"/>
</property>
<property name="packagesToScan" value="com.binglian"/>
<property name="jpaProperties">
<props>
<prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
</bean>
<!--3 配置事务管理器-->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"/>
</bean>
<!--4 配置支持注解的事务-->
<tx:annotation-driven transaction-manager="transactionManager"/>
<!--5 配置spring data-->
<jpa:repositories base-package="com.binglian" entity-manager-factory-ref="entityManagerFactory"/>
<context:component-scan base-package="com.binglian"/>
</beans>
然后看下代码
使用Jpa 需要继承Repository
也可以使用注解方式(添加注解能到达到不用extends Repository的功能)
@RepositoryDefinition(domainClass = Employee.class, idClass = Integer.class)
Repository类的定义:
public interface Repository<T, ID extends Serializable> {
}
Repository是一个空接口,标记接口
没有包含方法声明的接口
package com.binglian.repository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;
import org.springframework.data.repository.RepositoryDefinition;
import org.springframework.data.repository.query.Param;
import com.binglian.domain.Employee;
import java.util.List;
@RepositoryDefinition(domainClass = Employee.class, idClass = Integer.class)
public interface EmployeeRepository { //extends Repository<Employee,Integer>{
public Employee findByName(String name);
// where name like ?% and age <?
public List<Employee> findByNameStartingWithAndAgeLessThan(String name, Integer age);
// where name like %? and age <?
public List<Employee> findByNameEndingWithAndAgeLessThan(String name, Integer age);
// where name in (?,?....) or age <?
public List<Employee> findByNameInOrAgeLessThan(List<String> names, Integer age);
// where name in (?,?....) and age <?
public List<Employee> findByNameInAndAgeLessThan(List<String> names, Integer age);
@Query("select o from Employee o where id=(select max(id) from Employee t1)")
public Employee getEmployeeByMaxId();
@Query("select o from Employee o where o.name=?1 and o.age=?2")
public List<Employee> queryParams1(String name, Integer age);
@Query("select o from Employee o where o.name=:name and o.age=:age")
public List<Employee> queryParams2(@Param("name")String name, @Param("age")Integer age);
@Query("select o from Employee o where o.name like %?1%")
public List<Employee> queryLike1(String name);
@Query("select o from Employee o where o.name like %:name%")
public List<Employee> queryLike2(@Param("name")String name);
@Query(nativeQuery = true, value = "select count(1) from employee")
public long getCount();
@Modifying
@Query("update Employee o set o.age = :age where o.id = :id")
public void update(@Param("id")Integer id, @Param("age")Integer age);
}
test类
package com.imooc.repository;
import org.hibernate.action.internal.EntityIncrementVersionProcess;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import com.binglian.domain.Employee;
import com.binglian.repository.EmployeeJpaRepository;
import com.binglian.repository.EmployeePagingAndSortingReposity;
import com.binglian.repository.EmployeeRepository;
import com.binglian.service.EmployeeService;
import java.util.ArrayList;
import java.util.List;
public class EmployeeJpaRepositoryTest {
private ApplicationContext ctx = null;
private EmployeeJpaRepository employeeJpaRepository=null;
@Before
public void setup() {
ctx = new ClassPathXmlApplicationContext("beans-new.xml");
employeeJpaRepository= ctx.getBean(EmployeeJpaRepository.class);
System.out.println("setup");
}
@After
public void tearDown() {
ctx = null;
System.out.println("tearDown");
}
@Test
public void testFind(){
Employee employee=employeeJpaRepository.findOne(99);
System.out.println("employee:"+employee);
System.out.println("emloyee(10)"+employeeJpaRepository.exists(10));
System.out.println("emloyee(102)"+employeeJpaRepository.exists(102));
}
}
更新删除 需要@Modifying
也需要service 才可以成功运行
@Modifying
@Query("update Employee o set o.age = :age where o.id = :id")
public void update(@Param("id")Integer id, @Param("age")Integer age);
自动创建数据库 根据实体类自动创建数据库
package com.binglian.domain;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
/**
* 雇员:先开发实体类====>自动生成数据表
*/
@Entity
@Table(name="test_employee")
public class Employee {
private Integer id;
private String name;
private Integer age;
@GeneratedValue
@Id
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
@Column(length = 20)
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
CrudReository
package com.binglian.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import com.binglian.domain.Employee;
public interface EmployeeJpaRepository extends JpaRepository<Employee, Integer>{
}
test类
save使用
employeeService.save(employees);
package com.imooc.repository;
import org.hibernate.action.internal.EntityIncrementVersionProcess;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.binglian.domain.Employee;
import com.binglian.repository.EmployeeRepository;
import com.binglian.service.EmployeeService;
import java.util.ArrayList;
import java.util.List;
public class EmployeeCrudRepositoryTest {
private ApplicationContext ctx = null;
private EmployeeService employeeService=null;
@Before
public void setup() {
ctx = new ClassPathXmlApplicationContext("beans-new.xml");
employeeService= ctx.getBean(EmployeeService.class);
System.out.println("setup");
}
@After
public void tearDown() {
ctx = null;
System.out.println("tearDown");
}
@Test
public void testSave(){
List<Employee> employees=new ArrayList<Employee>();
Employee employee=null;
for(int i=0;i<100;i++){
employee=new Employee();
employee.setAge(100-i);
employee.setName("test"+i);
employees.add(employee);
}
employeeService.save(employees);
}
}
这个分页在工作也比较常用
分页、排序
package com.binglian.repository;
import org.springframework.data.repository.PagingAndSortingRepository;
import com.binglian.domain.Employee;
public interface EmployeePagingAndSortingReposity extends PagingAndSortingRepository<Employee, Integer>{
}
Test类
Sort.Direction.DESC,"id"根据id正序
Sort.Order order=new Sort.Order(Sort.Direction.DESC,"id");
Sort sort=new Sort(order);
//page:index是0开始的,不是从1开始的
Pageable pageable=new PageRequest(0, 5);
Page<Employee> page=employeePagingAndSortingReposity.findAll(pageable);
Page 封装了页数这些属性
System.out.println("查询的总页数"+page.getTotalPages());
System.out.println("查询的总记录数"+page.getTotalElements());
package com.imooc.repository;
import org.hibernate.action.internal.EntityIncrementVersionProcess;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import com.binglian.domain.Employee;
import com.binglian.repository.EmployeePagingAndSortingReposity;
import com.binglian.repository.EmployeeRepository;
import com.binglian.service.EmployeeService;
import java.util.ArrayList;
import java.util.List;
public class EmployeePagingSortingRepositoryTest {
private ApplicationContext ctx = null;
private EmployeePagingAndSortingReposity employeePagingAndSortingReposity=null;
@Before
public void setup() {
ctx = new ClassPathXmlApplicationContext("beans-new.xml");
employeePagingAndSortingReposity= ctx.getBean(EmployeePagingAndSortingReposity.class);
System.out.println("setup");
}
@After
public void tearDown() {
ctx = null;
System.out.println("tearDown");
}
@Test
public void testPage(){
//根据id正序排序
Sort.Order order=new Sort.Order(Sort.Direction.DESC,"id");
Sort sort=new Sort(order);
//page:index是0开始的,不是从1开始的
Pageable pageable=new PageRequest(0, 5);
Page<Employee> page=employeePagingAndSortingReposity.findAll(pageable);
System.out.println("查询的总页数"+page.getTotalPages());
System.out.println("查询的总记录数"+page.getTotalElements());
System.out.println("查询的当前第几页"+page.getNumber());
System.out.println("查询的当前页面的集合"+page.getContent());
System.out.println("查询的当前页面的记录数"+page.getNumberOfElements());
}
}
JpaRepository
package com.binglian.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import com.binglian.domain.Employee;
public interface EmployeeJpaRepository extends JpaRepository<Employee, Integer>{
}
JpaSpecificationRepository
这个是多继承可以使用两个方法
package com.binglian.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import com.binglian.domain.Employee;
/**
* 也是可以多继承
* @author binglian
*
*/
public interface EmployeeJpaSpecificationExecutorRepository
extends JpaRepository<Employee, Integer>,JpaSpecificationExecutor<Employee>{
}
/**
* root:就是我们要查询的类型(Employee)
* query:添加查询天剑
* cb:构建Predicate
*/
Specification<Employee> specification=new Specification<Employee>() {
@Override
public Predicate toPredicate(Root<Employee> root,
CriteriaQuery<?> query,
CriteriaBuilder cb) {
Path path=root.get("age");
return cb.gt(path, 50);//age大于20;
}
};
Page<Employee> page=employeeJpaSpecificationExecutorRepository.findAll(specification,pageable);
package com.imooc.repository;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Path;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import com.binglian.domain.Employee;
import com.binglian.repository.EmployeeJpaRepository;
import com.binglian.repository.EmployeeJpaSpecificationExecutorRepository;
public class EmployeeJpaSpecificationExecutorRepositoryTest {
private ApplicationContext ctx = null;
private EmployeeJpaSpecificationExecutorRepository employeeJpaSpecificationExecutorRepository=null;
@Before
public void setup() {
ctx = new ClassPathXmlApplicationContext("beans-new.xml");
employeeJpaSpecificationExecutorRepository= ctx.getBean(EmployeeJpaSpecificationExecutorRepository.class);
System.out.println("setup");
}
@After
public void tearDown() {
ctx = null;
System.out.println("tearDown");
}
/**
* 分页
* 排序
* 查询条件
*/
@Test
public void testQuery(){
//根据id正序排序
Sort.Order order=new Sort.Order(Sort.Direction.DESC,"id");
Sort sort=new Sort(order);
//page:index是0开始的,不是从1开始的
Pageable pageable=new PageRequest(0, 5);
/**
* root:就是我们要查询的类型(Employee)
* query:添加查询天剑
* cb:构建Predicate
*/
Specification<Employee> specification=new Specification<Employee>() {
@Override
public Predicate toPredicate(Root<Employee> root,
CriteriaQuery<?> query,
CriteriaBuilder cb) {
Path path=root.get("age");
return cb.gt(path, 50);//age大于20;
}
};
Page<Employee> page=employeeJpaSpecificationExecutorRepository.findAll(specification,pageable);
// Page<Employee> page=employeeJpaSpecificationExecutorRepository.findAll(pageable);
System.out.println("查询的总页数"+page.getTotalPages());
System.out.println("查询的总记录数"+page.getTotalElements());
System.out.println("查询的当前第几页"+page.getNumber());
System.out.println("查询的当前页面的集合"+page.getContent());
System.out.println("查询的当前页面的记录数"+page.getNumberOfElements());
}
}