Spring Data JPA

//保存实体

testJpa.save(t);

//findById

Optional<TestTest> byId = testJpa.findById(1L);

//findAll

List<TestTest> all = testJpa.findAll();

//count

long count = testJpa.count();

//getOne

 /**

 * geOne是懒加载方式,并且返回的是代理对象,是一个对象的引用

 * 优先使用findById findOne

 *

 * 使用geOne首先必须禁用lazy  Proxy(lazy=false)

 * 并且在查询不存在的数据时,会报异常

 * exception=...nested exception is javax.persistence.EntityNotFoundException....

 */

TestTest one = testJpa.getOne(2L);



//findOne

TestTest t = new TestTest();

t.setAge(1);

Optional<TestTest> one = testJpa.findOne(Example.of(t));



//existsById

boolean b = testJpa.existsById(1L);

//existsById by Example

TestTest t = new TestTest();

t.setAge(11);

boolean exists = testJpa.exists(Example.of(t));

//delete

testJpa.deleteById(1L);

//findAll->Sort(field)

Sort age = Sort.by(Sort.Direction.DESC, "age");

List<TestTest> all = testJpa.findAll(age);



Sort age = Sort.by(Sort.Order.desc("age"));

List<TestTest> all = testJpa.findAll(age);



//findAll->page

Pageable unpaged = Pageable.unpaged();

Page<TestTest> all = testJpa.findAll(unpaged);

Page<TestTest> all = testJpa.findAll(PageRequest.of(0, 10));



PageRequset实现了Pageable接口



//立即刷新

testJpa.flush();

//批量保存

testJpa.saveAll(Collection);

//保存并刷新

testJpa.saveAndFlush(S);



//JPA的派生用法

//通过age查询数量

long count = testJpa.countByAge(2);

//通过name删除

testJpa.deleteByName("2");

//通过age和name查询数据

List<TestTest> list = testJpa.findByNameAndAge("3", 3);



//去重

List<TestTest> list = testJpa.findDistinctPeopleByAge(3);



//or

List<TestTest> list = testJpa.findByAgeOrName(1, "1");



//忽略大小写

List<TestTest> list = testJpa.findByNameIgnoreCase("abc");

//全部忽略大小写

List<Person> findByLastnameAndFirstnameAllIgnoreCase(String lastname, String firstname);



//排序

List<TestTest> list = testJpa.findByAgeOrderByAgeDesc(1);



//分页或者排序

List<TestTest> findByAgeOrderByAgeDesc(int age, Pageable pageable);

//query查询

@Query("select u from TestTest u where u.age = ?1")

List<TestTest> findByAge1(int age);



@Query("select u from TestTest u where u.age = :age")

List<TestTest> findByAge2(@Param("age") int age);



@Query("select u from #{#entityName} u where u.age = ?1")

List<TestTest> findByAge3(int age);



@Transactional

@Modifying

@Query("update TestTest cn set cn.age = :#{#entity.age } where cn.id =  :#{#entity.id }")

Integer update(@Param("entity") TestTest entity);



//limit

List<TestTest> list =  testJpa.findFirstByAgeOrderByIdDesc(1);

List<TestTest> list =  testJpa.findTopByOrderByAgeDesc();

List<TestTest> list = testJpa.findTop2ByAge(1);





//CriteriaBuilder

CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();

CriteriaQuery<TestTest> query = criteriaBuilder.createQuery(TestTest.class);

Root<TestTest> from = query.from(TestTest.class);

List<Predicate> preCondition = new ArrayList<>();

Predicate condition = criteriaBuilder.equal(from.get("age"),1);

preCondition.add(condition);

Predicate[] predicates = new Predicate[preCondition.size()];

query.where(preCondition.toArray(predicates));

Query q = entityManager.createQuery(query);

List resultList = q.getResultList();

print(resultList);



//简单的一个util

public class CriteriaUtil {



    private CriteriaBuilder criteriaBuilder;

    private CriteriaQuery<T> query;

    private Root<TestTest> from;

    private List<Predicate> preCondition;

    private EntityManager entityManager;



    public CriteriaUtil(Class entity, EntityManager entityManager) {

        init(entity, entityManager);

    }



    public static CriteriaUtil create(Class entity, EntityManager entityManager) {

        return new CriteriaUtil(entity, entityManager);

    }



    private void init(Class target, EntityManager entityManager) {

        this.criteriaBuilder = entityManager.getCriteriaBuilder();

        this.query = criteriaBuilder.createQuery(target);

        this.from = query.from(target);

        this.preCondition = new ArrayList<>();

        this.entityManager = entityManager;

    }



    public void find() {

        Predicate[] predicates = new Predicate[this.preCondition.size()];

        this.query.where(this.preCondition.toArray(predicates));

        Query q = this.entityManager.createQuery(this.query);

        List resultList = q.getResultList();

        System.out.println(resultList);

    }



    public void findByPage(Integer page, Integer limit) {

        Predicate[] predicates = new Predicate[this.preCondition.size()];

        this.query.where(this.preCondition.toArray(predicates));

        Query q = this.entityManager.createQuery(this.query);

        List resultList = q.setFirstResult((page - 1) * limit).setMaxResults(limit).getResultList();

        print(resultList);

    }



    public CriteriaUtil eqOp(Condition c) {

        this.preCondition.add(this.criteriaBuilder.equal(this.from.get(c.getKey()),c.getValue()));

        return this;

    }



    public void print(Object o) {

        System.out.println("================start================");

        System.out.println(o);

        System.out.println("=================end=================");

    }