006_Spring Data JPA基于方法名称命名规则查询

最新推荐文章于 2024-10-24 09:37:20 发布
最新推荐文章于 2024-10-24 09:37:20 发布
阅读量849 收藏 1
点赞数
分类专栏： SpringData 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/aihiao/article/details/122986353
版权

1. Repository接口 

1.1. Repository接口是Spring Data JPA中为我我们提供的所有接口中的顶层接口。

1.2. Repository提供了两种查询方式的支持 

1.2.1. 基于方法名称命名规则查询。

1.2.2. 基于@Query注解查询。

2. 方法名称命名规则查询

2.1. 规则: findBy(关键字)+属性名称(属性名称的首字母大写)+查询条件(首字母大写)。

2.2. 方法名称命名规则查询列表

关键字

方法命名

sql语句

findByName(String name)

where name=?

Is

findByNameIs(String name)

where name=?

Equals

findByNameEquals(String name)

where name=?

And

findByNameAndSex(String name, String sex)

where name=? and sex=?

Or

findByIdOrName(Integer id, String name)

where id=? or name=?

Between

findByIdBetween(Integer x, Integer y)

where id between ? and ?

LessThan

findByIdLessThan(Integer x)

where id<?

LessThanEqual

findByIdLessThanEqual(Integer x)

where id<=?

GreaterThan

findByIdGreaterThan(Integer x)

where id>?

GreaterThanEqual

findByIdGreaterThanEqual(Integer x)

where id>=?

After

findByIdAfter(Integer x)

where id>?

Before

findByIdBefore(Integer x)

where id<?

IsNull

findByNameIsNull()

where name is null

IsNotNull

findByNameIsNotNull()

where name is not null

NotNull

findByNameNotNull()

where name is not null

Like

findByNameLike(String name)

where name like ?

NotLike

findByNameNotLike(String name)

where name not like ?

StartingWith

findByNameStartingWith(String name)

where name like ?%

EndingWith

findByNameEndingWith(String name)

where name like %?

Containing

findByNameContaining(String name)

where name like %?%

OrderBy

findBySexOrderByIdDesc(String sex)

where sex=? order by id desc

Not

findByNameNot(String name)

where name <> ?

In

findByIdIn(Collection<Integer> c)

where id in (?)

NotIn

findByIdNotIn(Collection<Integer> c)

where id not in (?)

3. 方法名称命名规则查询例子 

3.1. 创建一个名为spring-data-jpa-naming的Java项目, 同时添加相关jar包, 并添加JUnit能力。

3.2. 新建User.java 

package com.bjbs.pojo;

import java.io.Serializable;
import java.util.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import org.springframework.format.annotation.DateTimeFormat;

@Entity // 指定该类是实体类
@Table(name = "user") // 指定数据库表名(表名和实体类对应)
public class User implements Serializable {
	private static final long serialVersionUID = 1L;

	@Id // 指定为主键
	@GeneratedValue(strategy = GenerationType.IDENTITY) // 指定主键生成策略
	@Column(name = "id") // 指定表中列名(列名和属性名对应)
	private Integer id;

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

	@Column(name = "sex")
	private String sex;
	
	@Column(name = "birthday")
	@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
	private Date birthday;

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

	public User() {
	}

	public User(String name, String sex, Date birthday, String address) {
		this.name = name;
		this.sex = sex;
		this.birthday = birthday;
		this.address = address;
	}

	public User(Integer id, String name, String sex, Date birthday, String address) {
		this.id = id;
		this.name = name;
		this.sex = sex;
		this.birthday = birthday;
		this.address = address;
	}

	public Integer getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	public String getAddress() {
		return address;
	}

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

	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", sex=" + sex + ", birthday=" + birthday + ", address=" + address
				+ "]";
	}
}

3.3. 新建UserRepository.java, 实现Repository

package com.bjbs.dao;

import java.util.Collection;
import java.util.List;
import org.springframework.data.repository.Repository;
import com.bjbs.pojo.User;

/**
 * 参数一T: 当前需要映射的实体; 参数二 T: 当前映射的实体中的id的类型
 */
public interface UserRepository extends Repository<User, Integer> {
	/**
	 * 判断相等
	 */
	User findByName(String name);
	User findByNameIs(String name);
	User findByNameEquals(String name);
	
	/**
	 * And语句
	 */
	User findByNameAndSex(String name, String sex);
	
	/**
	 * Or语句
	 */
	List<User> findByIdOrName(Integer id, String name);
	
	/**
	 * Between语句
	 */
	List<User> findByIdBetween(Integer x, Integer y);
	
	/**
	 * < x
	 */
	List<User> findByIdLessThan(Integer x);
	/**
	 * <= x
	 */
	List<User> findByIdLessThanEqual(Integer x);
	/**
	 * > x
	 */
	List<User> findByIdGreaterThan(Integer x);
	/**
	 * >= x
	 */
	List<User> findByIdGreaterThanEqual(Integer x);
	/**
	 * > x
	 */
	List<User> findByIdAfter(Integer x);
	/**
	 * < x
	 */
	List<User> findByIdBefore(Integer x);
	
	/**
	 * IsNull语句
	 */
	List<User> findByNameIsNull();
	/**
	 * IsNotNull语句
	 */
	List<User> findByNameIsNotNull();
	/**
	 * NotNull语句
	 */
	List<User> findByNameNotNull();
	
	/**
	 * Like语句
	 */
	List<User> findByNameLike(String name);
	/**
	 * NotLike语句
	 */
	List<User> findByNameNotLike(String name);
	/**
	 * Like name%
	 */
	List<User> findByNameStartingWith(String name);
	/**
	 * Like %name
	 */
	List<User> findByNameEndingWith(String name);
	/**
	 * Like %name%
	 */
	List<User> findByNameContaining(String name);
	
	/**
	 * OrderBy语句
	 */
	List<User> findBySexOrderByIdDesc(String sex);
	
	/**
	 * Not语句
	 */
	List<User> findByNameNot(String name);
	
	/**
	 * In语句
	 */
	List<User> findByIdIn(Collection<Integer> c);
	/**
	 * NotIn语句
	 */
	List<User> findByIdNotIn(Collection<Integer> c);
}

3.4. 新建UserService.java

package com.bjbs.service;

import java.util.Collection;
import java.util.List;
import com.bjbs.pojo.User;

public interface UserService {
	User findByName(String name);
	User findByNameIs(String name);
	User findByNameEquals(String name);
	
	User findByNameAndSex(String name, String sex);
	
	List<User> findByIdOrName(Integer id, String name);
	
	List<User> findByIdBetween(Integer x, Integer y);
	
	List<User> findByIdLessThan(Integer x);
	List<User> findByIdLessThanEqual(Integer x);
	List<User> findByIdGreaterThan(Integer x);
	List<User> findByIdGreaterThanEqual(Integer x);
	List<User> findByIdAfter(Integer x);
	List<User> findByIdBefore(Integer x);
	
	List<User> findByNameIsNull();
	List<User> findByNameIsNotNull();
	List<User> findByNameNotNull();
	
	List<User> findByNameLike(String name);
	List<User> findByNameNotLike(String name);
	List<User> findByNameStartingWith(String name);
	List<User> findByNameEndingWith(String name);
	List<User> findByNameContaining(String name);
	
	List<User> findBySexOrderByIdDesc(String sex);
	
	List<User> findByNameNot(String name);
	
	List<User> findByIdIn(Collection<Integer> c);
	List<User> findByIdNotIn(Collection<Integer> c);
}

3.5. 新建UserServiceImpl.java

package com.bjbs.service.impl;

import java.util.Collection;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.bjbs.dao.UserRepository;
import com.bjbs.pojo.User;
import com.bjbs.service.UserService;

@Service
@Transactional
public class UserServiceImpl implements UserService {
	@Autowired
	private UserRepository userRepository;
	
	@Override
	public User findByName(String name) {
		return userRepository.findByName(name);
	}

	@Override
	public User findByNameIs(String name) {
		return userRepository.findByNameIs(name);
	}

	@Override
	public User findByNameEquals(String name) {
		return userRepository.findByNameEquals(name);
	}

	@Override
	public User findByNameAndSex(String name, String sex) {
		return userRepository.findByNameAndSex(name, sex);
	}

	@Override
	public List<User> findByIdOrName(Integer id, String name) {
		return userRepository.findByIdOrName(id, name);
	}

	@Override
	public List<User> findByIdBetween(Integer x, Integer y) {
		return userRepository.findByIdBetween(x, y);
	}

	@Override
	public List<User> findByIdLessThan(Integer x) {
		return userRepository.findByIdLessThan(x);
	}

	@Override
	public List<User> findByIdLessThanEqual(Integer x) {
		return userRepository.findByIdLessThanEqual(x);
	}

	@Override
	public List<User> findByIdGreaterThan(Integer x) {
		return userRepository.findByIdGreaterThan(x);
	}

	@Override
	public List<User> findByIdGreaterThanEqual(Integer x) {
		return userRepository.findByIdGreaterThanEqual(x);
	}

	@Override
	public List<User> findByIdAfter(Integer x) {
		return userRepository.findByIdAfter(x);
	}

	@Override
	public List<User> findByIdBefore(Integer x) {
		return userRepository.findByIdBefore(x);
	}

	@Override
	public List<User> findByNameIsNull() {
		return userRepository.findByNameIsNull();
	}

	@Override
	public List<User> findByNameIsNotNull() {
		return userRepository.findByNameIsNotNull();
	}

	@Override
	public List<User> findByNameNotNull() {
		return userRepository.findByNameIsNotNull();
	}

	@Override
	public List<User> findByNameLike(String name) {
		return userRepository.findByNameLike(name);
	}

	@Override
	public List<User> findByNameNotLike(String name) {
		return userRepository.findByNameNotLike(name);
	}

	@Override
	public List<User> findByNameStartingWith(String name) {
		return userRepository.findByNameStartingWith(name);
	}

	@Override
	public List<User> findByNameEndingWith(String name) {
		return userRepository.findByNameEndingWith(name);
	}

	@Override
	public List<User> findByNameContaining(String name) {
		return userRepository.findByNameContaining(name);
	}

	@Override
	public List<User> findBySexOrderByIdDesc(String sex) {
		return userRepository.findBySexOrderByIdDesc(sex);
	}

	@Override
	public List<User> findByNameNot(String name) {
		return userRepository.findByNameNot(name);
	}

	@Override
	public List<User> findByIdIn(Collection<Integer> c) {
		return userRepository.findByIdIn(c);
	}

	@Override
	public List<User> findByIdNotIn(Collection<Integer> c) {
		return userRepository.findByIdNotIn(c);
	}
	
}

3.6. 新建TestUserRepository.java

package com.bjbs.test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
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 com.bjbs.pojo.User;
import com.bjbs.service.UserService;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestUserRepository {
	@Autowired
	private UserService userService;
	
	/**
	 * 查询姓名等于'曹操'的用户
	 */
	@Test
	public void findByName() {
		User user = userService.findByName("曹操");
		System.out.println(user);
	}

	/**
	 * 查询姓名等于'曹操'的用户
	 */
	@Test
	public void findByNameIs() {
		User user = userService.findByNameIs("曹操");
		System.out.println(user);
	}

	/**
	 * 查询姓名等于'曹操'的用户
	 */
	@Test
	public void findByNameEquals() {
		User user = userService.findByNameEquals("曹操");
		System.out.println(user);
	}

	/**
	 * 查询姓名等于'曹操'并且性别等于'男'的用户
	 */
	@Test
	public void findByNameAndSex() {
		User user = userService.findByNameAndSex("曹操", "男");
		System.out.println(user);
	}

	/**
	 * 查询id等于37或的姓名等于'曹操'所有用户
	 */
	@Test
	public void findByIdOrName() {
		List<User> list = userService.findByIdOrName(37, "曹操");
		for (User user : list) {
			System.out.println(user);
		}
	}
	
	/**
	 * 查询id在30-35之间的所有用户(包括id是30和35的用户)
	 */
	@Test
	public void findByIdBetween() {
		List<User> list = userService.findByIdBetween(30, 35);
		for (User user : list) {
			System.out.println(user);
		}
	}
	
	/**
	 * 查询id<33的所有用户
	 */
	@Test
	public void findByIdLessThan() {
		List<User> list = userService.findByIdLessThan(33);
		for (User user : list) {
			System.out.println(user);
		}
	}
	
	/**
	 * 查询id<=33的所有用户
	 */
	@Test
	public void findByIdLessThanEqual() {
		List<User> list = userService.findByIdLessThanEqual(33);
		for (User user : list) {
			System.out.println(user);
		}
	}
	
	/**
	 * 查询id>55的所有用户
	 */
	@Test
	public void findByIdGreaterThan() {
		List<User> list = userService.findByIdGreaterThan(55);
		for (User user : list) {
			System.out.println(user);
		}
	}
	
	/**
	 * 查询id>=55的所有用户
	 */
	@Test
	public void findByIdGreaterThanEqual() {
		List<User> list = userService.findByIdGreaterThanEqual(55);
		for (User user : list) {
			System.out.println(user);
		}
	}
	
	/**
	 * 查询id>55的所有用户
	 */
	@Test
	public void findByIdAfter() {
		List<User> list = userService.findByIdAfter(55);
		for (User user : list) {
			System.out.println(user);
		}
	}
	
	/**
	 * 查询id<33的所有用户
	 */
	@Test
	public void findByIdBefore() {
		List<User> list = userService.findByIdBefore(33);
		for (User user : list) {
			System.out.println(user);
		}
	}
	
	/**
	 * 查询姓名为Null的所有用户
	 */
	@Test
	public void findByNameIsNull() {
		List<User> list = userService.findByNameIsNull();
		for (User user : list) {
			System.out.println(user);
		}
	}
	
	/**
	 * 查询姓名不是空的所有用户
	 */
	@Test
	public void findByNameIsNotNull() {
		List<User> list = userService.findByNameIsNotNull();
		for (User user : list) {
			System.out.println(user);
		}
	}
	
	/**
	 * 查询姓名不是空的所有用户
	 */
	@Test
	public void findByNameNotNull() {
		List<User> list = userService.findByNameNotNull();
		for (User user : list) {
			System.out.println(user);
		}
	}
	
	/**
	 * 查询姓名包含'河公'的所有用户
	 */
	@Test
	public void findByNameLike() {
		List<User> list = userService.findByNameLike("%河公%");
		for (User user : list) {
			System.out.println(user);
		}
	}
	
	/**
	 * 查询姓名不是以'操'结尾的所有用户
	 */
	@Test
	public void findByNameNotLike() {
		List<User> list = userService.findByNameNotLike("%操");
		for (User user : list) {
			System.out.println(user);
		}
	}
	
	/**
	 * 查询姓名以'李'开头的所有用户
	 */
	@Test
	public void findByNameStartingWith() {
		List<User> list = userService.findByNameStartingWith("李");
		for (User user : list) {
			System.out.println(user);
		}
	}
	
	/**
	 * 查询姓名以'操'结尾的所有用户
	 */
	@Test
	public void findByNameEndingWith() {
		List<User> list = userService.findByNameEndingWith("操");
		for (User user : list) {
			System.out.println(user);
		}
	}
	
	/**
	 * 查询姓名包含'河公'的所有用户
	 */
	@Test
	public void findByNameContaining() {
		List<User> list = userService.findByNameContaining("河公");
		for (User user : list) {
			System.out.println(user);
		}
	}
	
	/**
	 * 查询性别是'女'的所有用户并按id倒序排列
	 */
	@Test
	public void findBySexOrderByIdDesc() {
		List<User> list = userService.findBySexOrderByIdDesc("女");
		for (User user : list) {
			System.out.println(user);
		}
	}
	
	/**
	 * 查询姓名不是'曹操'的所有用户
	 */
	@Test
	public void findByNameNot() {
		List<User> list = userService.findByNameNot("曹操");
		for (User user : list) {
			System.out.println(user);
		}
	}
	
	/**
	 * 查询id是35 42 43 44的这几个用户
	 */
	@Test
	public void findByIdIn() {
		Collection<Integer> c = new ArrayList<Integer>();
		c.add(35);
		c.add(42);
		c.add(43);
		c.add(44);
		List<User> list = userService.findByIdIn(c);
		for (User user : list) {
			System.out.println(user);
		}
	}
	
	/**
	 * 查询id不是35 42 43 44的所有用户
	 */
	@Test
	public void findByIdNotIn() {
		Collection<Integer> c = new ArrayList<Integer>();
		c.add(35);
		c.add(42);
		c.add(43);
		c.add(44);
		List<User> list = userService.findByIdNotIn(c);
		for (User user : list) {
			System.out.println(user);
		}
	}
}

3.7. 在src下新建application.properties

spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://192.168.25.138:3306/StudyMybatis?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=lyw123456

3.8. 在src下新建applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
	
	<!-- 配置读取properties文件的工具类 -->
	<context:property-placeholder location="classpath:application.properties" />

	<!-- 配置c3p0数据库连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="jdbcUrl" value="${spring.datasource.url}" />
		<property name="driverClass" value="${spring.datasource.driverClassName}" />
		<property name="user" value="${spring.datasource.username}" />
		<property name="password" value="${spring.datasource.password}" />
	</bean>

	<!-- Spring整合JPA 配置EntityManagerFactory -->
	<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
				<!-- hibernate相关的属性的注入 -->
				<!-- 配置数据库类型 -->
				<property name="database" value="MYSQL" />
				<!-- 正向工程 自动创建表 -->
				<!-- <property name="generateDdl" value="true" /> -->
				<!-- 显示执行的SQL -->
				<property name="showSql" value="true" />
			</bean>
		</property>
		<!-- 扫描实体的包 -->
		<property name="packagesToScan">
			<list>
				<value>com.bjbs.pojo</value>
			</list>
		</property>
	</bean>

	<!-- 配置Hibernate的事务管理器 -->
	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory" />
	</bean>

	<!-- 配置开启注解事务处理 -->
	<tx:annotation-driven transaction-manager="transactionManager" />

	<!-- 配置springIOC的注解扫描 -->
	<context:component-scan base-package="com.bjbs.service" />

	<!-- Spring Data JPA 的配置 -->
	<!-- base-package: 扫描dao接口所在的包 -->
	<jpa:repositories base-package="com.bjbs.dao" />
</beans>

3.9. 数据库user表

3.10. 查询姓名等于'曹操'的用户 

3.11. 查询姓名等于'曹操'的用户 

3.12. 查询姓名等于'曹操'的用户 

3.13. 查询姓名等于'曹操'并且性别等于'男'的用户 

3.14. 查询id等于37或的姓名等于'曹操'多个用户 

3.15. 查询id在30-35之间的所有用户(包括id是30和35的用户) 

3.16. 查询id<33的所有用户 

3.17. 查询id<=33的所有用户 

3.18. 查询id>55的所有用户 

3.19. 查询id>=55的所有用户 

3.20. 查询id>55的所有用户 

3.21. 查询id<33的所有用户 

3.22. 查询姓名为Null的所有用户

 3.23. 查询姓名不是空的所有用户 

3.24. 查询姓名不是空的所有用户

3.25. 查询姓名包含'河公'的所有用户

3.26. 查询姓名不是以'操'结尾的所有用户 

 3.27. 查询姓名以'李'开头的所有用户

3.28. 查询姓名以'操'结尾的所有用户 

3.29. 查询姓名包含'河公'的所有用户

3.30. 查询性别是'女'的所有用户并按id倒序排列

3.31. 查询姓名不是'曹操'的所有用户 

 3.32. 查询id是35 42 43 44的这几个用户

 3.33. 查询id不是35 42 43 44的所有用户

SpringData JPA复杂查询三：方法命名规则查询
qq_42041712的博客
07-02 2703
SpringData JPA方法命名规则查询 按照Spring Data JPA 定义的规则，查询方法以findBy开头，涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性首字母需大写。框架在进行方法名解析时，会先把方法名多余的前缀截取掉，然后对剩下部分进行解析。 测试一：测试方法命名规则的 查询（查询方式 精准（默认））： findBy 对象中的属性名（首字母...
Spring Data Jpa底层原理剖析、JPQL查询、方法命名规则查询
huangyh技术栈
12-23 5986
1.1 Spring Data Jpa底层原理解析  目标：知道它是怎么运行的？底层到底封装的是谁？、 明确一点：我们所使用的所有框架，底层大多数都使用了动态代理技术、反射技术来封装实现。  分析步骤： 我们只写了接口，但是没有写实现类，这个实现类就是Spring在运行的时候，注入的代理对象。 Spring怎么知道生成的那个dao的实现类？因为在配置文件中指定了dao接口所在的...
spring data jpa根据方法名查询
weixin_33862514的博客
09-19 342
表达式例子hql查询语句 And findByLastnameAndFirstname … where x.lastname = ?1 and x.firstname = ?2 Or findByLastnameOrFirstname … where x.lastname = ?1 or x.firstname = ?2 Is,Equals fi...
JPA 的查询，JPA 根据方法名字查询详细介绍
冰糖会发光
08-07 5703
摘自：https://www.sojson.com/blog/295.html 根据方法名字生成SQL语句（根据方法名查询）。 public interface UserRepository extends Repository&lt;User, Long&gt; { List&lt;User&gt; findByEmailAddressAndLastname(Strin...
68、Spring Data JPA 的 方法名关键字查询（全自动，既不需要提供sql语句，也不需要提供方法体）
Java 领域技术分享
09-15 1268
Spring Data JPA 的 方法名关键字查询
Spring Data JPA ：方法命名规则查询
tangiwang的博客
04-20 1580
只需要按照Spring Data JPA提供的方法命名规则定义方法的名称，就可以完成查询工作。程序执行的时候会根据方法名称进行解析，并自动生成sql语句进行查询。 /** * 只要根据 约定的方法命名，可以不写sql（hql）语句. * 方法名的约定： * findBy : 查询 * 对象中的属性名（首字母大写） ： 查询的条件 * CustName * * 默认情况 ： 使用 等于的方式查询 * 特殊的查询方式 * <p> * findByCustName -- 根据
Spring Data JPA的优点和难点.pdf
12-05
- Spring Data JPA支持DQL（Domain Query Language）风格的方法命名，使得查询语句的编写变得直观且易于理解。例如，`findByLastnameIgnoreCase` 方法会忽略大小写进行查询，`...
jpa 去重_SpringDataJPA系统（3）
weixin_32513585的博客
02-17 2302
DQM的命名语法与参数在工作中，你是否经常为方法名的语义、命名规范而发愁？是否要为不同的查询条件写各种的 SQL 语句？是否为同一个实体的查询，写一个超级通用的查询方法或者 SQL？如果其他开发同事不查看你写的 SQL 语句，而直接看方法名的话，却不知道你想查什么而郁闷？Spring Data JPA 的 Defining Query Methods(DQM)通过方法名和参数，可以很好地解决上面的...
Spring Data JPA 简单查询--方法定义规则(详解)
08-30
首先，Spring Data JPA 的查询方法命名遵循一定的规则，通常以 `find`、`read` 或 `get` 开头，如 `findAll()`、`findByAge()` 等。在这些方法中，条件查询的关键字是方法名的一部分，它们对应于SQL中的各种比较操作...
JPA查询方式：方法命名规则、@Query查询、结果集类型转化器
qq_43975645的博客
07-20 1522
注意：在这里的SQL操作都是基于对象，使用的为对象属性，非数据库字段。在持久层接口中，可以直接根据方法的名字进行条件查询。，而非复杂的、定制的SQL的处理，表中的字段，所以最终封装到。保留了写SQL的方法，
Spring Data JPA基于方法名称命名规则查询
gryhan的博客
05-06 3167
Repository 接口是 Spring Data JPA 中为我我们提供的所有接口中的顶层接口 Repository 提供了两种查询方式的支持 1）基于方法名称命名规则查询 2）基于@Query 注解查询 其中，基于方法名称命名规则查询： ...
SpringBoot使用SpringDataJPA通过方法名查询
weixin_44232093的博客
05-02 1273
文章目录JPA方法名查询1. 方法名表图2. 举例说明3. 测试 JPA方法名查询 约定方法名一定要根据命名规范来书写，Spring Data 会根据前缀、中间连接词（Or、And、Like、NotNull 等类似 SQL 中的关键字）、内部拼接 SQL 代理生成方法的实现,约定方法名的方法见表: 1. 方法名表图 关键词 SQL符号 举例 最终执行的JPQL 片段 And and findByAddressLikeAndState … where x.lastname = ?1 and x
SpringDataJPA方法命名规范
weixin_46007404的博客
04-21 994
SpringDataJPA配置及其方法命名规范 示例： 1.Employee实体类： @Entity public class Employee { private Integer empId; private String empAddress; private Integer empAge; private String empGender; private String em...
spring data jpa通过方法名称定义查询的实现机制解析
u013905744的专栏
09-27 2782
使用方法 spring data jpa其实体Repository继承Repository接口，如JpaRepository等接口，也可以选择JpaSpecificationExecutor，这样就可以使用方法名称，来定义查询 如 List<User> findByEmailAddressAndLastname(EmailAddress emailAddress, String lastname) List<User> findDistinctPeopleByLastnameOrFi
如何在Spring中使用JPA的命名查询？
java永无止境！
07-27 817
命名查询（Named Query）在实体类中通过使用或注解定义。命名查询的名字通常是按照实体名.查询名的形式构成，这样可以帮助组织和引用查询。举个例子，假设有一个叫做User@Entity@Id// 其他属性...在上面的例子中，我们定义了一个名为的查询。当我们需要通过用户名来查找用户时，将可以使用这个命名查询。
SpringDataJpa中,直接按照命名规范命名就能查询的实现原理
JavaMyDream的博客
04-01 344
【代码】SpringDataJpa中,直接按照命名规范命名就能查询的实现原理。
第二百九十五节 JPA教程 - JPA查询命名示例
最新发布
2301_78772942的博客
10-24 548
第二百九十五节 JPA教程 - JPA查询命名示例
SpringBoot_JPA之命名查询
tangyaya8的博客
11-04 2460
Named-Query 就是在Entity上定义相关的查询方法，然后在Session中查询的时候，可以调用这个方法，实现相关的查询 XML方式 Person类： package com.tangbaobao.springbootjpa.pojo; import lombok.Data; import javax.persistence.Entity; import javax.persiste...
Spring Data Jpa的方法命名规则
在路上
09-03 1607
关键字 方法命名 sql where字句 And findByNameAndPwd where name= ? and pwd =? Or findByNameOrSex where name= ? or sex=? Is,Equals findById,findByIdEquals where id= ? Between fi...
Spring Data JPA 中文文档关键概念与查询方法解析
"SpringDataJPA中文文档[1.4.3]" Spring Data JPA是Spring框架的一个模块，它简化了Java Persistence API (JPA)的使用，提供了一种声明式的方式来处理数据访问。这份中文文档详细介绍了如何利用Spring Data JPA进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值