SpringBoot實現的JPA封裝了JPA的特性，只需要寫介面即可，但是有的時候約定的寫法不符合我們的開發要求，沒有很好的靈活性，這就需要我們自己去定義一下方法實現自己的封裝Repository。

借鑑網上配置：

1. 新增所需要的依賴包

<!-- spring-data-jpa程式的啟動項依賴，底層為hibernate實現，若不使用此框架則可以依賴其他的orm框架 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId
 
>spring-boot-starter-data-jpa</artifactId>
</dependency>

<!-- web程式的啟動項依賴，通過此依賴可引入內嵌的tomcat等web必須的jars -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

        <!-- mysql依賴，使用spring-data-jpa需要指定一個數據庫方言，用於連線資料庫，即mysql驅動 -->
 

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
</dependency>

1. 定義BaseRepository介面實現JPARepository介面

package com.redsoft.spirit.dao;

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

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

/**
 * @author
 
 楊雷
 *
 */
@NoRepositoryBean
public interface BaseRepository<T, ID extends Serializable> extends JpaRepository<T,ID>{
    public HashMap<String, Object> sqlQuery(String queryString, String countSql, Map<String, ?> values, int offset, int limit, String countName, String rowsName);

    public List<T> sqlQuery(String queryString, Map<String, ?> values);

    public List<T> sqlQuery(String queryString, Object ... values);

    public HashMap<String, Object> retrieve(String queryString, String countHql, Map<String, ?> values, int offset, int limit, String countName, String rowsName);
}

1. 定義BaseRepository的實現類，所有的DAO實現BaseRepository介面後，具體的實現方法由該實現類去操作。

package com.redsoft.spirit.dao;

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

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.springframework.data.jpa.repository.support.SimpleJpaRepository;
import org.springframework.util.Assert;

/**
 * dao的封裝類.
 * 
 * <pre>
 *  封裝一些涉及到原生sql的增刪改查分頁等功能
 * </pre>
 * 
 * @author 楊雷
 * @since 1.0
 *
 */
public class BaseRepositoryImpl<T, ID extends Serializable> extends SimpleJpaRepository<T, ID> implements BaseRepository<T, ID> {

    //父類沒有不帶引數的構造方法，這裡手動構造父類
    public BaseRepositoryImpl(Class<T> domainClass, EntityManager entityManager) {
        super(domainClass, entityManager);
        System.out.println("建構函式" + domainClass);
        this.entityManager = entityManager;
        this.entityClass = domainClass;
    }

    @PersistenceContext
    private EntityManager entityManager;

    private Class<T> entityClass;

    /**
     * 查詢分頁的方法.
     * <pre>
     *  帶著條件進行動態拼接sql的查詢方法
     * </pre>
     * 
     */
    @Override
    public HashMap<String, Object> sqlQuery(String queryString, String countSql, Map<String, ?> values, int offset,
            int limit, String countName, String rowsName) {

        Assert.hasText(queryString, "queryString不能為空");

        HashMap<String, Object> map = new HashMap<String, Object>();

        Query query = entityManager.createNativeQuery(queryString);
        Query countQuery = entityManager.createNativeQuery(countSql);

        //給條件賦上值
        if (values != null && !values.isEmpty()) {
            for (Map.Entry<String, ?> entry : values.entrySet()) {  
                query.setParameter(entry.getKey(), entry.getValue());
                countQuery.setParameter(entry.getKey(), entry.getValue());    
            } 
        }

        query.setFirstResult(offset);
        query.setMaxResults(limit);
        query.unwrap(SQLQuery.class).setResultTransformer(new BeanTransformerAdapter(this.entityClass));

        Object results = query.getResultList();
        Object resultsCount = countQuery.getSingleResult();

        map.put(countName, resultsCount);
        map.put(rowsName, results);

        return map;
    }

    @Override
    public List sqlQuery(String queryString, Map<String, ?> values) {
        Session session = entityManager.unwrap(org.hibernate.Session.class);
        SQLQuery query = session.createSQLQuery(queryString);

//      //給條件賦上值
//      if (values != null && !values.isEmpty()) {
//          for (Map.Entry<String, ?> entry : values.entrySet()) {  
//              query.setParameter(entry.getKey(), entry.getValue());
//          } 
//      }

        if (values != null) {
            query.setProperties(values);
          }

        query.setResultTransformer(new BeanTransformerAdapter(this.entityClass));

        return query.list();
    }

    @Override
    public List sqlQuery(String queryString, Object... values) {
        Query query = entityManager.createNativeQuery(queryString);
//      Session session = entityManager.unwrap(org.hibernate.Session.class);
//      SQLQuery query = session.createSQLQuery(queryString);


        if (values != null) {
            for (int i = 0; i < values.length; i++) {
              query.setParameter(i + 1, values[i]);
            }
          }

        query.unwrap(SQLQuery.class).setResultTransformer(new BeanTransformerAdapter(this.entityClass));

        return query.getResultList();
    }

    @Override
    public HashMap<String, Object> retrieve(String queryString, String countHql, Map<String, ?> values, int offset,
            int limit, String countName, String rowsName) {

        HashMap<String, Object> map = new HashMap<String, Object>();

        Query query = entityManager.createQuery(queryString);
        Query countQuery = entityManager.createQuery(countHql);

        //給條件賦上值
        if (values != null && !values.isEmpty()) {
            for (Map.Entry<String, ?> entry : values.entrySet()) {  
                query.setParameter(entry.getKey(), entry.getValue());
                countQuery.setParameter(entry.getKey(), entry.getValue());    
            } 
        }

        query.setFirstResult(offset);
        query.setMaxResults(limit);

        Object results = query.getResultList();
        Object resultsCount = countQuery.getSingleResult();

        map.put(countName, resultsCount);
        map.put(rowsName, results);

        return map;
    }
}

1. 新增將結果轉換成實體類的介面卡類

package com.redsoft.spirit.dao;

import java.beans.PropertyDescriptor;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.transform.ResultTransformer;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.NotWritablePropertyException;
import org.springframework.beans.PropertyAccessorFactory;
import org.springframework.beans.TypeMismatchException;
import org.springframework.dao.DataRetrievalFailureException;
import org.springframework.dao.InvalidDataAccessApiUsageException;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.support.JdbcUtils;
import org.springframework.util.StringUtils;

public class BeanTransformerAdapter<T>
  implements ResultTransformer
{
  private static final long serialVersionUID = 8149706114474043039L;
  protected final Log logger = LogFactory.getLog(getClass());
  private Class<T> mappedClass;
  private boolean checkFullyPopulated = false;

  private boolean primitivesDefaultedForNullValue = false;
  private Map<String, PropertyDescriptor> mappedFields;
  private Set<String> mappedProperties;

  public BeanTransformerAdapter()
  {
  }

  public BeanTransformerAdapter(Class<T> mappedClass)
  {
    initialize(mappedClass);
  }

  public BeanTransformerAdapter(Class<T> mappedClass, boolean checkFullyPopulated)
  {
    initialize(mappedClass);
    this.checkFullyPopulated = checkFullyPopulated;
  }

  public void setMappedClass(Class<T> mappedClass)
  {
    if (this.mappedClass == null) {
      initialize(mappedClass);
    }
    else if (!this.mappedClass.equals(mappedClass))
      throw new InvalidDataAccessApiUsageException("The mapped class can not be reassigned to map to " + 
        mappedClass + " since it is already providing mapping for " + this.mappedClass);
  }

  protected void initialize(Class<T> mappedClass)
  {
    this.mappedClass = mappedClass;
    this.mappedFields = new HashMap();
    this.mappedProperties = new HashSet();
    PropertyDescriptor[] pds = BeanUtils.getPropertyDescriptors(mappedClass);
    for (PropertyDescriptor pd : pds)
      if (pd.getWriteMethod() != null) {
        this.mappedFields.put(pd.getName().toLowerCase(), pd);
        String underscoredName = underscoreName(pd.getName());
        if (!pd.getName().toLowerCase().equals(underscoredName)) {
          this.mappedFields.put(underscoredName, pd);
        }
        this.mappedProperties.add(pd.getName());
      }
  }

  private String underscoreName(String name)
  {
    if (!StringUtils.hasLength(name)) {
      return "";
    }
    StringBuilder result = new StringBuilder();
    result.append(name.substring(0, 1).toLowerCase());
    for (int i = 1; i < name.length(); i++) {
      String s = name.substring(i, i + 1);
      String slc = s.toLowerCase();
      if (!s.equals(slc))
        result.append("_").append(slc);
      else {
        result.append(s);
      }
    }
    return result.toString();
  }

  public final Class<T> getMappedClass()
  {
    return this.mappedClass;
  }

  public void setCheckFullyPopulated(boolean checkFullyPopulated)
  {
    this.checkFullyPopulated = checkFullyPopulated;
  }

  public boolean isCheckFullyPopulated()
  {
    return this.checkFullyPopulated;
  }

  public void setPrimitivesDefaultedForNullValue(boolean primitivesDefaultedForNullValue)
  {
    this.primitivesDefaultedForNullValue = primitivesDefaultedForNullValue;
  }

  public boolean isPrimitivesDefaultedForNullValue()
  {
    return this.primitivesDefaultedForNullValue;
  }

  protected void initBeanWrapper(BeanWrapper bw)
  {
  }

  protected Object getColumnValue(ResultSet rs, int index, PropertyDescriptor pd)
    throws SQLException
  {
    return JdbcUtils.getResultSetValue(rs, index, pd.getPropertyType());
  }

  public static <T> BeanPropertyRowMapper<T> newInstance(Class<T> mappedClass)
  {
    BeanPropertyRowMapper newInstance = new BeanPropertyRowMapper();
    newInstance.setMappedClass(mappedClass);
    return newInstance;
  }

  public Object transformTuple(Object[] tuple, String[] aliases)
  {
    Object mappedObject = BeanUtils.instantiate(this.mappedClass);
    BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(mappedObject);
    initBeanWrapper(bw);

    Set populatedProperties = isCheckFullyPopulated() ? new HashSet() : null;
    for (int i = 0; i < aliases.length; i++) {
      String column = aliases[i];
      PropertyDescriptor pd = (PropertyDescriptor)this.mappedFields.get(column.replaceAll(" ", "").toLowerCase());
      if (pd == null) continue;
      try {
        Object value = tuple[i];
        try {
          bw.setPropertyValue(pd.getName(), value);
        } catch (TypeMismatchException e) {
          if ((value == null) && (this.primitivesDefaultedForNullValue))
            this.logger.debug("Intercepted TypeMismatchException for column " + column + " and column '" + 
              column + "' with value " + value + " when setting property '" + pd.getName() + "' of type " + pd.getPropertyType() + 
              " on object: " + mappedObject);
          else {
            throw e;
          }
        }
        if (populatedProperties != null)
          populatedProperties.add(pd.getName());
      }
      catch (NotWritablePropertyException ex) {
        throw new DataRetrievalFailureException("Unable to map column " + column + 
          " to property " + pd.getName(), ex);
      }

    }

    if ((populatedProperties != null) && (!populatedProperties.equals(this.mappedProperties))) {
      throw new InvalidDataAccessApiUsageException("Given ResultSet does not contain all fields necessary to populate object of class [" + 
        this.mappedClass + "]: " + this.mappedProperties);
    }

    return mappedObject;
  }

  public List transformList(List list)
  {
    return list;
  }
}

1. 擴充套件jpaRepository,讓所有的repository共享起自定義的方法。RepositoryFactoryBean負責返回一個RepositoryFactory，Spring Data Jpa將使用RepositoryFactory來建立Repository具體實現。

package com.redsoft.spirit.dao;

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;

/**
 * Created by konghao on 2016/12/7.
 */
public class BaseRepositoryFactoryBean<R extends JpaRepository<T, I>, T,
        I extends Serializable> extends JpaRepositoryFactoryBean<R, T, I> {

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

    @Override
    protected RepositoryFactorySupport createRepositoryFactory(EntityManager em) {
        return new BaseRepositoryFactory(em);
    }

    //建立一個內部類，該類不用在外部訪問
    private static class BaseRepositoryFactory<T, I extends Serializable>
            extends JpaRepositoryFactory {

        private final EntityManager em;

        public BaseRepositoryFactory(EntityManager em) {
            super(em);
            this.em = em;
        }

        //設定具體的實現類是BaseRepositoryImpl
        @Override
        protected Object getTargetRepository(RepositoryInformation information) {
            return new BaseRepositoryImpl<T, I>((Class<T>) information.getDomainType(), em);
        }

        //設定具體的實現類的class
        @Override
        protected Class<?> getRepositoryBaseClass(RepositoryMetadata metadata) {
            return BaseRepositoryImpl.class;
        }
    }
}

1. 主類上指定自己的工廠類

@SpringBootApplication
@EnableJpaRepositories(basePackages = {"com.redsoft"}, repositoryFactoryBeanClass = BaseRepositoryFactoryBean.class)//指定自己的工廠類

public class EPIPApplication extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(
            SpringApplicationBuilder application) {
        return application.sources(EPIPApplication.class);
    }

    public static void main(String[] args) throws InterruptedException {
        ApplicationContext ctx = SpringApplication.run(EPIPApplication.class, args);
    }
}