Springdata--jpa入门

最新推荐文章于 2024-05-19 16:05:53 发布
置顶 最新推荐文章于 2024-05-19 16:05:53 发布
阅读量301 收藏 1
点赞数 1
文章标签： springdata jpa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35228318/article/details/86660190
版权

jpa是面向对象的，而非面向数据库，所以这里我们不需要去写sql语句操作数据库，只需要通过操作对象就能达到修改和查询数据库的操作。在这里我就先使用jpa创建一个数据库t_user表。

  1. 创建一个springboot项目，添加mysql和jpa

    取好项目名，next
    在这里插入图片描述

在这里插入图片描述
然后修改pom文件中mysql依赖，加上版本号，不然等会在yml文件中会无法解析driver-class-name

<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.21</version>
</dependency>
  1. 修改resources目录下的properties文件变成yml文件
    在这里插入图片描述
    2.1 配置yml文件
spring:
  # 配置数据源
  datasource:
    username: root
    password: root
    url: jdbc:mysql://127.0.0.1:3306/jpaDemo
    driver-class-name: com.mysql.jdbc.Driver
    # 配置jpa的相关信息
  jpa:
    generate-ddl: true # 生成创建表的sql语句
    hibernate:
      ddl-auto: update  # 每次启动项目时，检查数据库表结构和实体属性是否进行映射
    show-sql: true
    #配置数据方言
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
  1. 创建实体类
import javax.persistence.*;
//给数据库表取名
@Entity(name="t_user")
public class User {
    @Id //设置主键
    @GeneratedValue(strategy = GenerationType.IDENTITY) //设置主键自增
    private Integer uid;
    @Column //设置列
    private String uname;
    @Column //设置列
    private String address;

    @Override
    public String toString() {
        return "User{" +
                "uid=" + uid +
                ", uname='" + uname + '\'' +
                ", address='" + address + '\'' +
                '}';
    }

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public String getUname() {
        return uname;
    }

    public void setUname(String uname) {
        this.uname = uname;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

3.1 接下来去测试类中运行方法即可在数据库中创建一个和实体类属性相对应的表了。
在这里插入图片描述
3.2 查看数据库就能发现表已经创建完成。
在这里插入图片描述
4. 接下来我们将使用jpa对数据库进行增删查改操作。
4.1 创建一个dao包，里面包含userDao接口，并继承JpaRepository类

public interface UserDao extends JpaRepository<User,Integer> {

}

4.2在测试类注入UserDao

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringdataJpaDemoApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    public void contextLoads() {
        System.out.println("--------创建数据库表--------");
    }
    //新增操作
    @Test
    public void saveUser(){
        User user=new User();
        user.setUname("一一");
        user.setAddress("北京");
        userDao.save(user);
    }

4.3 更新操作

//更新操作 , 和插入的区别是这个有id，先执行查询，然后再更新数据
    @Test
    public void updateUser(){
        User user=new User();
        user.setUid(1);
        user.setUname("liming");
        user.setAddress("上海");
        userDao.save(user);
    }

4.4 删除操作

//删除操作
    @Test
    public void deleteUser(){
        userDao.deleteById(1);
    }

4.5 查询单个用户

//查询某个用户
    @Test
    public void findOne(){
        Optional<User> optional=userDao.findById(1);
        User user=optional.get();
        System.out.println(user.getUid()+","+user.getUname()+","+user.getAddress());
    }

4.6 查询全部用户

//查询所有用户信息
    @Test
    public void findAll(){
        List<User> list = userDao.findAll();
        for (User i : list){
            System.out.println(i.getUid()+"--"+i.getUname()+"--"+i.getAddress());
        }
    }

4.7 具体条件查询多个用户

//具体条件查询多个用户
    @Test
    public void findMoreByXX(){
        User user=new User();
        user.setUname("王五");
        user.setAddress("上海");
        //存储User对象指定where查询
        Example<User> example=Example.of(user);
        List<User> list = userDao.findAll(example);
        for (User u : list) {
            System.out.println(u.getUid()+"--"+u.getUname()+"--"+u.getAddress());
        }
    }

4.8 模糊查询多个用户

 //模糊查询多个用户
    @Test
    public void findMoreByVague(){
        User user=new User();
        //user.setUname("王");
        user.setAddress("上");
        //在对象中存了“上”这个值，才能实现 where address like 上%  这个sql语句
        ExampleMatcher matcher=ExampleMatcher.matching().withMatcher("address",ExampleMatcher.GenericPropertyMatchers.startsWith());
        Example<User> example=Example.of(user,matcher);
        List<User> list = userDao.findAll(example);
        for (User u : list) {
            System.out.println(u.getUid()+"--"+u.getUname()+"--"+u.getAddress());
        }
    }

4.9 分页查询

//分页查询
    @Test
    public void findPage(){
        //创建分页查询对象
        Pageable pageable= PageRequest.of(0,2);
        Page<User> page = userDao.findAll(pageable);

        for (User u : page) {
            System.out.println(u.getUid()+"--"+u.getUname()+"--"+u.getAddress());
        }
        //获得本次查询的总记录数和总页数
        System.out.println(page.getTotalElements()+"---"+page.getTotalPages());
    }

4.10 分页查询结果排序

//查询结果排序
    @Test
    public void findSort(){
        Sort sort=new Sort(Sort.Direction.DESC,"uid");
        PageRequest pageRequest = PageRequest.of(1, 3, sort);
        Page<User> page = userDao.findAll(pageRequest);
        page.forEach(new Consumer<User>() {
            @Override
            public void accept(User user) {
                System.out.println(user.getUid()+"--"+user.getUname()+"--"+user.getAddress());
            }
        });
    }
  1. 建立用户表和订单表之间的关系
    如果我们按照之前的方法再建立一张订单表，那么订单表和用户表好像是独立的，两者没有外键关联的。那这样就不能根据用户id查询用户订单了，所以我们有必要给他们建立一个关联。
    5.1创建订单类
package com.zym.springdata_jpa_demo.pojo;

import javax.persistence.*;
import java.util.Date;

@Entity(name = "t_orders")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    @Column
    private Double total;
    @Column
    private Date date;
    // 用户和订单是多对一的关系，所以这里使用 @ManyToOne
    @ManyToOne
    @JoinColumn(name="uid") //设置uid为外键
    private User user;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Double getTotal() {
        return total;
    }

    public void setTotal(Double total) {
        this.total = total;
    }

    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}

5.2 修改用户类

//给数据库表取名
@Entity(name="t_user")
public class User {
    @Id //设置主键
    @GeneratedValue(strategy = GenerationType.IDENTITY) //设置主键自增
    private Integer uid;
    @Column //设置列
    private String uname;
    @Column //设置列
    private String address;
    //用户和订单是多对一的关系，所以在用户类中使用 @OneToMany
    @OneToMany(mappedBy = "user")
    private List<Order> oList;

5.3 启动测试类，查看数据库的表
在这里插入图片描述
5.4 多表关联查询

//查询某个用户所有订单信息
    @Test
    public void findOneAllOrders(){
        Optional<User> userOptional = userDao.findById(2);
        User user = userOptional.get();
        List<Order> orderList = user.getoList();
        for (Order order : orderList) {
            System.out.println(order.getId()+"--"+order.getDate()+"--"+order.getTotal()+"--"+order.getUser().getUid());
        }
    }

这里会报错，org.hibernate.LazyInitializationException: failed to lazily initialize a col，因为jpa默认是懒加载的，当执行user.getoList()方法时，数据库连接已经关闭了，查不到了，所以这里有两种解决办法，一是将用户类的@OneToMany设置成立即加载，二是设置session延迟关闭。在这里我们先介绍第一种方案，

@OneToMany(mappedBy = "user",fetch = FetchType.EAGER)
private List<Order> oList;

在这里插入图片描述
设置成立即加载后再次运行即可成功。
6. 定义jpql查询数据库
这是一个类似于sql的查询语句。和sql不同的是，sql语句中是用表名查询，jpql用的是类的全限定路径。

6.1 在userDao中自定义扩展方法

package com.zym.springdata_jpa_demo.dao;

import com.zym.springdata_jpa_demo.pojo.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;

import java.util.List;

public interface UserDao extends JpaRepository<User,Integer> {
    //自己扩展方法
    @Query(value = "from com.zym.springdata_jpa_demo.pojo.User u ")
    public List<User> loadUserList();
}

6.2 在测试类写查询方法

    //jpql查询数据库
    @Test
    public void loadUserList(){
        List<User> userList = userDao.loadUserList();
        for (User user : userList) {
            System.out.println(user.getUid()+"--"+user.getUname()+"--"+user.getAddress());
        }
    }

6.3 jpql多表关联查询

    @Query(value = "from com.zym.springdata_jpa_demo.pojo.User u  join " +
            "com.zym.springdata_jpa_demo.pojo.Order o on u.uid=o.user.uid")
            //集合中既要存储用户还要存储订单，所以使用Object数组
    public List<Object[]> loadUserAndOrderList();

 //jpql多表关联查询
    @Test
    public void loadUserAndOrderList(){
        List<Object[]> list=userDao.loadUserAndOrderList();
        for (Object[] obj : list) {
            User user = (User) obj[0];
            Order order = (Order) obj[1];
            System.out.println(user.getUid()+"--"+user.getUname()+"--订单信息:"+order.getTotal()+"--"+order.getDate());
        }
    }
蓝爱思考
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
SpringDataJpa开发--继承JpaRepository实现简单条件查询
BADAO_LIUMANG_QIZHI的博客
07-18 9610
1.Spring Data JPA 是 Spring Data 技术下的子项目，使用Spring Data JPA 访问数据只需要数据访问层接口实现JpaRepository接口即可。 2.JpaRepository接口继承了PagingAndSortingRepository接口，所以也有它的一些功能 3.JpaRepoditory接口提供了很多常用方法：   示例：简单条件查询 ...
【Spring Data JPA】JpaRepository 增删改查
杜小舟的博客
09-13 4969
基于 JpaRepository 增删改查
Spring Data JPA 之 JpaRepository
lizhengyu891231的博客
10-21 670
转载自：https://blog.csdn.net/hbtj_1216/article/details/79773839 JpaRepository是Spring提供的非常强大的基本接口。 1 JpaRepository 1.1 JpaRepository接口定义 JpaRepository接口的官方定义如下： public interface JpaRepository<T, ...
创建springboot项目之后无法继承JpaRepository的问题
最新发布
Bermuda_Triangle的博客
05-19 125
我是在b站上看《一小时带你从0到1实现一个SpringBoot项目开发》入门springboot,up主创建dao之后public interface StudentRepository extends JpaRepository这个句子后面的JpaRepository根本无法解析，类似的问题可以参考一下哈。1.看很多其他博主说是版本号的问题，可以试试；创建时选择版本要注意，同时配置文件pom里的版本要写对了；我把这一段代码贴到pom.xml依赖里就ok啦！新手入门困难多多的，都耐心一点，一定会解决的。
Spring Data JPA框架系列(三)-自定义Repository接口详解
最爱嫣夜来
04-02 2972
2.1 自定义Repository接口 要定义一个repository接口，你首先需要自定义一个实体类专用的Repository接口。该接口必须扩展 Repository，并将其类型指定为实体类和实体类的 ID 类型。 如果你想为该实体类资源类型开放CRUD方法，请直接继承CrudRepository而不是Repository。 2.1.1 repository接口定义 通常，你的repository接口会扩展Repository、CrudRepository或PagingAndSortingReposit
Spring Data自定义接口实现
Anxiaolu的博客
07-29 1786
引言使用Spring Data自定义的Repository的实现方式最普遍的就是继承Spring的Repository定义及使用方式一:首先,因为Spring Data JPA的JpaRepository接口封装了一系列的增删改查,所以方便一般方式如下: public interface UserDao extends JpaRepository<User,Integer>{ }然后,对于想使用自己
spring-data-jpa-demo:一个关于Spring-data-JPA使用的demo,附带Spring Data JPA的一系列入门文章，详见http
05-14
spring-data-jpa-demo一个关于Spring-data-JPA使用的demo1、2、3、4、5、6、7、8、9、9.1、例子 10、11、12、13、请通过社区SpringForAll（）获取文章更新Spring For All 是什么「文艺版」关于Spring 的一切「接地气...
Spring-data-jpa常用教程.pdf
12-18
### Spring-data-jpa 的核心知识点解析 #### 一、Spring-data-jpa 基本介绍 Spring-data-jpa 是 Spring 家族中的一个重要成员，它主要用于简化基于 Java Persistence API (JPA) 的数据访问层（DAO）的开发工作。...
spring-data-jpa-guide:spring-data-jpa-guide，Spring Data JPA实现，SpringDataJpa解决方案
04-29
SpringDataJpa之Hibernate5.0的Entity判断Dirty的过程 SpringDataJPA之Hibernate加载过程 高级用法学习资料： https://github.com/eugenp/tutorials/tree/master/spring-rest-query-language 源码说明： 源码太分散...
Spring Data JPA.zip
08-10
**Spring Data JPA 深度解析** Spring Data JPA 是 Spring Framework 的一个重要模块，它为 Java Persistence API (JPA) 提供了便捷的数据访问层。这个框架简化了数据库操作，使得开发人员能够以声明式的方式处理...
JPA的Repository详解
热门推荐
三毛村滴雪鱼粉的博客
03-17 3万+
Spring Data JPA Spring Data是Spring提供的操作数据的框架，Spring Data JPA是Spring Data的一个模块，通过Spring data 基于jpa标准操作数据的模块。 Spring Data的核心能力，就是基于JPA操作数据，并且可以简化操作持久层的代码。 它使用一个叫作Repository的接口类为基础，它被定义为访问底层数据模型的超级接口。而对于...
easyui框架前后端交互_【平台开发】— 6.从[登录]看前后端交互
weixin_33206743的博客
12-03 266
上次了解到了后端代码的大概分层，作用都是干嘛的。那今天就结合着前端，一起看下它们是怎么交互的。其实简单来讲，就是前端把数据传递给后端，后端拿到数据后一通处理再返回给前端。一、登录功能前面提到的前端模板vue-admin-template，在本地run起来后，其实就可以看出一些端倪。打开登录页后，按下F12，点击到network下，再点击登录按钮。可以看到有2个请求：logininfo其中，logi...
Spring JPA(二）
weixin_39892530的博客
04-19 181
上一篇通过在自己的Repository类里注入EntityManager来实现对数据库的相关操作。 但是Spring觉得这种方式还是会出现一些重复的模板式的代码。于是对于Repository的实现进行了更加简单的封装。 分为以下三个步骤： ①定义自己的Repository接口，例如public interface UserRepository extends JpaRepository，需要...
【基于JPA的Repository使用详解】
qq_55656404的博客
06-28 7149
Spring Data是Spring提供的操作数据的框架，Spring Data JPA是Spring Data的一个模块，通过Spring data 基于jpa标准操作数据的模块。Spring Data的核心能力，就是基于JPA操作数据，并且可以简化操作持久层的代码。它使用一个叫作Repository的接口类为基础，它被定义为访问底层数据模型的超级接口。而对于某种具体的数据访问操作，则在其子接口中定义。Spring Data可以让我们只定义接口，只要遵循spring data的规范，就无需写实现类，不用写
SpringDataJpa：JpaRepository增删改查
卢卢在路上
09-06 4757
Jpa查询 1. JpaRepository简单查询 基本查询也分为两种，一种是spring data默认已经实现，一种是根据查询的方法来自动解析成SQL。 预先生成方法 spring data jpa 默认预先生成了一些基本的CURD的方法，例如：增、删、改等等 继承JpaRepository public interface UserRepository extends JpaRepo......
基于JPA的Repository使用详解
Mr. David 专栏
06-20 1122
Spring Data是Spring提供的操作数据的框架，Spring Data JPA是Spring Data的一个模块，通过Spring data 基于jpa标准操作数据的模块。Spring Data的核心能力，就是基于JPA操作数据，并且可以简化操作的代码。它使用一个叫作Repository的接口类为基础，它被定义为访问底层的超级接口。而对于某种具体的数据访问操作，则在其子接口中定义。
spring data jpa个人笔记
yi742891270的博客
11-01 1070
导包 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency>
springboot项目--数据库配置(使用JpaRepository进行增删改查)
一粒程序米
07-06 1275
1.首先开启数据库MySQL服务，我用的是xampp管理工具 2.使用sql-front可视化工具新建一个名为‘selldata.sql’的数据库，然后使用以下建表语句建表： CREATE TABLE `product_category` ( `category_id`int not null AUTO_INCREMENT, `category_name` varchar(64)not null comment'类目名字', `category_type` decimal(8,2)not null
spring-boot-starter-data-jpa 入门
04-30
spring-boot-starter-data-jpa 是 Spring Boot 提供的一个快速开发 JPA 应用的起步依赖。它提供了一系列默认的配置和依赖，方便我们快速地使用 JPA 进行开发。 以下是入门步骤： 1. 添加依赖：在 pom.xml 文件中添加以下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> ``` 2. 配置数据源：在 application.properties 或 application.yml 文件中配置数据库连接信息，例如： ```properties spring.datasource.url=jdbc:mysql://localhost:3306/mydb spring.datasource.username=root spring.datasource.password=root spring.datasource.driver-class-name=com.mysql.jdbc.Driver ``` 3. 创建实体类：创建一个用于映射数据库表的实体类，例如： ```java @Entity @Table(name = "user") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; private Integer age; // 省略 getter 和 setter 方法 } ``` 4. 创建 Repository 接口：创建一个继承 JpaRepository 接口的 Repository 接口，例如： ```java public interface UserRepository extends JpaRepository<User, Long> { } ``` 5. 使用 Repository：在业务逻辑中使用 UserRepository 进行增删改查操作，例如： ```java @Service public class UserService { @Autowired private UserRepository userRepository; public User save(User user) { return userRepository.save(user); } public User findById(Long id) { return userRepository.findById(id).orElse(null); } public List<User> findAll() { return userRepository.findAll(); } public void deleteById(Long id) { userRepository.deleteById(id); } } ``` 以上就是使用 spring-boot-starter-data-jpa 开发 JPA 应用的基本步骤。需要注意的是，该起步依赖默认使用 Hibernate 作为 JPA 的实现，因此需要添加 Hibernate 的相关依赖。同时，也可以根据需要进行自定义配置，例如配置 JPA 的缓存、事务管理等。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值