spring data jpa查询

最新推荐文章于 2024-07-29 11:02:40 发布
最新推荐文章于 2024-07-29 11:02:40 发布
阅读量671 收藏 1
点赞数 1
分类专栏： Spring Data JPA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40055163/article/details/109179955
版权

spring data jpa查询

1 spring Data JPA查询调用接口方法查询（count，exists）
编写测试统计查询测试代码如下：

package com.txw.test;

import com.txw.dao.CustomerDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
 * 测试CRUD的操作
 * @author: Adair
 */
@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
@SuppressWarnings("all")         // 注解警告信息
public class CustomerDaoTest {
    // 声明CustomerDao业务对象
    @Autowired   // 自动注入
    private CustomerDao customerDao;
    /**
     * 测试统计查询：查询客户的总数量
     *      count:统计总条数
     */
    @Test
    public void testCount() {
        // 查询全部的客户数量
        long count = customerDao.count();
        System.out.println(count);
    }
}

运行结果如图所示：在这里插入图片描述
编写测试客户是否存在的代码如下：

package com.txw.test;

import com.txw.dao.CustomerDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
 * 测试CRUD的操作
 * @author: Adair
 */
@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
@SuppressWarnings("all")         // 注解警告信息
public class CustomerDaoTest {
    // 声明CustomerDao业务对象
    @Autowired   // 自动注入
    private CustomerDao customerDao;
    /**
     * 测试：判断id为5的客户是否存在
     *      1. 可以查询以下id为5的客户
     *          如果值为空，代表不存在，如果不为空，代表存在
     *      2. 判断数据库中id为5的客户的数量
     *          如果数量为0，代表不存在，如果大于0，代表存在
     */
    @Test
    public void  testExists() {
        boolean exists = customerDao.exists(5l);
        System.out.println("id为5的客户 是否存在："+exists);
    }
}

运行结果如图所示：在这里插入图片描述
2 spring Data JPA查询调用接口方法查询（findOne和getOne的区别）
编写测试代码如下：

package com.txw.test;

import com.txw.dao.CustomerDao;
import com.txw.domain.Customer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
/**
 * 测试CRUD的操作
 * @author: Adair
 */
@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
@SuppressWarnings("all")         // 注解警告信息
public class CustomerDaoTest {
    // 声明CustomerDao业务对象
    @Autowired   // 自动注入
    private CustomerDao customerDao;
    /**
     * 根据id从数据库查询
     *      @Transactional : 保证getOne正常运行
     *  findOne：
     *      em.find()           :立即加载
     *  getOne：
     *      em.getReference     :延迟加载
     *      * 返回的是一个客户的动态代理对象
     *      * 什么时候用，什么时候查询
     */
    @Test
    @Transactional
    public void  testGetOne() {
        Customer customer = customerDao.getOne(5l);
        System.out.println(customer);
    }
}

运行结果如图所示：在这里插入图片描述
3 JPQL查询引入
在继承JpaRepository，和JpaRepository接口后,我们就可以使用接口中定义的方法进行查询。
继承JpaRepository后的方法列表在这里插入图片描述
继承JpaSpecificationExecutor的方法列表在这里插入图片描述
jpql的查询方式
jpql:jpa query language （jpq查询语言）
特点:语法或关键字和sql语句类似。
查询的是类和类中的属性。
需要将JPQL语句配置到接口方法上
1.特有的查询：需要在dao接口上配置方法
2.在新添加的方法上，使用注解的形式配置jpql查询语句
3.注解 ： @Query
使用Spring Data JPA提供的查询方法已经可以解决大部分的应用场景，但是对于某些业务来说，我们还需要灵活的构造查询条件，这时就可以使用@Query注解，结合JPQL的语句方式完成查询。
@Query 注解的使用非常简单，只需在方法上面标注该注解，同时提供一个JPQL查询语句即可。
此外，也可以通过使用 @Query 来执行一个更新操作，为此，我们需要在使用 @Query 的同时，用 @Modifying 来将该操作标识为修改查询，这样框架最终会生成一个更新的操作，而非查询。
4 使用jpql完成基本查询
编写CustomerDao的案例的代码如下：

package com.txw.dao;

import com.txw.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
/**
 *  符合SpringDataJpa的dao层接口规范
 *        JpaRepository<操作的实体类类型，实体类中主键属性的类型>
 *             封装了基本CRUD操作
 *        JpaSpecificationExecutor<操作的实体类类型>
 *            封装了复杂查询（分页）
 * @author: Adair
 */
@SuppressWarnings("all")         // 注解警告信息
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
    /**
     * 案例：根据客户名称查询客户
     *      使用jpql的形式查询
     *  jpql：from Customer where custName = ?
     *  配置jpql语句，使用的@Query注解
     */
    @Query(value="from Customer where custName = ?")
    public Customer findJpql(String custName);
}

编写测试代码如下：

package com.txw.test;

import com.txw.dao.CustomerDao;
import com.txw.domain.Customer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
 * 使用jpql测试
 * @author: Adair
 */
@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
@SuppressWarnings("all")         // 注解警告信息
public class JpqlTest {
    // 声明CustomerDao业务对象
    @Autowired
    private CustomerDao customerDao;
    /**
     * 根据客户名称查询
     */
    @Test
    public void  testFindJPQL() {
        Customer customer = customerDao.findJpql("学无止路");
        System.out.println(customer);
    }
}

运行结果如图所示：在这里插入图片描述
5 多占位符的赋值
编写CustomerDao的案例的代码如下：

package com.txw.dao;

import com.txw.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
/**
 *  符合SpringDataJpa的dao层接口规范
 *        JpaRepository<操作的实体类类型，实体类中主键属性的类型>
 *             封装了基本CRUD操作
 *        JpaSpecificationExecutor<操作的实体类类型>
 *            封装了复杂查询（分页）
 * @author: Adair
 */
@SuppressWarnings("all")         // 注解警告信息
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
    /**
     * 案例：根据客户名称和客户id查询客户
     *      jpql： from Customer where custName = ? and custId = ?
     *  对于多个占位符参数
     *      赋值的时候，默认的情况下，占位符的位置需要和方法参数中的位置保持一致
     *  可以指定占位符参数的位置
     *      ? 索引的方式，指定此占位的取值来源
     */
    @Query(value = "from Customer where custName = ?2 and custId = ?1")
    public Customer findCustNameAndId(Long id,String name);
}

编写测试代码如下：

package com.txw.test;

import com.txw.dao.CustomerDao;
import com.txw.domain.Customer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
 * 使用jpql测试
 * @author: Adair
 */
@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
@SuppressWarnings("all")         // 注解警告信息
public class JpqlTest {
    // 声明CustomerDao业务对象
    @Autowired
    private CustomerDao customerDao;
    @Test
    public void testFindCustNameAndId() {
        // Customer customer = customerDao.findCustNameAndId(5l, "Adair");
        Customer customer =  customerDao.findCustNameAndId(5l,"Adair");
        System.out.println(customer);
    }
}

运行结果如图所示：在这里插入图片描述
6 使用jpql完成更新操作
编写CustomerDao的案例的代码如下：

package com.txw.dao;

import com.txw.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
/**
 *  符合SpringDataJpa的dao层接口规范
 *        JpaRepository<操作的实体类类型，实体类中主键属性的类型>
 *             封装了基本CRUD操作
 *        JpaSpecificationExecutor<操作的实体类类型>
 *            封装了复杂查询（分页）
 * @author: Adair
 */
@SuppressWarnings("all")         // 注解警告信息
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
    /**
     * 使用jpql完成更新操作
     *      案例 ： 根据id更新，客户的名称
     *          更新7号客户的名称，将名称改为“学无止路”
     *  sql  ：update cst_customer set cust_name = ? where cust_id = ?
     *  jpql : update Customer set custName = ? where custId = ?
     *  @Query : 代表的是进行查询
     *      * 声明此方法是用来进行更新操作
     *  @Modifying
     *      * 当前执行的是一个更新操作
     */
    @Query(value = " update Customer set custName = ?2 where custId = ?1 ")
    @Modifying
    public void updateCustomer(long custId,String custName);
}

编写测试代码如下：

package com.txw.test;

import com.txw.dao.CustomerDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
/**
 * 使用jpql测试
 * @author: Adair
 */
@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
@SuppressWarnings("all")         // 注解警告信息
public class JpqlTest {
    // 声明CustomerDao业务对象
    @Autowired
    private CustomerDao customerDao;
    /**
     * 测试jpql的更新操作
     *  * springDataJpa中使用jpql完成 更新/删除操作
     *         * 需要手动添加事务的支持
     *         * 默认会执行结束之后，回滚事务
     *   @Rollback : 设置是否自动回滚
     *          false | true
     */
    @Test
    @Transactional //添加事务的支持
    @Rollback(value = false)
    public void testUpdateCustomer() {
        customerDao.updateCustomer(7l,"学无止路");
    }
}

运行之前数据库的数据如图所示：在这里插入图片描述
运行结果如图所示：在这里插入图片描述
运行之后数据库的数据如图所示：在这里插入图片描述
7 查询全部
sql语句的查询
1.特有的查询：需要在dao接口上配置方法
2.在新添加的方法上，使用注解的形式配置sql查询语句
3.注解 ：@Query
value ：jpql语句 | sql语句
nativeQuery ：false（使用jpql查询） | true（使用本地查询：sql查询）
是否使用本地查询
编写CustomerDao的案例的代码如下：

package com.txw.dao;

import com.txw.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
import java.util.List;
/**
 *  符合SpringDataJpa的dao层接口规范
 *        JpaRepository<操作的实体类类型，实体类中主键属性的类型>
 *             封装了基本CRUD操作
 *        JpaSpecificationExecutor<操作的实体类类型>
 *            封装了复杂查询（分页）
 * @author: Adair
 */
@SuppressWarnings("all")         // 注解警告信息
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
    /**
     * 使用sql的形式查询：
     *     查询全部的客户
     *  sql ： select * from cst_customer;
     *  Query : 配置sql查询
     *      value ： sql语句
     *      nativeQuery ： 查询方式
     *          true ： sql查询
     *          false：jpql查询
     */
    //@Query(value = " select * from cst_customer" ,nativeQuery = true)
    public List<Object [] > findSql();
}

编写测试代码如下：

package com.txw.test;

import com.txw.dao.CustomerDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.Arrays;
import java.util.List;
/**
 * 使用jpql测试
 * @author: Adair
 */
@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
@SuppressWarnings("all")         // 注解警告信息
public class JpqlTest {
    // 声明CustomerDao业务对象
    @Autowired
    private CustomerDao customerDao;
    /**
     * 测试sql查询
     */
    @Test
    public void testFindSql() {
        List<Object[]> list = customerDao.findSql();
        for(Object [] obj : list) {
            System.out.println(Arrays.toString(obj));
        }
    }
}

运行结果如图所示：在这里插入图片描述
8 条件全部
编写CustomerDao的案例的代码如下：

package com.txw.dao;

import com.txw.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
import java.util.List;
/**
 *  符合SpringDataJpa的dao层接口规范
 *        JpaRepository<操作的实体类类型，实体类中主键属性的类型>
 *             封装了基本CRUD操作
 *        JpaSpecificationExecutor<操作的实体类类型>
 *            封装了复杂查询（分页）
 * @author: Adair
 */
@SuppressWarnings("all")         // 注解警告信息
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
    /**
     * 使用sql的形式查询：
     *     查询全部的客户
     *  sql ： select * from cst_customer;
     *  Query : 配置sql查询
     *      value ： sql语句
     *      nativeQuery ： 查询方式
     *          true ： sql查询
     *          false：jpql查询
     */
    @Query(value="select * from cst_customer where cust_name like ?1",nativeQuery = true)
    public List<Object [] > findSql(String name);
}

编写测试代码如下：

package com.txw.test;

import com.txw.dao.CustomerDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.Arrays;
import java.util.List;
/**
 * 使用jpql测试
 * @author: Adair
 */
@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
@SuppressWarnings("all")         // 注解警告信息
public class JpqlTest {
    // 声明CustomerDao业务对象
    @Autowired
    private CustomerDao customerDao;
    /**
     * 测试sql模糊配置查询
     */
    @Test
    public void testFindSql() {
        List<Object[]> list = customerDao.findSql("Adair%");
        for(Object [] obj : list) {
            System.out.println(Arrays.toString(obj));
        }
    }
}

运行结果如图所示：在这里插入图片描述
9 方法命名规则查询：基本查询
顾名思义，方法命名规则查询就是根据方法的名字，就能创建查询。只需要按照Spring Data JPA提供的方法命名规则定义方法的名称，就可以完成查询工作。Spring Data JPA在程序执行的时候会根据方法名称进行解析，并自动生成查询语句进行查询
按照Spring Data JPA 定义的规则，查询方法以findBy开头，涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性首字母需大写。框架在进行方法名解析时，会先把方法名多余的前缀截取掉，然后对剩下部分进行解析。

//方法命名方式查询（根据客户名称查询客户）
public Customer findByCustName(String custName);

具体的关键字，使用方法和生产成SQL如下表所示：
在这里插入图片描述
编写CustomerDao的案例的代码如下：

package com.txw.dao;

import com.txw.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
/**
 *  符合SpringDataJpa的dao层接口规范
 *        JpaRepository<操作的实体类类型，实体类中主键属性的类型>
 *             封装了基本CRUD操作
 *        JpaSpecificationExecutor<操作的实体类类型>
 *            封装了复杂查询（分页）
 * @author: Adair
 */
@SuppressWarnings("all")         // 注解警告信息
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
    /**
     * 方法名的约定：
     *      findBy : 查询
     *            对象中的属性名（首字母大写） ： 查询的条件
     *            CustName
     *            * 默认情况 ： 使用 等于的方式查询
     *                  特殊的查询方式
     *  findByCustName   --   根据客户名称查询
     *  再springdataJpa的运行阶段
     *          会根据方法名称进行解析  findBy    from  xxx(实体类)
     *                                      属性名称      where  custName =
     *      1.findBy  + 属性名称 （根据属性名称进行完成匹配的查询=）
     *      2.findBy  + 属性名称 + “查询方式（Like | isnull）”
     *          findByCustNameLike
     *      3.多条件查询
     *          findBy + 属性名 + “查询方式”   + “多条件的连接符（and|or）”  + 属性名 + “查询方式”
     */
    public Customer findByCustName(String custName);
}

编写测试代码如下：

package com.txw.test;

import com.txw.dao.CustomerDao;
import com.txw.domain.Customer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
 * 使用jpql测试
 * @author: Adair
 */
@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
@SuppressWarnings("all")         // 注解警告信息
public class JpqlTest {
    // 声明CustomerDao业务对象
    @Autowired
    private CustomerDao customerDao;
    /**
     * 测试方法命名规则的查询
     */
    @Test
    public void testNaming() {
        Customer customer = customerDao.findByCustName("Adair");
        System.out.println(customer);
    }
}

运行结果如图所示：在这里插入图片描述
注意事项：custName在数据库中数据相同就会报错误。
10 方法命名规则查询：模糊匹配
编写CustomerDao的案例的代码如下：

package com.txw.dao;

import com.txw.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import java.util.List;
/**
 *  符合SpringDataJpa的dao层接口规范
 *        JpaRepository<操作的实体类类型，实体类中主键属性的类型>
 *             封装了基本CRUD操作
 *        JpaSpecificationExecutor<操作的实体类类型>
 *            封装了复杂查询（分页）
 * @author: Adair
 */
@SuppressWarnings("all")         // 注解警告信息
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
    /**
     * 根据客户名进行模糊查询
     * @param custName
     * @return
     */
    public List<Customer> findByCustNameLike(String custName);
}

编写测试代码如下：

package com.txw.test;

import com.txw.dao.CustomerDao;
import com.txw.domain.Customer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.List;
/**
 * 使用jpql测试
 * @author: Adair
 */
@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
@SuppressWarnings("all")         // 注解警告信息
public class JpqlTest {
    // 声明CustomerDao业务对象
    @Autowired
    private CustomerDao customerDao;
    /**
     * 测试方法命名规则的查询
     */
    @Test
    public void testNaming() {
        List<Customer> list = customerDao.findByCustNameLike("学无止路");
        for (Customer customer : list) {
            System.out.println(customer);
        }
    }
}

运行结果如图所示：在这里插入图片描述
11 方法命名规则查询：多条件查询
编写CustomerDao的案例的代码如下：

package com.txw.dao;

import com.txw.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
/**
 *  符合SpringDataJpa的dao层接口规范
 *        JpaRepository<操作的实体类类型，实体类中主键属性的类型>
 *             封装了基本CRUD操作
 *        JpaSpecificationExecutor<操作的实体类类型>
 *            封装了复杂查询（分页）
 * @author: Adair
 */
@SuppressWarnings("all")         // 注解警告信息
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
    /**
     * 使用客户名称模糊匹配和客户所属行业精准匹配的查询
     * @param custName
     * @param custIndustry
     * @return
     */
    public Customer findByCustNameLikeAndCustIndustry(String custName,String custIndustry);
}

编写测试代码如下：

package com.txw.test;

import com.txw.dao.CustomerDao;
import com.txw.domain.Customer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
 * 使用jpql测试
 * @author: Adair
 */
@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
@SuppressWarnings("all")         // 注解警告信息
public class JpqlTest {
    // 声明CustomerDao业务对象
    @Autowired
    private CustomerDao customerDao;
    /**
     * 测试方法命名规则的查询
     */
    @Test
    public void testFindByCustNameLikeAndCustIndustry() {
        Customer customer = customerDao.findByCustNameLikeAndCustIndustry("学无止路%", "笔记");
        System.out.println(customer);
    }
}

运行结果如图所示：在这里插入图片描述

学无止路
关注
专栏目录
SpringDataJPA--查询方式
qq_43404873的博客
12-07 751
Spring Data JPA的查询方式 4.1 使用Spring Data JPA中接口定义的方法进行查询 在继承JpaRepository，和JpaRepository接口后,我们就可以使用接口中定义的方法进行查询 继承JpaRepository后的方法列表 继承JpaSpecificationExecutor的方法列表 测试count()方法和exists()方法 /** * 测试统计查询: 查询客户的总数量 * count()：通过主键id进行统计客户总数量 *
Spring Data Jpa (二)JPA基础查询
weixin_30786657的博客
06-27 147
介绍Spring Data Common里面的公用基本方法 (1)Spring Data Common的Repository 　　Repository位于Spring Data Common的lib里面，是Spring Data里面做数据库操作的最底层的抽象接口、最顶级的父类，源码里面其实什么方法都没有，仅仅起到一个标识作用。管理域类以及域类的id类型作为类型参数，此接口主要作为标记接口捕获要...
SpringDataJPA（三）：多表操作，复杂查询
最新发布
you4580的专栏
07-29 1927
在实际开发中，我们数据库的表难免会有相互的关联关系，在操作表的时候就有可能会涉及到多张表的操作。有时我们在查询某个实体的时候，给定的条件是不固定的，这时就需要动态构建相应的查询语句，在Spring Data JPA中可以通过JpaSpecificationExecutor接口查询。多对多关系中：用中间表（第三章表）来描述这种关系，中间表中至少应该由两个字段组成，这两个字段作为外键指向两张表的主键，且这两个字段又组成了联合主键。在一对多关系中，我们习惯把一的一方称之为主表，把多的一方称之为从表。
spring data jpa基本查询
weixin_43326384的博客
12-14 220
PageRequest pageRequest = PageRequest.of(0, 5); String name = null; List<Integer> saleList = new ArrayList<>(); // saleList.add(10); // saleList.add(6); List<Long> categoryList = new ArrayList<>(); categoryList.add(12l)..
开发人员必须要掌握的《Spring Data JPA四种查询方式》
小小张自由—>张有博
12-24 6093
本文详细介绍了SpringDataJPA的使用情况，从基础的环境的搭建，到后来SpringDataJPA的四种查询方式，基础查询，JPQL查询，SQL查询以及方法名查询。
Spring Data JPA中文文档[1.4.3]_springdatajpa_erlang_waitxpf_
10-02
9. **JPA Querydsl Support**：Spring Data JPA 还支持 Querydsl，这是一个强大的类型安全的查询语言，它可以进一步提高查询的可读性和可维护性。 10. **Elasticsearch 集成**：虽然不是 Spring Data JPA 的核心...
Spring Data JPA API（Spring Data JPA 开发文档）.CHM
08-31
Spring Data JPA API。 Spring Data JPA 开发文档。 官网 Spring Data JPA API。
详解Spring Data Jpa 模糊查询的正确用法
08-27
Spring Data JPA 模糊查询的正确用法 Spring Data JPA 是一个基于 Java Persistence API（JPA）规范的数据访问技术，提供了简洁的数据访问方式。然而，在实际开发中，开发者经常会遇到模糊查询的需求。本文将详细...
Spring Data JPA的优点和难点.pdf
12-05
- Spring Data JPA虽然简化了查询编写，但可能导致生成的SQL不够优化，尤其是在处理大数据量或复杂查询时。开发者需要熟悉JPA的内部工作原理，适时使用`@Query`注解自定义SQL，以提升性能。 2. **关联关系的处理**...
spring注解+spring data jpa文档+JPA文档.rar
04-05
Spring Data JPA提供了强大的Repository抽象，允许开发者以声明式的方式定义数据操作，如查询方法。只需要在接口上定义方法名，Spring Data JPA就能自动生成对应的SQL语句。例如，`findAll()`会执行SELECT ALL查询，...
Spring-data-jpa最全的查询语法总结，直入超神
我是香菜
06-05 1502
spring-data 一统江湖，玩转多种数据源今天这篇文章总结下spring data jpa的查询语法，在开发中能够灵活使用，在开始下面的之前我们定义一个entity，以便后面的部分使用这里定义一个玩家的entity@Data@Entity@ApiModel(description = "玩家信息")@Id@ApiModelProperty(value = "主键")@ApiModelProperty(value = "玩家名字")
一篇文章带你搞定 Spring Data JPA 的查询方式
南淮北安的博客
07-12 966
文章目录一、使用 Spring Data JPA 中接口定义的方法二、使用JPQL的方式查询三、使用 SQL 语句查询四、方法命名规则查询 一、使用 Spring Data JPA 中接口定义的方法 在继承 JpaRepository，和 JpaRepository 接口后,我们就可以使用接口中定义的方法进行查询 继承 JpaRepository 后的方法列表 继承 JpaSpecificationExecutor 的方法列表 例如： /** * 测试统计查询：查询客户的总数量
【Spring Boot】Java 持久层 API（三）：JPA 的查询方式
书山有路，学海无涯。记录成长，追逐梦想
06-30 1694
QueryDSL 也是基于各种 ORM 之上的一个通用查询框架，它与 Spring Data JPA 是同级别的。使用 QueryDSL 的 API 可以写出 SQL 语句(Java 代码，非真正标准 SQL），不需要懂 SQL 语句。它能够构建类型安全的查询。这与 JPA 使用原生查询时有很大的不同，可以不必再对 Object[] 进行操作。它还可以和 JPA 联合使用。
Spring Data JPA查询
LEEWLE的博客
02-15 158
Spring Data JPA查询
springDataJpa——spectification查询
qq_44132240的博客
11-29 309
springDataJpa——spectification查询 一、环境搭建 springDataJpa的环境搭建在上篇已经讲到，这篇中所使用的entity、Dao与层下面这个链接一致，这里不再赘述。springDataJpa环境搭建 package com.xsl.test; import com.xsl.dao.UserDao; import com.xsl.entity.UserEntit...
SpringData JPA 接口查询
路边烧卖
09-09 1193
SpringData JPA 接口查询 1、SpringData 接口继承结构 Repository：最顶层的接口，是一个空的接口，目的是为了统一所有Repository的类型，且能让组件扫描的时候自动识别。 CrudRepository ：是Repository的子接口，提供CRUD的功能 PagingAndSortingRepository：是CrudRepository的子接口，添加分页和排序的功能 JpaRepository：是PagingAndSortingRepository的子接口，增加了一
Spring Data JPA 查询方法那些事
热门推荐
小小默：进无止境
09-09 1万+
Spring Data 提供了几个接口供继承使用，如 JpaRepository，另外还规定了方法查询中的关键字，即你命名的查询方法需要符合规范。 详情参考：SpringBoot整合Spring Data JPA、SpringDataJPA入门。 本篇博文详细记录Spring Data JPA查询中的那些事。 【1】方法查询 ① 只要符号命名规范的接口都可以被正常解析使用 如下所示：...
Jpa中的count()计数查询
hardtomakeaname的博客
01-09 7830
比如 userRepository.count()。意思就是找出user的所有数量 计数 查询 long count() 或者 根据某个属性的值查询总数 countByAge(int age)
Spring Data JPA查询方法：构建与参数处理
本文档主要介绍了Spring Data JPA中如何通过方法名构建查询，涉及了查询方法的声明、属性表达式、特殊参数处理以及排序等关键概念。Spring Data JPA允许开发者以一种声明式的方式定义查询，简化了与数据库交互的复杂...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

学无止路

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

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

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

打赏作者

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

抵扣说明：

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

余额充值