Spring Data JPA 整合

已于 2024-09-12 21:27:03 修改
阅读量1.1k 收藏 19
点赞数 26
分类专栏： spring-boot 文章标签： spring boot java restful 后端
于 2023-12-01 07:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62943934/article/details/134696432
版权

目录

前言

正文 

1.Spring Data JPA 导入项目和配置 

2.Spring Data JPA 的 CRUD 实例 

3.Spring Data JPA 扩展封装 

总结

前言

JPA 全称是 Java Persistence API ，意思是 Java 持久层 API 接口。而 Spring Data JPA 是一套 ORM（对象关系映射）标准，关于这套标准的实现 ORM 框架很多，如大名鼎鼎的 Hibernate 。实际上是先有 Hibernate ，再有的 JPA 标准 。而这里推荐的是 Spring Boot 的实现，也就是 Spring Data。

正文 

Spring Data 算是 Spring 官配的项目，用于简化数据库相关操作，通过封装来减少冗余的代码，让数据库访问和操作变得非常简单。

1.Spring Data JPA 导入项目和配置 

首先创建用于测试的数据库，SQL 如下。

create database  `test_jpa` default character set utf8;

添加 MySQL 和 Spring Data JPA 相关依赖包，pom.xml 代码如下。

        <!--        阿里数据库连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.23</version>
        </dependency>
        <!--        mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>

然后设置好数据库的配置，配置 application.yml 代码。 

server:
  port: 8080
spring:
  redis:
    host: 127.0.0.1
    port: 6379
    database: 0
    jedis:
      pool:
        max-active: 50
        max-idle: 20
        max-wait: 3000
        min-idle: 2
    timeout: 5000
  datasource:
    url: jdbc:mysql://localhost:3306/test_jpa?useTimezone=true&serverTimezone=UTC
    type: com.alibaba.druid.pool.DruidDataSource
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
    druid:
      # 初始化时建立物理连接的个数
      initial-size: 5
      # 最小连接数量
      min-idle: 5
      # 最大活跃连接池数量
      max-active: 20
      # 请求连接池在分配连接时，是否先检查该连接是否有效，建议设置成true。
      test-while-idle: true
      # 程序申请连接的时候，是否进行连接有效性检查，建议设置成false。
      test-on-borrow: false
      # 程序返还连接的时候，是否进行连接有效性检查，建议设置成false。
      test-on-return: false
      # 是否使用PSCache，对于mysql的性能提升不明显，对oracle效果更好。
      pool-prepared-statements: false
      # 获取连接的最大等待时间，单位是毫秒。
      max-wait: 60000
      # 检查空闲连接的频率，单位毫秒, 非正整数时表示不进行检查
      time-between-eviction-runs-millis: 60000
      # 池中某个连接的空闲时长达到 N 毫秒后, 连接池在下次检查空闲连接时，将回收该链接，然后设置要小于防火墙的超时设置
      min-evictable-idle-time-millis: 30000
      # 设置插件
      filters: stat
      # 是否异步初始化
      async-init: true
      # 连接属性设置
      connection-properties: druid.stat.mergeSql=true;druid.stat.SlowSqlMills=5000



  # 设置实体类中的字段自动变成对应的数据库中下划线字段
  jpa:
    database: mysql
    hibernate:
      naming:
        # 需要安装hibernate相关依赖   开启驼峰命名
        physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
      # 是否自动创建表，设置为update则说明如果表存在则更新
      ddl-auto: none
    #physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

2.Spring Data JPA 的 CRUD 实例 

为了后续演示，创建一个英雄表 ，建表代码如下。

create TABLE `tm_heros`
(
    `id` int(10) unsigned NOT NULL  auto_increment comment '主键ID',
    `name` varchar(80) NOT NULL comment '英雄名称',
    `role_type` varchar(60) NOT NULL comment '类型，如：射手、法师、游走',
    `attack_value` int(11) NOT NULL comment '攻击力，单位 1HP，最大值为1000',
    `version` varchar(50) NOT NULL comment '版本，如：v1.2.0',
    `created` int(11) not null comment '创建时间，时间戳',
    primary key (`id`)
)ENGINE=InnoDB DEFAULT CHARSET=utf8;

基于该表，开始编写对应的实体类，命名为 Hero.java 。 

package org.example.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;

@Entity(name = "tm_heros")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Hero {
    //主键 ID
    @Id
    private int id;
    //英雄名称
    private String name;
    //角色类型，如：射手、法师
    @Column(name = "role_type")
    private String roleType;
    //攻击力 0 - 1000 的整数
    @Column(name = "attack_value")
    private int attackValue;
    //版本 如v1.0.2
    private String version;
    //创建时间
    private int created;
}

编写 HeroDao 接口，继承自 JpaRepository 接口。

import org.example.entity.Hero;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;

import java.util.List;

public interface HeroDao extends JpaRepository<Hero,Integer> {
    @Override
    List<Hero> findAll();
    //sql like : select * from tm_hero where name like "%name%"
    List<Hero> getHeroByNameContaining(String name);//根据方法名自动实现sql
    //获取最新的英雄，根据创建时间（自定义）
    @Query(value = "select * from tm_heros where created = (select max(created) from tm_heros)",nativeQuery = true)
    Hero getLateHero();

}

POM依赖 

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
        </dependency>

JpaRepository 中提供了不少封装好的基础方法，例如 CURD 和一些分页排序功能。findAll() 就是一个获取所有数据的方法，只需重写该方法即可。 

而一些方法的命名也是有规律可以遵循的。

  1.  And 系列，findByNameAndRoleType 方法对应的 SQL 是 "where name =? and role_type=?"。
  2. Or 系列，findByNameOrRoletype 方法对应的 SQL 是  "where name =? or role_type=?"。
  3. Equals 系列，findByVersionEquals 对应的 SQL 是 "where Version=?"。
  4. Is 系列，findByNames 对应的是 SQL 是 "where name=？"。
  5. Between --- 等价于 SQL 中的 between 关键字，比如 findBySalaryBetween(int max, int min)；
  6. LessThan --- 等价于 SQL 中的 "<"，比如 findBySalaryLessThan(int max)；
  7. GreaterThan --- 等价于 SQL 中的">"，比如 findBySalaryGreaterThan(int min)；
  8. IsNull --- 等价于 SQL 中的 "is null"，比如 findByUsernameIsNull()；
  9. IsNotNull --- 等价于 SQL 中的 "is not null"，比如 findByUsernameIsNotNull()；
  10. NotNull --- 与 IsNotNull 等价；
  11. Like --- 等价于 SQL 中的 "like"，比如 findByUsernameLike(String user)；
  12. NotLike --- 等价于 SQL 中的 "not like"，比如 findByUsernameNotLike(String user)；
  13. OrderBy --- 等价于 SQL 中的 "order by"，比如 findByUsernameOrderBySalaryAsc(String user)；
  14. Not --- 等价于 SQL 中的 "！ ="，比如 findByUsernameNot(String user)；
  15. In --- 等价于 SQL 中的 "in"，比如 findByUsernameIn(Collection<String> userList) ，方法的参数可以是 Collection 类型，也可以是数组或者不定长参数；
  16. NotIn --- 等价于 SQL 中的 "not in"，比如 findByUsernameNotIn(Collection<String> userList) ，方法的参数可以是 Collection 类型，也可以是数组或者不定长参数；

还有更多既定的命名规则可以参考官方文档。由于这些既定的方法比较局限，不一定能满足所有的开发需求。所以 Spring Data JPA 也支持原生 SQL 自定义，如之前编写的获取最新英雄的查询。

如果涉及修改数据时，则要使用 @Modifying 注解。

继续编写 Service 。 

package org.example.service;

import org.example.dao.HeroDao;
import org.example.entity.Hero;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class HeroService {
    @Autowired
    HeroDao heroDao;
    //添加英雄
    public void addHero(Hero hero){
        heroDao.save(hero);
    }

    //分页获取英雄列表
    public Page<Hero> getHeroByPage(Pageable pageable){
        return heroDao.findAll(pageable);
    }

    //根据名称查询英雄数据
    public List<Hero> getHerosByNameStartingWith(String name){
        return heroDao.getHeroByNameContaining(name);
    }

    //获取最新被创建的英雄
    public Hero getLatestHero(){
        return heroDao.getLateHero();
    }
}

其中 save 方法是 JpaRespository 自带的，用于存储数据。而分页时传递 Pageable 对象就可以实现。该对象包含了总记录数、总页数、每页记录数等。 

创建 Controller 文件，命名为 HeroController.java ，具体实现如下。

package org.example.controller;

import org.example.entity.Hero;
import org.example.service.HeroService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class HeroController {
    @Autowired
    HeroService heroService;
    @GetMapping("/findAllHeros")
    public Page<Hero> findAll(){
        // 第二页 2页（从0开始计数） 每页大小最大为 3
        PageRequest pageable = PageRequest.of(2,3);
        Page<Hero> page = heroService.getHeroByPage(pageable);
        return page;
    }

    //查询
    @GetMapping("/findHeroesByName")
    public List<Hero> searchHerosByName(@PathVariable String name){
        List<Hero> heroes = heroService.getHerosByNameStartingWith(name);
        return heroes;
    }

    @GetMapping("/getLatestHero")
    public Hero getLatesHero(){
        return heroService.getLatestHero();
    }
}

别忘了 hibernate 依赖，不然可能无法启动，例如：dao that could not be found。

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
        </dependency>

成功运行。 

3.Spring Data JPA 扩展封装 

Spring Data JPA 的扩展，其实就是对于 dao 层代码的扩展，因为所有 dao 层接口都是继承自 JpaRespository 接口，再不添加更多代码就能继承默认的方法。然后很多时候，由于业务需要，开发者需要编写很多自定义的数据库操作方法，这就是扩展封装。 

这种封装一般有以下两种：

  • 一是封装成一个自定义的扩展实现类，去实现之前编写好的 Dao 层接口。命名方面是 EntityNameRespositoryImpl 格式，并把相应的方法实现。
  • 二是直接在 Dao 层接口中添加自定义的方法，针对业务需求自行定义方法名和参数，同时在相应的 Mapper 文件中编写 SQL 语句来实现该方法。这种封装方式更加灵活，但也需要开发者对 SQL 语句的编写有一定的熟练度。其中，命名方式可以是在原先的方法名上添加一些前缀、后缀或其他修饰词。

由于编写了 HeroDao.java ，那么基于 HeroDao 进行封装。

package org.example.dao.impl;

import org.example.dao.HeroDao;
import org.example.entity.Hero;
import org.springframework.data.domain.Example;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;

import java.util.List;
import java.util.Optional;

public class HeroRespositoryImpl implements HeroDao {

    @Override
    public List<Hero> findAll() {
        // other codes
        return findAll();
    }

    @Override
    public List<Hero> findAll(Sort sort) {
        return null;
    }

    @Override
    public Page<Hero> findAll(Pageable pageable) {
        return null;
    }

    @Override
    public List<Hero> findAllById(Iterable<Integer> iterable) {
        return null;
    }

    @Override
    public long count() {
        return 0;
    }

    @Override
    public void deleteById(Integer integer) {

    }

    @Override
    public void delete(Hero hero) {

    }

    @Override
    public void deleteAll(Iterable<? extends Hero> iterable) {

    }

    @Override
    public void deleteAll() {

    }

    @Override
    public <S extends Hero> S save(S s) {
        return null;
    }

    @Override
    public <S extends Hero> List<S> saveAll(Iterable<S> iterable) {
        return null;
    }

    @Override
    public Optional<Hero> findById(Integer integer) {
        return Optional.empty();
    }

    @Override
    public boolean existsById(Integer integer) {
        return false;
    }

    @Override
    public void flush() {

    }

    @Override
    public <S extends Hero> S saveAndFlush(S s) {
        return null;
    }

    @Override
    public void deleteInBatch(Iterable<Hero> iterable) {

    }

    @Override
    public void deleteAllInBatch() {

    }

    @Override
    public Hero getOne(Integer integer) {
        return null;
    }

    @Override
    public <S extends Hero> Optional<S> findOne(Example<S> example) {
        return Optional.empty();
    }

    @Override
    public <S extends Hero> List<S> findAll(Example<S> example) {
        return null;
    }

    @Override
    public <S extends Hero> List<S> findAll(Example<S> example, Sort sort) {
        return null;
    }

    @Override
    public <S extends Hero> Page<S> findAll(Example<S> example, Pageable pageable) {
        return null;
    }

    @Override
    public <S extends Hero> long count(Example<S> example) {
        return 0;
    }

    @Override
    public <S extends Hero> boolean exists(Example<S> example) {
        return false;
    }

    @Override
    public List<Hero> getHeroByNameContaining(String name) {
        if (name == "test") {
            return null;
        }
        return getHeroByNameContaining(name);
    }

    @Override
    public Hero getLateHero() {
        return null;
    }
}

根据业务封装基类接口，如一个公共开发使用的接口，命名为 BaseRespository.java 。

package org.example.dao;

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;

@NoRepositoryBean
public interface BaseRespository<T,ID extends Serializable> extends JpaRepository<T,ID>, JpaSpecificationExecutor<T> {
    /**
     * 查询多个属性
     * 返回 List<Object> 对象形式的 List
     *
     * @param sql 原生 SQL 语句
     * @param obj Class 格式对象
     * @return
     */
    List sqlObjectList(String sql,Object obj);

    /**
     * 查询多个属性
     * 返回 List<Object[]> 数组形式的 List
     * 
     * @param sql 原生 sql语句
     * @return
     */
    List<Object[]> sqlArrayList(String sql);

    /**
     * 查询单个个数
     * 返回 List<Object> 对象形式的List
     * @param sql 原生 SQL 语句
     * @return
     */
    List sqlStringleList(String sql);
}

其中，@NoRepositoryBean 注解说明这个接口不是一个标准的 Repository ，Spring 不会把它当作一个 Repository 处理，使其不要被 Spring Data JPA 自动扫描并创建相应的仓库实现。这个接口也继承了  JpaSpecificationExecutor ，可以使用 Specification 的复杂查询方式。

进一步可以编写实现 BaseRespository 的类，命名为：MyBaseJpaRepository.java 。

package org.example.dao.impl;

import org.example.dao.BaseRespository;
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 的接口实现类
 *
 * @param <T>
 * @param <ID>
 */
public class MyBaseJpaRepository<T, ID extends Serializable> extends SimpleJpaRepository<T, ID> implements BaseRespository<T, ID> {
    private final EntityManager entityManager;
    private Class<T> myclass;

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

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

    //略
    @Override
    public List<Object[]> sqlArrayList(String sql) {
        return null;
    }

    //略
    @Override
    public List sqlStringleList(String sql) {
        return null;
    }
}

在实际工作中只需要编写 JPA 接口去阶乘这个 MyBaseJpaRepository 类就可以实现业务的需要。

Spring Data JPI 封装了许多接口，可以提供默认的 CURD 和数据库操作方法。如果在业务不复杂的 RESTful API 下，完全可以使用原生的 JpaRepository 或者 CrudJpaRepository 接口来编写接口即可。

如果业务更加复杂的情况下，可以考虑通过编写扩展接口来实现个性化的需求。Spring Data JPA 作为一款封装良好的 JPA 实现框架，可以很好地减少冗余代码，让开发者不必过多地去关注数据库持久层的底层操作和管理。

常用接口的继承关系

补充 

JpaSpecificationExecutor 是 Spring Data JPA 提供的一个扩展接口，用于支持基于 Criteria API 的动态查询。

JpaSpecificationExecutor 接口中定义了一个 Specification 接口和一组相关的查询方法。

Specification 接口表示一个查询规范，可以用于构建动态查询条件。你可以在查询方法中传入Specification 对象来指定查询规范，从而查询符合要求的数据。

以下是一个使用 JpaSpecificationExecutor 的示例：

public interface CarRepository extends JpaRepository<Car, Long>, JpaSpecificationExecutor<Car> {
}

public class CarSpecification {
    public static Specification<Car> withModel(String model) {
        return (root, query, cb) -> cb.equal(root.get("model"), model);
    }

    public static Specification<Car> withColor(String color) {
        return (root, query, cb) -> cb.equal(root.get("color"), color);
    }
}

public class CarService {

    @Autowired
    private CarRepository carRepository;

    public List<Car> findCarsByCriteria(String model, String color) {
        Specification<Car> spec = Specification.where(null);
        if (model != null && !model.isEmpty()) {
            spec = spec.and(CarSpecification.withModel(model));
        }
        if (color != null && !color.isEmpty()) {
            spec = spec.and(CarSpecification.withColor(color));
        }
        return carRepository.findAll(spec);
    }
}

在这个例子中，CarRepository 继承了 JpaRepository 和 JpaSpecificationExecutor 接口，就可以使用 findAll(Specification) 方法进行动态查询。

CarSpecification 类定义了两个 Specification 对象：withModel 用于匹配指定车型，withColor 用于匹配指定颜色。这些 Specification 对象可以组合起来，用于构建复杂的查询条件。

在 CarService 类中，我们可以通过传入 model 和 color 参数来动态构建查询条件，并通过 findAll(spec) 方法查询符合条件的数据。

总之，JpaSpecificationExecutor 接口是 Spring Data JPA 提供的一个扩展接口，用于支持基于 Criteria API 的动态查询。通过使用 Specification 接口，你可以组合多个查询条件，构建高度动态的查询语句。 

总的来说，JpaSpecificationExecutor 接口的动态查询机制确实与 builder 模式有些类似，都是通过组合多个条件构建细粒度的对象。 

总结

通过简单的介绍，我们已经简单的对 JPA 有了基本的了解。 

duration～
关注
专栏目录
Spring Data Jpa整合PostgreSQL（一）
有道无德的博客
03-15 8725
直接看2吧。。 ================== 自己写的时候遇到很多问题,总结一下,分享出来,留作记录 只是简单的实现,以后会尝试PostgreSQL的更多特性 安装PostgreSQL : 可选方案是在你的系统环境下安装官方提供的安装包,或是运行Docker镜像.我使用的版本为10.3 Spring Boot版本暂不可以为2.0,原因是不兼容当前驱动版本.我使用的是1.5.9.R...
Springboot jpa使用sum()函数返回结果如何接收
ununie的博客
08-01 2万+
1、需求 我的需求是统计域名以及域名出现的次数。 之前使用springboot jpa都是把数据库中的表跟实体类绑定，创建继承JpaRepository的接口。如下： @Repository public interface UrlsRepository extends JpaRepository<Urls, String> { Optional<Urls&...
SpringDataJPA
GuanHao的博客
06-28 687
注解的方式 更新删除等事务操作需要加上Transactional 方式一 @Transactional @Modifying(clearAutomatically = true) @Query(value = "UPDATE User u SET u.status =?1 WHERE u.id = ?2") Integer updateStatusById(String status, Lo...
Spring Data JPA
只有变秃 才能变强
12-08 1974
首先了解 JPA 是什么？JPA（Java Persistence API）是 Sun 官方提出的 Java 持久化规范。 它为 Java 开发人员提供了一种对象/关联映射工具来管理 Java 应用中的关系数据。它的出现主要是为了简化现有的持久化开发工作和整合 ORM 技术， 结束现在 Hibernate、TopLink、JDO 等 ORM 框架各自为营的局面。 值得注意的是，JPA 是在充分
springdata+jpa 个人学习记录过程，开发步骤，教程
lcb611118的博客
04-25 237
springdata 这篇笔记没有任何知识点，只是本人入门的学习过程，如果有错误，欢迎大家指出改进！ 1、新建maven项目，导入pom依赖 依赖就不啰嗦了 2、Web.Xml 导入配置 <context-param> <param-name>contextConfigLocation</param-name> <param-value&gt...
SpringDataJpa和jpa-spe插件
SaoLife的博客
09-28 422
什么是SpringDataJpa: 就是对jpa进行封装，从而形成的一个框架。封装之后，使用更加简单 SpringDataJpa需要的jar包 <!-- SpringData的支持包 --> <dependency> <groupId>org.springframework.data</groupId> ...
SpringData——JPA整合Spring完整案例
最新发布
程序员阿皓的博客
04-28 172
整合JPA和Spring是常见的做法，可以方便地管理持久化对象和事务。
SpringDataJpa整合FreeMarker源码样例
08-05
《SpringDataJpa整合FreeMarker源码解析》 在当今的软件开发中，Spring Boot、Spring Data JPA和FreeMarker的整合已经成为了构建高效、简洁Web应用的常见选择。本篇将深入探讨如何将这三个强大的工具结合在一起，...
Spring+Spring MVC+SpringData JPA整合完成增删改查，翻页实例.zip
07-16
在这个"Spring+Spring MVC+SpringData JPA整合完成增删改查，翻页实例"中，我们将深入探讨这三个组件如何协同工作，实现高效的数据管理与用户交互。 首先，Spring MVC是Spring框架的一个模块，专门用于构建Web应用...
Spring Data JPA 笔记
04-16
Spring Data JPA 是一个强大的框架，它简化了Java应用程序与数据库之间的交互，是Spring生态中的重要组成部分。通过使用Spring Data JPA，开发者可以避免编写大量的JPA（Java Persistence API）和SQL代码，专注于...
Spring-Boot1.52 SpringSecurity4 Spring Data Jpa 整合例子
07-09
### Spring Boot 1.5.2、Spring Security 4 与 Spring Data JPA 整合实践 #### 一、项目背景及目标 本项目旨在通过一个具体的案例来演示如何将 Spring Boot 1.5.2、Spring Security 4 以及 Spring Data JPA 进行...
springboot 整合 springdataJPA 自定义操作 JPQL和SQL
qq_53374893的博客
12-20 729
【代码】springboot 整合 springdataJPA 自定义操作 JPQL和SQL。
IDEA对Spring Data JPA的强大支持
weixin_54618625的博客
03-22 1万+
本文介绍IDEA中对Spring Data JPA的支持，以及一些常用的使用方式。让你几乎不用手写代码，全方面自动生成。
Spring Data JPA用法详解
li_w_ch的博客
12-10 7289
Spring Data JPA： JPA（Java Persistence API）即java持久化API，它的出现主要是为了简化持久层开发以及整合ORM技术，结束Hibernate、TopLink、JDO等ORM框架各自为营的局面。JPA是在吸收现有ORM框架的基础上发展而来，易于使用，伸缩性强。总的来说，JPA包括以下三方面的技术： ORM映射元数据：支持XML和注解两种元数据的形式，元数据描述对象和表之间的映射关系 API：操作实体对象来执行CRUD操作 查询语言：通过面向对象而非面向数据库的
详解 spring data jpa，全方位总结
m0_54828003的博客
08-03 4470
jpa 的全称是 Java Persistence API , 中文的字面意思就是 java 的持久层 API , jpa 就是定义了一系列标准，让实体类和数据库中的表建立一个对应的关系，当我们在使用 java 操作实体类的时候能达到操作数据库中表的效果(不用写sql ,就可以达到效果），jpa 的实现思想即是 ORM （Object Relation Mapping），对象关系映射，用于在关系型数据库和业务实体对象之间作一个映射。在使用 jpa 的时候,这几个注解应该如何使用呢？...
Spring ORM+Hibernate？Out！换 Spring Data JPA 吧！
热门推荐
anxpp的博客
05-15 4万+
Spring Data JPA 的目标是通过让一些必须的工作变得更简单，来极大的提高数据访问层的实现效率。通常我们只需要姐访问方法，而 Spring 给你提供自动实现。！ 在一切开始之前，先举个简单的例子，以提高大家的兴致！ 如果一张表user有三个字段，id、name和age，要查找指定姓氏在某年龄以上的user，在传统的Spring+Hibernate中，dao层我们是这样写的...
Maven项目集成Spring+SpringMVC+SpringDataJpa的项目配置
蔡茂的博客
04-26 989
Maven项目集成Spring+SpringMVC+SpringDataJpa的项目配置 Spring的配置文件 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.or...
Spring Data Jpa 整合SSM教程
mytimelife的博客
01-25 844
点击上方Java老铁，并选择设为星标优质文章和资料会及时送达一、简介Spring Data :Spring 的一个子项目。用于简化数据库访问，支持NoSQL和关系数据存储。其主要目标...
JPA聚合函数（适用于联合查询）
美丽的泡沫
11-17 3万+
最近帮老同事解决一个问题，场景是这样的，查询条件比较多，也就是我们说的联合查询，比如下面的，时间可以选不同的，状态和来源也可以选不同，而且可选可不选 如果这个时候写sql，是不是要各种条件判断，各种纠结，各种难写，各种sql，这个时候大家一般都想到了springdata的jpa貌似很好用，可以直接拼接sql，但是怎么拼接呢，又怎么支持非表字段的展示呢，比如表中一个字段 aaa 好展示，但是查
Spring Data JPA整合MySQL详细配置教程
"本文主要讲解了如何将Spring Data JPA与MySQL数据库进行整合，并提供了配置方法，适合初学者参考。" 在开发Web应用程序时，Spring Data JPA是一个强大的工具，它简化了数据库操作，使开发者能够专注于业务逻辑而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

duration～

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

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

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

打赏作者

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

抵扣说明：

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

余额充值