spring boot整合Spring-data-jpa自定义扩展接口

• 基于Spring boot1.5.9.RELEASE和JDK1.8

1、添加Maven依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

2、配置数据源

application.yml

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver #mysql连接配置
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8
    username: root
    password: root
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: update

3、创建公共Base接口

公共接口声明BaseJpaRepository.java

package com.lilian.base.jpa;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.NoRepositoryBean;

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

/**
 * jpa-demo
 * 为全部的Repository 声明一些自定义方法的接口
 *
 * @Author 孙龙
 * @Date 2018/7/2
 */
@NoRepositoryBean
public interface BaseJpaRepository<T, ID extends Serializable> extends JpaRepository<T, ID>, JpaSpecificationExecutor<T> {
    /**
     * 查询多个属性
     * 返回List<Object[]>数组形式的List，数组中内容按照查询字段先后
     *
     * @param sql 原生SQL语句
     * @return
     */
    List<Object[]> sqlArrayList(String sql);

    /**
     * 查询多个属性
     * 返回List<Object>对象形式的List，Object为Class格式对象
     *
     * @param sql 原生SQL语句
     * @param obj Class格式对象
     * @return
     */
    List sqlObjectList(String sql, Object obj);

    /**
     * 查询单个属性
     * 返回List<Object>对象形式的List，Object为对象数据类型
     *
     * @param sql 原生SQL语句
     * @return
     */
    List sqlSingleList(String sql);
}

• 需要添加@NoRepositoryBean注解来说明此接口不是一个声明的Repository，否则Spring默认当做普通的Repository来处理；
• 可以在此接口中生命一些自定义的接口公共方法；
• 在这里同时继承了JpaSpecificationExecutor类，支持了Specification方式的复杂查询方式，普通的Repository接口在使用Specification查询就无须使用多继承或选择继承的方式
  公共接口实现类SimpleBaseJpaRepository.java

package com.lilian.base.jpa;

import org.springframework.data.jpa.repository.support.SimpleJpaRepository;

import javax.persistence.EntityManager;
import javax.persistence.Query;
import java.io.Serializable;
import java.util.List;

/**
 * jpa-demo 公共Jpa接口实现类
 *
 * @Author 孙龙
 * @Date 2018/7/2
 */
public class SimpleBaseJpaRepository<T, ID extends Serializable>
        extends SimpleJpaRepository<T, ID> implements BaseJpaRepository<T, ID> {

    private final EntityManager entityManager;

    private Class<T> clazz;

    public SimpleBaseJpaRepository(Class<T> domainClass, EntityManager em) {
        super(domainClass, em);
        this.clazz = domainClass;
        this.entityManager = em;
    }

    @Override
    public List<Object[]> sqlArrayList(String sql) {
        Query query = entityManager.createNativeQuery(sql);
        List<Object[]> list = query.getResultList();
        entityManager.close();
        return list;
    }

    @Override
    public List sqlObjectList(String sql, Object obj) {
        Query query = entityManager.createNativeQuery(sql, obj.getClass());
        List list = query.getResultList();
        entityManager.close();
        return list;
    }

    @Override
    public List sqlSingleList(String sql) {
        Query query = entityManager.createNativeQuery(sql);
        List list = query.getResultList();
        entityManager.close();
        return list;
    }
}

4、重写JpaRepositoryFactoryBean中的方法

package com.lilian.base.jpa;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.support.JpaRepositoryFactory;
import org.springframework.data.jpa.repository.support.JpaRepositoryFactoryBean;
import org.springframework.data.repository.core.RepositoryInformation;
import org.springframework.data.repository.core.RepositoryMetadata;
import org.springframework.data.repository.core.support.RepositoryFactorySupport;

import javax.persistence.EntityManager;
import java.io.Serializable;

/**
 * jpa-demo
 * 自定义扩展后的factoryBean
 *
 * @Author 孙龙
 * @Date 2018/7/2
 */
public class BaseJpaRepositoryFactoryBean<R extends JpaRepository<T, I>, T, I extends Serializable>
        extends JpaRepositoryFactoryBean<R, T, I> {

    public BaseJpaRepositoryFactoryBean(Class<? extends R> repositoryInterface) {
        super(repositoryInterface);
    }

    @Override
    protected RepositoryFactorySupport createRepositoryFactory(EntityManager entityManager) {
        return new BaseDaoFactory(entityManager);
    }

    private static class BaseDaoFactory<T, I extends Serializable>
            extends JpaRepositoryFactory {
        private final EntityManager entityManager;

        public BaseDaoFactory(EntityManager entityManager) {
            super(entityManager);
            this.entityManager = entityManager;
        }

        @Override
        protected Object getTargetRepository(RepositoryInformation information) {
            return new SimpleBaseJpaRepository<T, I>((Class<T>) information.getDomainType(), entityManager);
        }


        @Override
        protected Class<?> getRepositoryBaseClass(RepositoryMetadata metadata) {
            return SimpleBaseJpaRepository.class;
        }
    }
}

5、覆盖SpringBoot提供的默认配置

package com.lilian.base;

import com.lilian.base.mysql.BaseJpaRepositoryFactoryBean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

/**
 * jpa-demo
 * 自定义jpa配置类
 *
 * @Author 孙龙
 * @Date 2018/7/2
 */
@Configuration
@EnableJpaRepositories(basePackages = {"com.lilian.repository.mysql"}, repositoryFactoryBeanClass = BaseJpaRepositoryFactoryBean.class)
public class JpaRepositoryConfig {
}

这里的basePackages参数需要指定Repository所在的包，可以指定多个

6、使用Base接口开发

(1)创建实体类

Person.java

package com.lilian.entity.mysql;

import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.*;
import java.sql.Timestamp;

/**
 * jpa-demo
 *
 * @Author 孙龙
 * @Date 2018/7/3
 */
@Data
@Entity
@NoArgsConstructor
public class Person {
    @Id
    @GeneratedValue
    private Long id;
    /**
     * 姓名
     */
    private String name;
    /**
     * 年龄
     */
    private Integer age;
    /**
     * 地址
     */
    private String address;
    /**
     * 邮箱
     */
    private String email;
    /**
     * 添加时间
     */
    private Timestamp addTime;
    /**
     * 手机号码
     */
    private String phoneNum;

    public Person(String name, Integer age, String address, String email, Timestamp addTime, String phoneNum) {
        this.name = name;
        this.age = age;
        this.address = address;
        this.email = email;
        this.addTime = addTime;
        this.phoneNum = phoneNum;
    }
}

(2)创建Repo接口

PersonJpaRepository.java

package com.lilian.repository.mysql;

import com.lilian.base.jpa.BaseJpaRepository;
import com.lilian.entity.mysql.Person;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import java.util.List;

/**
 * jpa-demo
 *
 * @Author 孙龙
 * @Date 2018/7/3
 */
public interface PersonJpaRepository extends BaseJpaRepository<Person, Long> {
    /**
     * 根据ID查询全部
     *
     * @param id
     * @return
     */
    @Query("select p from Person p where p.id = ?1")
    List<Person> findById(@Param("id") long id);

}

(3)Service层

IPersonService.java

package com.lilian.service.mysql;

import com.lilian.entity.mysql.Person;

import java.util.List;

/**
 * jpa-demo
 *
 * @Author 孙龙
 * @Date 2018/7/3
 */
public interface IPersonService {
    /**
     * 批量添加
     *
     * @param personList
     */
    void batchAdd(List<Person> personList);

    /**
     * 根据ID查询（@Query方式）
     *
     * @param id
     * @return
     */
    List<Person> queryById(Long id);

    /**
     * 根据Addr查询（Specification方式）
     *
     * @param addr
     * @return
     */
    List<Person> queryByAddr(String addr);

    /**
     * 根据 phoneNum 查询（Specification方式）
     *
     * @param phoneNum
     * @return
     */
    List<Person> queryByPhoneNum(String phoneNum);
}

PersonServiceImpl.java

package com.lilian.service.mysql.impl;

import com.lilian.entity.mysql.Person;
import com.lilian.repository.mysql.PersonJpaRepository;
import com.lilian.service.mysql.IPersonService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * jpa-demo
 *
 * @Author 孙龙
 * @Date 2018/7/3
 */
@Service
public class PersonServiceImpl implements IPersonService {

    @Autowired
    private PersonJpaRepository personRepository;

    @Override
    public void batchAdd(List<Person> personList) {
        personRepository.save(personList);
    }

    @Override
    public List<Person> queryById(Long id) {
        return personRepository.findById(id);
    }

    @Override
    public List<Person> queryByAddr(String addr) {
        return personRepository.findAll((root, query, cb) -> cb.equal(root.get("address"), addr));
    }

    @Override
    public List<Person> queryByPhoneNum(String phoneNum) {
        return personRepository.findAll((root, query, cb) -> cb.equal(root.get("phoneNum"), phoneNum));
    }
}

7、测试类

PersonServiceImplTest.java

package com.lilian.service.mysql.impl;

import com.lilian.entity.mysql.Person;
import com.lilian.service.mysql.IPersonService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.List;

/**
 * jpa-demo
 *
 * @Author 孙龙
 * @Date 2018/7/4
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceImplTest {

    @Autowired
    private IPersonService personService;

    @Test
    public void batchAdd() {
        List<Person> personList = new ArrayList<Person>() {{
            add(new Person("李四", 25, "北京", "lisi@lll.com", new Timestamp(System.currentTimeMillis() - 10000L), "18844556222"));
            add(new Person("张三", 58, "济南", "zhangsan@lll.com", new Timestamp(System.currentTimeMillis() - 15000L), "16666555222"));
            add(new Person("老王", 14, "合肥", "laowang@lll.com", new Timestamp(System.currentTimeMillis() - 20000L), "11222213222"));
            add(new Person("赵六", 42, "广州", "zhaoliu@lll.com", new Timestamp(System.currentTimeMillis() - 30000L), "15555433322"));
            add(new Person("武大", 63, "上海", "wuda@lll.com", new Timestamp(System.currentTimeMillis() - 40000L), "18766676622"));
            add(new Person("孙五", 45, "石家庄", "sunwu@lll.com", new Timestamp(System.currentTimeMillis()), "1888888888"));

        }};
        personService.batchAdd(personList);
    }

    @Test
    public void queryById() {
        long id = 1L;
        List<Person> personList = personService.queryById(id);
        for (Person person : personList) {
            System.out.println(person);
        }
    }

    @Test
    public void queryByAddr() {
        String addr = "石家庄";
        List<Person> personList = personService.queryByAddr(addr);
        for (Person person : personList) {
            System.out.println(person);
        }
    }

    @Test
    public void queryByPhoneNum() {
        String phoneNum = "1888888888";
        List<Person> personList = personService.queryByPhoneNum(phoneNum);
        for (Person person : personList) {
            System.out.println(person);
        }
    }
}

---

Github代码示例
示例中包含Spring data jpa 对Mongo自定义接口的封装和使用