spring data jpa 操作JPA 2.0原生api

spring data jpa 虽然为我们提供了很多便利，但业务往往是复杂的，便利并不能随心所欲，另外，如果你对原生的sql比较熟悉，或许你可以用用jpa2.0的原生api

操作JPA2.0 api我们只需要按平常建一个dao类就可以了，然后把EntityManager实体管理器注进来，这里用@PersistenceContext进行注入

@Repository("taskDao")public class TaskDao{    @PersistenceContext private EntityManager em ;}
1
2
3
4
5
6
1
2
3
4
5
6

所有的数据库操作都基于EntityManager ，例如常见的CRUD

@Repository("taskDao")public class TaskDao{    @PersistenceContext private EntityManager em ;    /**     * 保存     * @param t     * @return     */    public Task save(Task t){        this.em.persist(t);        return t ;    }    /**     * 更新     * @param t     * @return     */    public Task update(Task t){        return this.em.merge(t);    }    /**     * 删除     * @param id     */    public void delete(Long id){        Task t = this.em.unwrap(Task.class);        t.setId(id);        this.em.remove(t);    }    /**     * 查找     * @param id     * @return     */    public Task findOne(Long id){        return this.em.find(Task.class,id);    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

利用Query进行hql，sql查询

@Repository("taskDao")public class TaskDao{    @PersistenceContext private EntityManager em ;    /**     * 查询列表     * @return     */    @SuppressWarnings("unchecked")    public List<Task> findAll(){        Query query = this.em.createQuery("select t from Task t ",Task.class);        return query.getResultList();    }    /**     * 通过原生sql查询某些字段     * @return     */    public  List<Object[]> findTuple(){        Query query = this.em.createNativeQuery("select t.id ,t.task_name from tb_task t ");        return query.getResultList();    }    /**     * 查询字段映射成map     * @return     */    public  List<Map<String, Object>> findMap(){        Query query = this.em.createQuery("select t.id as id ,t.taskName as taskName ,t.createTime as createTime from Task t ");        query.unwrap(org.hibernate.Query.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);        return  query.getResultList();    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

使用criteria 查询

@Repository("taskDao")public class TaskDao{    @PersistenceContext private EntityManager em ;/**     * 通过Criteria创建查询     * @return     */    public List<Task> findByCriteria(){        CriteriaBuilder cb = em.getCriteriaBuilder();   //创建查询工厂类        CriteriaQuery<Task> c = cb.createQuery(Task.class); //创建一个查询实例        Root<Task> p = c.from(Task.class);  //类似from task ，        Path<String> expression = p.get("taskName"); //获取属性路径        Predicate condition = cb.like(expression, "%taskName%"); //创建where查询        c.where(condition);        TypedQuery<Task> q = em.createQuery(c);  //查询查新        List<Task> result = q.getResultList();        return result ;    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

criteria的优势是禁止构造语法错误的查询，个人感觉没什么用，不怎么建议大家用criteria，语法麻烦，而且学习成本大。

好，这时候，我有这样子的需求，我是想直接操作JPA api，它给我最大灵活性，但我又想把常用的接口放到基类中，而spring data jpa 提供的一些接口，确实又很方便，直接用它的接口比我自己来封装是不是要强大得多

通过前一篇博客，介绍了全自定义全局接口Basedao，
http://blog.csdn.net/yingxiake/article/details/51017797，
我们发现spring data jpa通过SimpleJpaRepository来实现spring data jpa的一些实用的方法的，那么我们可不可以来继承SimpleJpaRepository，然后也就可以用spring data jpa一些有用的方法了，那我们定义一个通用的dao类，其他模块的dao就直接继承这个dao吧

public class GenericDao<T,ID extends Serializable> {    private Class<T> entityClass;     private EntityManager entityManager ;    private SimpleJpaRepository<T, ID> simpleJpaRepository ;    /**     * 注入EntityManager，同时实例化SimpleJpaRepository     * @param em     */    @SuppressWarnings({ "unchecked", "rawtypes" })    @PersistenceContext        /**     * 注入EntityManager，同时实例化SimpleJpaRepository     * @param em     */    @SuppressWarnings({ "unchecked", "rawtypes" })    @PersistenceContext    public void setEntityManager(EntityManager entityManager) {        Type genType = getClass().getGenericSuperclass();          Type[] params = ((ParameterizedType) genType).getActualTypeArguments();          entityClass = (Class) params[0];          this.simpleJpaRepository = new SimpleJpaRepository<T,ID>(entityClass, entityManager);        this.entityManager = entityManager;    }    /**     * 获取EntityManager，操作jpa api的入口     * @return     */    public EntityManager getEntityManager() {        return entityManager;    }    /**     * 给子类提供simpleJpaRepository实例，用来操作spring data jpa常用的接口     * @return     */    public SimpleJpaRepository<T, ID> getSimpleJpaRepository() {        return simpleJpaRepository;    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

然后让我们的taskdao来继承这个GenericDao，这样就可以完成利用spring data jpa提供的接口了

@Repository("taskDao")public class TaskDao extends GenericDao<Task, Long>{    /**     * 自定义查询     * @return     */    public List<Map<String, Object>> findMap() {        Query query = this.getEntityManager().createQuery("select t.id as id ,t.taskName as taskName ,t.createTime as createTime from Task t ");        query.unwrap(org.hibernate.Query.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);        return  query.getResultList();    }    /**     * 利用spring data jpa提供的接口进行查询     * @param id     * @return     */    public Task findOne(Long id){        return this.getSimpleJpaRepository().findOne(id);    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

ok，spring data jpa大概就介绍到这里吧，还有一些其他比较少用的用法，后面 有碰到过再看看