JavaWeb-Springboot集成JPA开箱即用

已于 2022-08-27 14:09:05 修改
阅读量303 收藏
点赞数
分类专栏： 博文 文章标签： spring boot java jpa maven
于 2020-12-30 11:30:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rothchil/article/details/111956894
版权

JPA

不知为什么在以前的一段时间内，我特别喜欢用 JPA ，它给我印象就是小巧灵便，为我省去了很多不必要的编码，带给我不一样的代码输出效率，因为业务在垂直划分过程中都相对来说封闭，要求在编码过程中相对来说实体关联没有那么复杂，而且项目本身的交付周期特别短，我就选择 JPA 作为我们某个特定项目的专用持久层框架，当然 JPA 自身的优势就不说啦。

项目架构目的就是为了高质量、低成本、更便捷的交付，也是我那段时间里秉承的思路。

下面言归正传，我们用我之前项目在springboot集成 JPA 来做一个演示。

1. POM

pom中引入 spring-boot-starter-data-jpa 依赖，注意版本。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
    <version>2.3.4.RELEASE</version>
</dependency>

2. 自定义Repository工厂类

JPA 默认工厂类 JpaRepositoryFactoryBean ，并不能满足我们实际要求，比如我们想在插入或者修改的适合做些事情，默认工厂类就不会支持，所以我们重写一个自己的，继承 JpaRepositoryFactoryBean即可。

JpaRepositoryFactoryBean工厂类

继承后重写 createRepositoryFactory 方法，指定我们自己的，这里我用一个内静态类来，这个内部类 BaseRepositoryFactory 也需要继承 JpaRepositoryFactory 工厂，此处我们指定自己真实的工厂类实现 BaseRepositoryImpl。


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

private static class BaseRepositoryFactory<T,I extends Serializable> extends JpaRepositoryFactory{

        private final EntityManager em;

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

        @Override
        protected JpaRepositoryImplementation<?, ?> getTargetRepository(RepositoryInformation information, EntityManager entityManager) {
            return new BaseRepositoryImpl<T, I>((Class<T>) information.getDomainType(), em);
        }


        /**
            *  设置具体的实现类的class
            * @param metadata
            * @return
            */
        @Override
        protected Class<?> getRepositoryBaseClass(RepositoryMetadata metadata) {
            return BaseRepositoryImpl.class;
        }
}

下面就可以在我们自己的类做我们的自己事情，同时我们实现类中抽象出来一个接口暴露对外，这个接口定义我们需要共用的方法，具体实现我们额外实现。这样设计有个好处，就是耦合度降低，扩展方便。

类之间关系图

  • 抽象接口
@NoRepositoryBean
@Transactional(readOnly=true,rollbackFor = Exception.class)
public interface BaseRepository<T, ID extends Serializable> extends JpaRepository<T, ID> {

    /**
     * 根据主键删除
     *
     * @param ids
     */
    void delete(ID[] ids);

    /**
     *
     * @param sql
     * @return
     */
    List<Object[]> listBySQL(String sql);

    public Long getTargetId(String sql);

    /**
     *
     * @param sql
     * @param args
     */
    @Transactional(rollbackFor = Exception.class)
    void updateBySql(String sql,Object...args);


    @Transactional(rollbackFor = Exception.class)
    void updateByHql(String hql,Object...args);

    Page<T> findCriteria(Specification<T> spec, Pageable pageable);

    int batchInsert(String sql);
  • 实现类
@SuppressWarnings({"unchecked"})
public class BaseRepositoryImpl<T, ID extends Serializable> extends SimpleJpaRepository<T, ID> implements BaseRepository<T, ID> {

	//
	private final EntityManager entityManager;

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

	@Override
	public void delete(ID[] ids) {

	}

	@Override
	public Long getTargetId(String sql) {
		Query query = entityManager.createNativeQuery(sql);
		return Long.valueOf(query.getSingleResult().toString());
	}

	@Override
	public void updateBySql(String sql, Object... args) {
		Query query = entityManager.createNativeQuery(sql);
		int i = 0;
		for(Object arg:args) {
			query.setParameter(++i,arg);
		}
		query.executeUpdate();
	}

	@Override
	public void updateByHql(String hql, Object... args) {
		Query query = entityManager.createQuery(hql);
		int i = 0;
		for(Object arg:args) {
			query.setParameter(++i,arg);
		}
		query.executeUpdate();
	}

	@Override
	public List<Object[]> listBySQL(String sql) {
		return entityManager.createNativeQuery(sql).getResultList();
	}

	@Override
	public int batchInsert(String sql) {
		Query query = entityManager.createNativeQuery(sql);
		return query.executeUpdate();
	}


	public Page<T> find(Class rootCls, CriteriaQuery<T> criteria, int pageNo, int pageSize) {

		//count
		CriteriaBuilder builder = entityManager.getCriteriaBuilder();
		CriteriaQuery criteriaC = builder.createQuery();
		Root root = criteriaC.from(rootCls);
		criteriaC.select(builder.count(root));
		criteriaC.where(criteria.getRestriction());
		List<Long> totals = entityManager.createQuery(criteriaC).getResultList();
		Long total = 0L;
		for (Long element : totals) {
			total += element == null ? 0 : element;
		}
		//content
		TypedQuery<T> query = entityManager.createQuery(criteria);
		query.setFirstResult((pageNo - 1) * pageSize);
		query.setMaxResults(pageSize);

		List<T> content = total > query.getFirstResult() ? query.getResultList() : Collections.<T> emptyList();
		Sort sort = Sort.by(Sort.Direction.DESC, Constant.DEFAULT_SORT);
		Pageable pageable = PageRequest.of(pageNo, pageSize, sort);
		Page<T> pageRst = new PageImpl<T>(content, pageable, total);
		return pageRst;

	}

	@Override
	public Page<T> findCriteria(Specification<T> spec, Pageable pageable){
		  return super.findAll(spec,pageable);
	}

}

3. 抽象实体基类

实例基类，必须要实现一个接口 Persistable ，这个接口只定义ID主键。当然我们自己的基类也会定义这个，但是这并不冲突。

@MappedSuperclass
public abstract class AbsEntity<ID extends Serializable> extends AbstractEntity<ID> implements Persistable<ID> {

	private static final long serialVersionUID = 1L;

	@Override
	public abstract ID getId();

    /**
     * Sets the id of the entity.
     * @param id the id to set
     */
    public abstract void setId(final ID id);
    //......
}

4. 抽象Service基类

抽象 Service 提供基础业务类的功能。

/** Service基类
 * @ClassName BaseService
 * @Description
 * @author WCNGS@QQ.COM
 * @Github <a>https://github.com/rothschil</a>
 * @date 20/12/18 11:05
 * @Version 1.0.0
*/
public abstract class BaseService<T extends AbsEntity<?>, ID extends Serializable> {

    protected JpaRepository<T, ID> jpaRepository;

    public BaseService() {}

    /** 重要 **/
    public abstract void setJpaRepository(JpaRepository<T, ID> jpaRepository);

    public boolean retBoolFindByExample(T t){
        ExampleMatcher matcher = ExampleMatcher.matching();
        List<String> fields = new ArrayList<String>();
        Reflections.getField(t,fields);
        for (String fld: fields){
            matcher.withMatcher(fld,ExampleMatcher.GenericPropertyMatchers.exact());
        }
        Example<T> example = Example.of(t,matcher);
        if(jpaRepository.findAll(example).size()>0){
            return true;
        }
        return false;
    }

    public boolean retBoolSave(T t ){
        try{
            this.save(t);
            return true;
        }catch (RuntimeException re){
            return false;
        }
    }

    public List<T> findByProperty(T t,String propertyName, Object value) {
        try {
            Class<?> cls = t.getClass();
            Field[] fields = cls.getDeclaredFields();
            Method[] methods = cls.getDeclaredMethods();
            for (int i=0;i<fields.length;i++) {
                if(fields[i].getName().equals(propertyName)){
                    String fieldSetName = StringUtils.parSetName(fields[i].getName());
                    for (Method met : methods) {
                        if (fieldSetName.equals(met.getName())) {
                            met.invoke(t,value);
                        }
                    }
                }
            }
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (NumberFormatException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return findByEntity(t);
    }

    public boolean retBoolDelete(T t) {
        try {
            this.delete(t);
            return true;
        } catch (RuntimeException re) {
            return false;
        }
    }

    public List<T> findByEntity(T t) {
        ExampleMatcher matcher = ExampleMatcher.matching();
        List<String> fields = new ArrayList<String>();
        Reflections.getField(t,fields);
        for (String fld: fields){
            matcher.withMatcher(fld,ExampleMatcher.GenericPropertyMatchers.exact());
        }

/*                .withMatcher("username", ExampleMatcher.GenericPropertyMatchers.startsWith())
                .withMatcher("address" ,ExampleMatcher.GenericPropertyMatchers.contains())
                .withIgnorePaths("password");*/

        Example<T> example = Example.of(t,matcher);
        return jpaRepository.findAll(example);
    }

    public Page<T> findPageByEntity(int page, int size, T t) {
        size=size==0?10:size;
        // TODO Auto-generated method stub
        Pageable pageable = PageRequest.of(page, size);
        ExampleMatcher matcher = ExampleMatcher.matching();
        List<String> fields = new ArrayList<String>();
        Reflections.getField(t,fields);
        for (String fld: fields){
            matcher.withMatcher(fld,ExampleMatcher.GenericPropertyMatchers.exact());
        }

/*                .withMatcher("username", ExampleMatcher.GenericPropertyMatchers.startsWith())
                .withMatcher("address" ,ExampleMatcher.GenericPropertyMatchers.contains())
                .withIgnorePaths("password");*/

        Example<T> example = Example.of(t,matcher);
        return jpaRepository.findAll(example,pageable);
    }

    /**
     * 保存单个实体
     *
     * @param t 实体
     * @return 返回保存的实体
     */
    public T save(T t) {
        return jpaRepository.save(t);
    }

    public T saveAndFlush(T t) {
        t = save(t);
        jpaRepository.flush();
        return t;
    }


    /**
     * 根据主键删除相应实体
     *
     * @param id 主键
     */
    public void delete(ID id) {
        jpaRepository.delete(findOne(id));
    }

    /**
     * 删除实体
     *
     * @param t 实体
     */
    public void delete(T t) {
        jpaRepository.delete(t);
    }



    /**
     * 按照主键查询
     *
     * @param id 主键
     * @return 返回id对应的实体
     */
    public T findOne(ID id) {
        return jpaRepository.getOne(id);
    }


    /**
     * 实体是否存在
     * @method      exists
     * @author      WCNGS@QQ.COM
     * @version
     * @see
     * @param id                id 主键
     * @return      boolean   存在 返回true，否则false
     * @exception
     * @date        2018/7/3 22:08
     */
    public boolean exists(ID id) {
        return findOne(id)==null?true:false;
    }


    /**
     * 统计实体总数
     * @method      count
     * @author      WCNGS@QQ.COM
     * @version
     * @see
     * @param
     * @return      long
     * @exception
     * @date        2018/7/3 22:07
     */
    public long count() {
        return jpaRepository.count();
    }


    /**
     * 查询所有实体
     * @method      findAll
     * @author      WCNGS@QQ.COM
     * @version
     * @see
     * @param
     * @return      java.utils.List<T>
     * @exception
     * @date        2018/7/3 22:07
     */
    public List<T> findAll() {
        return jpaRepository.findAll();
    }

    /**
     * 按照顺序查询所有实体
     * @method      findAll
     * @author      WCNGS@QQ.COM
     * @version
     * @see
     * @param sort
     * @return      java.utils.List<T>
     * @exception
     * @date        2018/7/3 22:06
     */
    public List<T> findAll(Sort sort) {
        return jpaRepository.findAll(sort);
    }


    /**
     * 分页及排序查询实体
     *
     * @param pageable 分页及排序数据
     * @return
     */
    public Page<T> findAll(Pageable pageable) {
        return jpaRepository.findAll(pageable);
    }

    public Page<T> findEntityNoCriteria(Integer page, Integer size) {
        Pageable pageable = PageRequest.of(page, size);
        return findAll(pageable);
    }

}

5. 如何使用？

5.1. 继承实体基类

用 lombok 一目了然，对应字段名以及列与属性对应关系，代码整体简洁。

@EqualsAndHashCode(callSuper=false)
@Builder(toBuilder=true)
@Data
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(name="tb_locations")
public class Location extends AbsEntity<Long> {

    @Id
    @Column(name = "id", nullable = false)
    private Long id;

    @Column(name = "flag")
    private String flag;

    @Column(name = "local_code")
    //省略....
}
5.2. 继承repository基类

直接继承就完事，方法命名的书写，有些讲究，这里就不单独说明，有兴趣童鞋自行恶补。

public interface LocationRepository extends BaseRepository<Location, Long>,JpaSpecificationExecutor<Location> {

    List<Location> findByLv(int lv);
    //省略....
}
5.3. 继承Service基类

需要引入我们 locationRepository ，这一步很关键，当然我看有的人将引入的 Repository 弄在类泛型中，效果一样。

@Service(value="locationService")
@Transactional(readOnly = true)
public class LocationService extends BaseService<Location, Long> {

	private LocationRepository locationRepository;

	@Autowired
	@Qualifier("locationRepository")
	@Override
	public void setJpaRepository(JpaRepository<Location, Long> jpaRepository) {
		this.jpaRepository=jpaRepository;
		this.locationRepository =(LocationRepository)jpaRepository;
	}

	public List<Location> getLocationListByLevel(int lv){
		return locationRepository.findByLv(lv);
	}
}
5.4. 启动类

因为我们自定义了工厂类，所以我们的启动类需要将我们工厂类引入进来，所以 repositoryFactoryBeanClass 属性需要了解下。
这样子 springboot 整合 JPA 就完啦。

@EnableSwagger2
@EnableJpaAuditing
@SpringBootApplication
@EnableJpaRepositories(basePackages = {"xyz.wongs.drunkard"},
        repositoryFactoryBeanClass = BaseRepositoryFactoryBean.class//Specify your own factory class
)
public class MoonApplication {

    public static void main(String[] args) {
        SpringApplication.run(MoonApplication.class,args);
    }

}

EnableJpaRepositories中指定工厂类

6. 源码地址，如果觉得对你有帮助，请Star

觉得对你有帮助，请Star

Github源码地址

Gitee源码地址

王老邪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
javaWeb-springboot+mybatis+materializecss 图书销售系统
05-17
该项目利用了基于springboot + vue + mysql的开发模式框架实现的课设系统，包括了项目的源码资源、sql文件、相关指引文档等等。 【项目资源】：包含前端、后端、移动开发、操作系统、人工智能、物联网、信息化管理...
Spring系列之事务、@Transactional原理及失效场景
lonelymanontheway的博客
05-03 790
Spring事务类型；
@NoRepositoryBean的作用（JPA）
weixin_45394439的博客
06-23 3536
在服务器启动的时候，jpa的启动管理类会自动扫荡继承了JpaRepository的接口，然后添加到动态代理管理中，然后注入到spring的容器中。 @NoRepositoryBean注解确保添加了该注解的 repository 接口不会在运行时被创建实例。 也就是说，使用了该注解的接口不会被单独创建实例，只会作为其他接口的父接口而被使用。 ...
基于JPA封装的BaseService
ぃ慕容ぅ
09-11 3906
JPA-快速开始 我们将通过一个简单的 Demo 来阐述 BaseService 的强大功能，在此之前，我们假设您已经： 拥有 Java 开发环境以及相应 IDE 熟悉 Spring Boot 熟悉 Maven 配置 在 xxxService 类上继承BaseService： @Service public class TestService extends BaseService<M...
springboot与Jpa整合
沉浮
06-15 1643
对springboot的使用也是有一段时间了，在使用上确实简化了很多，也可以让一个刚入门的人迅速搭建一套开发环境来，但是随之而来的问题也比较显著，当框架本身无法满足需求或者需要在原有的基础上进行扩展，对原有的模块进行选择性的使用等等，都会带来巨大的麻烦，由于框架帮助我们预先定制了很多可能是比价不错的配置方式，但这些默认的，而这些约定的东西，我们理解多少，哪些复杂的构建关系又如何一眼看穿，所以效率提...
基于javaWeb-springboot+mybatis+materializecss 图书销售系统，全栈web开发学习，毕设
06-20
基于javaWeb-springboot+mybatis+materializecss 图书销售系统，全栈web开发学习，毕设 基于javaWeb-springboot+mybatis+materializecss 图书销售系统，全栈web开发学习，毕设 基于javaWeb-springboot+mybatis+...
javaWeb-springboot+mybatis+materializecss 图书销售系统.zip
最新发布
03-26
基于springboot的程序源码及相关信息
<项目经验> 基于jpa封装BaseDao,BaseService
weixin_33979363的博客
03-28 2461
2019独角兽企业重金招聘Python工程师标准>>> ...
java中JPA框架的集成
04-07
JPA框架的集成使用 package com.itcast.bean.product; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; @Entity public class ProductType { private Integer typeid ; @Id @GeneratedValue(strategy=GenerationType.AUTO) public Integer getTypeid() { return typeid; } public void setTypeid(Integer typeid) { this.typeid = typeid; } }
Spring使用JavaConfig集成JPA简单例子
05-17
Spring使用JavaConfig集成JPA简单例子，对应博文地址为http://blog.csdn.net/wu_boy/article/details/72353608
springboot + JPA
CaBCo的博客
12-16 1712
关于ORM框架的选择，左手mybatis，右手JPA，孰优孰劣，该如何选择？
利用泛型封装通用的service层
热门推荐
瓦力-眼观世界
06-22 1万+
身为一名开发人员,大家都知道,我们经常会在项目中大量的编写许多重复的代码,比如说public Entity find(String id);像这种代码,简单,但是写多了,可能也会容易出错,那么我们能不能直接编写一套完整的,通用的方法呢,这样既不用重复编写,还不用出错,说道通用的方法,泛型是个不错的选择.基础架构:spring-boot+spring mvc+spring jpa.jpa是个好东西,...
springboot jpa搭建开发环境（一）
chuanyuan8669的博客
04-03 116
随着spring4的出现，也为springboot奠定了基础，其实在了解spring4原理与一些扩展的同时，我们也就可以很方便搭建开发环境，而springboot就是使用了4中的一些新特性与功能，将我们搭建的过程进行了记录，同时通过一些特有的检测机制，实现各种环境的自由选择预搭配，将需要配置的...
Spring JPA 部分字段更新，灵活控制字段更新、支持（设定：可更新字段、不可更新字段）
刘贤松的博客
06-29 8646
Spring JPA 部分字段更新，灵活控制字段更新、支持（设定：可更新字段、不可更新字段） 目录 一、创建 实体类User.java 二、编写基础BaseRepository.class 三、编写UserRepository.class 继承BaseRepository 四、创建BaseService.class 五、创建UserService 继承BaseService 编写业务代码： 六、UserService 进行编写业务代码 七、创建控制器调用 测试 ...
SpringDataJpa02
weixin_46002365的博客
12-13 155
一.后台支持(dao与service) 1.1 Repsitory 1.1.1 抽取父类Repsitory @NoRepositoryBean:让Spring管理的时候不要为它创建实现 注意事项 父类的Repsitory要加注释@NoRepositoryBean 让spring不要创建实体类 继承了JpaRepository和JpaSpecificationExecutor 类上必须加上<T...
SpringBoot整合通用mapper实现泛型BaseController增删改
forever_xw_的博客
04-16 6365
SpringBoot整合通用mapper实现泛型BaseController增删改 前言：目前写项目做需求时增删改查一直用得比较频繁，但是在做开发的时候，却并不想一次一次写重复的代码，尝试着整合了一下泛型实现统一增删改。 一.开发环境： JDK：1.8 SpringBoot：2.4.4 二.加入依赖（所用到的是tk.mybatis中的通用mapper） <!--swaggerUi--> <dependency>
javaweb结合springboot
02-26
JavaWeb是一种使用Java语言开发Web应用程序的技术。而Spring Boot是一个基于Spring框架的快速开发Web应用程序的工具。 将JavaWeb与Spring Boot结合使用，可以提高Web应用程序的开发效率和可维护性。Spring Boot提供...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

王老邪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值