SpringData JPA提供的五个接口及其简单实现

最新推荐文章于 2022-09-20 17:10:04 发布
最新推荐文章于 2022-09-20 17:10:04 发布
阅读量1.1k 收藏 3
点赞数 1
分类专栏： # SpringData 文章标签： Spring Data JPA Spring Data JPA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rj2017211811/article/details/96154848
版权

1.Repository接口
用户定义的dao接口继承Repository接口后即可根据方法命名规则或@Query查询对数据库进行操作
在这里插入图片描述
UsersDao.java

package per.czt.dao;

import java.util.List;

import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;

import per.czt.pojo.Users;

public interface UsersDao extends Repository<Users, Integer> {

	//方法名称命名规则
	List<Users> findByUsernameIs(String username);

	List<Users> findByUsernameLike(String username);
	
	List<Users> findByUsernameAndUserageGreaterThanEqual(String username,Integer userage);
	//使用@Query注解查询，类似hql查询
	@Query(value="from Users where username=?")
	List<Users> queryUserByNameJPQL(String username);
	@Query(value="from Users where username like ?")
	List<Users> queryUsernameLikeJPQL(String username);
	@Query(value="from Users where username=? and userage>=?")
	List<Users> queryByUsernameAndUserageGreaterThanEqual(String username,Integer userage);
	
	//使用@Query进行SQL查询,要写nativeQuery=true
	@Query(value="select * from t_users where user_name=?",nativeQuery=true)
	List<Users> queryUserByUsernameUseSQL(String username);
	@Query(value="select * from t_users where user_name like ?",nativeQuery=true)
	List<Users> queryUsernameLikeUseSQL(String username);
	
	@Query(value="select * from t_users where user_name=? and user_age>=?",nativeQuery=true)
	List<Users> queryByUsernameAndUserageGreaterThanEqualUseSQL(String username,Integer userage);
	
	//使用@Query进行更新
	@Query(value="update Users set userage=? where userid=?")
	@Modifying//要写@Modifying
	void updateUsersByUserage(Integer userage,Integer userid);
}

RepositoryTest.java

package per.czt.test;

import java.util.List;

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;

import per.czt.dao.UsersDao;
import per.czt.pojo.Users;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class RepositoryTest {
	@Autowired
	private UsersDao usersDao;
	
	/*
	 * 判断相等
	 * 1.什么都不写
	 * 2.Is
	 * 3.Equal
	 * 
	 */
	@Test
	public void test1() {
		List<Users> usersList=usersDao.findByUsernameIs("李四");
		for(Users users:usersList) {
			System.out.println(users.toString());
		}
	}
	/*
	 * 对姓名做Like处理
	 * 
	 */
	@Test
	public void test2() {
		List<Users> usersList=usersDao.findByUsernameLike("李四%");
		for(Users users:usersList) {
			System.out.println(users.toString());
		}
	}
	/*
	 * 查询姓名为李四并且年龄大于等于28
	 */
	@Test
	public void test3() {
		List<Users> usersList=usersDao.findByUsernameAndUserageGreaterThanEqual("李四", 28);
		for(Users users:usersList) {
			System.out.println(users.toString());
		}
	}
	
	@Test
	public void test4() {
		List<Users> usersList=usersDao.queryUserByNameJPQL("李四");
		for(Users users:usersList) {
			System.out.println(users.toString());
		}
	}
	@Test
	public void test5() {
		List<Users> usersList=usersDao.queryUsernameLikeJPQL("李%");
		for(Users users:usersList) {
			System.out.println(users.toString());
		}
	}
	
	@Test
	public void test6() {
		List<Users> usersList=usersDao.queryByUsernameAndUserageGreaterThanEqual("李四", 20);
		for(Users users:usersList) {
			System.out.println(users.toString());
		}
	}
	
	@Test
	public void test7() {
		List<Users> usersList=usersDao.queryUserByUsernameUseSQL("张三");
		for(Users users:usersList) {
			System.out.println(users.toString());
		}
	}
	
	@Test
	public void test8() {
		List<Users> usersList=usersDao.queryUsernameLikeUseSQL("%三");
		for(Users users:usersList) {
			System.out.println(users.toString());
		}
	}
	
	@Test
	public void test9() {
		List<Users> usersList=usersDao.queryByUsernameAndUserageGreaterThanEqualUseSQL("张三", 1);
		for(Users users:usersList) {
			System.out.println(users.toString());
		}
	}
	
	@Test
	@Transactional
	@Rollback(false)
	//更新操作要进行事务提交
	public void test10() {
		usersDao.updateUsersByUserage(11, 4);
	}
	
	

}

2.CrudRepostory接口
对于简单的查询(根据主键查询，查询所有)，还有插入、更新、删除操作用户无需自己定义，只需继承CrudRepostory接口即可调用相应的方法
UsersDao.java

package per.czt.dao;


import org.springframework.data.repository.CrudRepository;


import per.czt.pojo.Users;

public interface UsersDao extends CrudRepository<Users, Integer> {
}

CrudRepositoryTest.java

package per.czt.test;

import java.util.ArrayList;
import java.util.List;

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;

import per.czt.dao.UsersDao;
import per.czt.pojo.Users;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class CrudRepositoryTest {
	@Autowired
	private UsersDao usersDao;
	@Test
	public void test() {
		
	}
	/*
	 * 添加
	 */
	 	//CrudRepository接口的save自己实现了事务
	@Test
	public void test1() {
		Users user=new Users();
		user.setUserage(12);
		user.setUsername("李明");
		usersDao.save(user);
	}
	/*
	 * 批量添加
	 */
	@Test
	//CrudRepository接口的save自己实现了事务
	public void test2() {
		Users user1=new Users();
		user1.setUserage(15);
		user1.setUsername("赵晓丽");
		
		Users user2=new Users();
		user2.setUserage(19);
		user2.setUsername("王小虎");
		
		Users user3=new Users();
		user3.setUserage(19);
		user3.setUsername("宋晓路");
		
		List<Users> usersList=new ArrayList<Users>();
		usersList.add(user1);
		usersList.add(user2);
		usersList.add(user3);
		
		usersDao.save(usersList);
		
	}
	/*
	 * 删除
	 */
	@Test
	public void test6() {
		this.usersDao.delete(10);
		
	}
	/*
	 * 根据主键查询
	 */

	@Test
	public void test4() {
		Users user=usersDao.findOne(15);
		System.out.println(user);
	}
	/*
	 * 查询所有
	 */
	@Test
	public void test5() {
		List<Users> usersList=(List<Users>) usersDao.findAll();
		for(Users user:usersList) {
			System.out.println(user);
		}
	}
	
	
	/*
	 * 更新-1
	 */
	@Test
	//CrudRepository接口的save自己实现了事务
	public void test7() {
		Users user=usersDao.findOne(14);
		user.setUsername("姜理");
		user.setUserage(10);
		usersDao.save(user);
	}

	/*
	 * 更新-2
	 */
	@Test
	@Transactional
	@Rollback(false)
	public void test8() {
		
		Users user=usersDao.findOne(6);
		//此时对象处于持久态
		
		user.setUsername("张三丰");
		
	}
}

3.PageAndSortingRepository接口
该接口提供了分页和排序的操作，和CrudRepository一样，只需继承该接口，就可以调用相应的方法
UsersDao.java

package per.czt.dao;



import org.springframework.data.repository.PagingAndSortingRepository;

import per.czt.pojo.Users;

public interface UsersDao extends PagingAndSortingRepository<Users, Integer> {
}

PageAndSortingRepositoryTest.java

package per.czt.test;

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.domain.Sort.Order;
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;


import per.czt.dao.UsersDao;
import per.czt.pojo.Users;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class PageAndSortingRepositoryTest {
	@Autowired
	private UsersDao usersDao;
	/*
	 * 分页
	 */
	@Test
	public void test() {
		int page=1;
		int size=3;
		Pageable pageable=new PageRequest(page,size);
		Page<Users> pages=this.usersDao.findAll(pageable);
		System.out.println("所有记录的数目:"+pages.getTotalElements());
		System.out.println("当前页的数目:"+pages.getSize());
		System.out.println("页的数目:"+pages.getTotalPages());
		List<Users> usersList=pages.getContent();
		for(Users user:usersList) {
			System.out.println(user);
		}
	}
	/*
	 * 排序
	 */
	@Test
	public void test2() {
		//Sort:该对象封装了排序规则以及制定的排序字段(对象的属性来表示)
		//direction：排序规则
		//properties:指定做排序的属性
		
		Sort sort=new Sort(Direction.DESC,"userid");
		
		List<Users> usersList=(List<Users>) this.usersDao.findAll(sort);
		for(Users user:usersList) {
			System.out.println(user);
		}
	}
	/*
	 * 多个排序规则的排序
	 */
	@Test
	public void test3() {
		Order order1=new Order(Direction.DESC,"username");
		Order order2=new Order(Direction.DESC,"userage");
		Sort sort=new Sort(order1,order2);
		List<Users> usersList=(List<Users>) this.usersDao.findAll(sort);
		for(Users user:usersList) {
			System.out.println(user);
		}
		
		
	}
	
	
}

4.JpaRepository接口
该接口对前面接口的返回值进行了适配处理，比如继承该接口后调用findAll方法直接返回List<实体>

UsersDao.java

package per.czt.dao;



import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.repository.PagingAndSortingRepository;

import per.czt.pojo.Users;

public interface UsersDao extends JpaRepository<Users, Integer> {
}

JpaRepositoryTest.java

package per.czt.test;

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.domain.Sort.Order;
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;


import per.czt.dao.UsersDao;
import per.czt.pojo.Users;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JpaRepositoryTest {
	@Autowired
	private UsersDao usersDao;
	/*
	 * 查询所有
	 */
	@Test
	public void test() {
		List<Users> usersList=usersDao.findAll();
		for(Users user:usersList) {
			System.out.println(user);
		}
	}
	/*
	 * 分页
	 */
	@Test
	public void test2() {
		Pageable pageable=new PageRequest(0, 2);
		Page<Users> pages=usersDao.findAll(pageable);
		for(Users user:pages.getContent()) {
			System.out.println(user);
		}
		
		
	}
	
}

5.JpaSpecificationExecutor接口
该接口提供了多条件查询的方法，不单独使用，配合其他接口一起使用
UsersDao.java

package per.czt.dao;



import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.PagingAndSortingRepository;

import per.czt.pojo.Users;

public interface UsersDao extends JpaRepository<Users, Integer>,JpaSpecificationExecutor<Users> {
}

JpaSpecificationExectorTest.java

package per.czt.test;


import java.util.ArrayList;
import java.util.List;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.domain.Sort.Order;
import org.springframework.data.jpa.domain.Specification;

import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;



import per.czt.dao.UsersDao;
import per.czt.pojo.Users;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JpaSpecificationExectorTest {
	@Autowired
	private UsersDao usersDao;
	/*
	 * 单条件
	 */
	@Test
	public void test() {
		Specification<Users> spec=new Specification<Users>() {
			/*
			 * 
			 * (non-Javadoc)
			 * @see org.springframework.data.jpa.domain.Specification#toPredicate(javax.persistence.criteria.Root, javax.persistence.criteria.CriteriaQuery, javax.persistence.criteria.CriteriaBuilder)
			 *Predicate:定义了查询条件
			 *root:封装了查询条件的对象
			 * CriteriaQuery<?>:定义了基本的查询功能，一般不使用
			 * CriteriaBuilder :创建一个查询条件
			 */

			@Override
			public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
				Predicate cate=cb.equal(root.get("username"), "李四");
				
				return cate;
			}
		};
		List<Users> usersList=usersDao.findAll(spec);
		for(Users user:usersList) {
			System.out.println(user);
		}
		
	}
    /*
     * 多条件-1
     */
	@Test
	public void test2() {
		Specification<Users> spec=new Specification<Users>() {

			@Override
			public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> arg1, CriteriaBuilder cb) {
				// TODO Auto-generated method stub
				List<Predicate> predicateList=new ArrayList<Predicate>();
				predicateList.add(cb.equal(root.get("username"), "李四"));
				predicateList.add(cb.equal(root.get("userage"),28));
			
				//return cb.and(predicateList.get(0),predicateList.get(1));
				Predicate []arr=new Predicate[predicateList.size()];
				return cb.and(predicateList.toArray(arr));
			}
		};
		List<Users> usersList=usersDao.findAll(spec);
		for(Users user:usersList) {
			System.out.println(user);
		}
	}
	/*
	 * 多条件-2
	 */
	@Test
	public void test3() {
		Specification<Users> spec=new Specification<Users>() {
			
			@Override
			public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
				// TODO Auto-generated method stub
				return cb.or(cb.equal(root.get("username"), "李四"),cb.equal(root.get("userage"), 15));
			}
		};
		List<Users> usersList=usersDao.findAll(spec);
		for(Users user:usersList) {
			System.out.println(user);
		}
	}
	/*
	 * 分页
	 */
	
	@Test
	public void test4() {
       Specification<Users> spec=new Specification<Users>() {
			
			@Override
			public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
				// TODO Auto-generated method stub
				return cb.like(root.get("username").as(String.class), "王%");
			}
		};
		Pageable pageable=new PageRequest(0,2);
		Page<Users> pages= usersDao.findAll(spec,pageable);
		List<Users> usersList=pages.getContent();
		for(Users user:usersList) {
			System.out.println(user);
		}
		
	}
	/*
	 * 排序
	 */
	@Test
	public void test5() {
		Specification<Users> spec=new Specification<Users>() {

			@Override
			public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> arg1, CriteriaBuilder cb) {
				// TODO Auto-generated method stub
				return cb.like(root.get("username").as(String.class), "李%");
			}
		};
		Order order1=new Order(Direction.ASC,"username");
		Order order=new Order(Direction.DESC,"userage");
		
		Sort sort=new Sort(order1,order);
		
		List<Users> usersList=usersDao.findAll(spec, sort);
		for(Users user:usersList) {
			System.out.println(user);
		}
	}
	/*
	 * 分页+排序
	 */
	@Test
	public void test6() {
		
		Specification<Users> spec=new Specification<Users>() {

			@Override
			public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> arg1, CriteriaBuilder cb) {
				// TODO Auto-generated method stub
				return cb.like(root.get("username").as(String.class), "李%");
			}
		};
		Sort sort=new Sort(new Order(Direction.ASC,"username"),new Order(Direction.DESC,"userage"));
		
		Pageable pageable=new PageRequest(1, 2, sort);
		Page<Users> pages=usersDao.findAll(spec, pageable);
		List<Users> usersList=pages.getContent();
		for(Users user:usersList) {
			System.out.println(user);
		}
		
	}
}
I like study.
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Data JPA API（Spring Data JPA 开发文档）.CHM
08-31
Spring Data JPA API。 Spring Data JPA 开发文档。 官网 Spring Data JPA API。
Spring Data JPA的优点和难点.pdf
12-05
3. 与Spring全家桶结合紧密： 4. 成熟的框架和架构 常⻅的SQL性能问题，如何优雅处理? 2. 错综复杂的关联关系如何应对？ 3. 万恶的LazyException本质是什么？ 4. ⾼并发⾼性能要求的API服务要⽤JPA吗？
Spring Data JPA中的七大接口和两大实现类
小青的博客
09-18 2468
Spring Data JPA 中的七大接口和两大实现类 接口 *PS：都是在org.springframework.data.包中的。 Repository接口 CrudRepository接口 PagingAndSortingRepository接口 JpaRepository接口 QueryByExampleExecutor接口 JpaSpecificationExecutor接口 Quer...
Spring Data JPA提供的接口
遭不住啊
08-16 256
一、SpringBoot JPA提供的核心接口 1、Repository接口 2、CrudRepository接口 3、PagingAndSortingRepository接口 4、JpaRepository接口 5、JPASpecificationExecutor接口 各个接口的继承体系图 CrudRepository接口 PagingAndSortingRepository接口 JpaRepository接口 JPASpecificationExecutor接口 该接口主要是提供了多条件查询的支持
2020-07-02 回顾SpringdataJPA之接口分析
weixin_44092667的博客
07-02 244
1、SpringDataJPA Spring Data JPA 是 spring data 项目下的一个模块。提供了一套基于 JPA标准操作数据库的简化方案。底层默认的是依赖 Hibernate JPA 来实现的。 2、SpringDataJPA的技术特点 我们只需要定义接口并集成 Spring Data JPA 中所提供的接口就可以了。不需要编写接口实现类。 3、Spring Data JPA 的接口继承结构 CrudRepository才真正实现增删改查 4、Repository 接口相关 Rep
spring data jpa 接口
qq_40979622的博客
10-21 198
主要来看看Spring Data JPA提供的接口，也是Spring Data JPA的核心概念：1：Repository：最顶层的接口，是一个空的接口，目的是为了统一所有Repository的类型，且能让组件扫描的时候自动识别。                    https://blog.csdn.net/u014268482/article/details/81014104      ...
JPA数据接口
qq_25692465的博客
07-13 274
jpa的数据操作接口 public interface UserRepository extends JpaRepository&lt;User,String&gt;{ /** * 相当于 select *from user where name=? * @param name * @return */ public List&lt;User&gt; findByName(Strin...
jpa接口详解
【轰炸机】的博客
08-30 1133
jpa接口详解RepositoryCrudRepositoryPagingAndSortingRepository @Data @Entity // 声明这个类对应了一个数据库表 @Table(name = "BB_CLOTHES") // 声明了数据库实体对应的表信息,如果没有指定，则表名和实体的名称保持一致 public class Clothes implements Serializable{ private static final long serialVersionUID = -301880
Spring Data Jpa实现自定义repository转DTO
08-18
主要介绍了Spring Data Jpa实现自定义repository转DTO,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring Data JPA中文文档[1.4.3]_springdatajpa_erlang_waitxpf_
10-02
Spring Data JPA中文文档1.4.3
Spring Data Jpa 复合主键的实现
08-26
主要介绍了Spring Data Jpa 复合主键的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
keyword in Jpa
10-25 1018
Keyword Sample JPQL snippet And findByLastnameAndFirstname … where x.lastname = ?1 and x.firstname = ?2 Or findByLastnameOrFirstname … where x.lastname = ?1 or x.fi
Spring系列：JPA 常用接口和方法
NIO4444
07-25 1168
基本方法 方法定义规则 符号 含义 And 并且 Or 或 Is,Equals 等于 Between 两者之间 LessThan 小于 LessThanEqual 小于等于 GreaterTh...
JPA相关接口/类
panzm_csdn的博客
04-18 740
Persistence•Persistence  类是用于获取EntityManagerFactory实例。该类包含一个名为createEntityManagerFactory的静态方法 。•createEntityManagerFactory方法有如下两个重载版本。–带有一个参数的方法以JPA配置文件persistence.xml中的持久化单元名为参数–带有两个参数的方法：前一个参数含义相同，后...
十四、Spring Data JPA 常用接口
weixin_45611944的博客
01-30 1623
Spring Data JPA 常用接口
SpringDataJPA的接口
xinyihhh的博客
09-20 1077
JPA
认识JPA的接口---Java持久化API(2)
qq_43419105的博客
05-08 406
认识JPA的接口 前言 JPA提供了操作数据库的接口。在开发过程中继承和使用这些接口，可简化现有的持久化开发工作。可以使Spring 找到自定义接口，并生成代理类，后续可以把自定义接口注入Spring容器中进行管理。在自定义接口过程中，可以不写相关的SQL操作，由代理自动生成。 JPA接口JpaRepository JpaRepository 继承自 PagingAndSortingRepository。该接口提供了JPA的相关实用功能。以及通过Example进行查询的功能。Example对象是JPA提供用
SpringData JPA -JPA接口体系
失忆๑的博客
08-20 287
一）JPA接口的继承结构 1.1）SpringData 加入的主要是两个包 1.SpringData-Commons.jar 2.SpringData-jpa.jar 1.2）JPA接口分布在这两个包下每个接口主要的作用和方法介绍 1.JapResposttory：接口 该接口是开放是常用的接口，此接口为封装了对数据库常用的Curd操作。 此接口存放于SpringData-...
jpa使用方法的几种分类
yuhui666666的博客
06-13 572
见结算项目     用jpa的都是单实体，如果需要复杂bo查询需要再dao上嫁接一个接口，其实现类用jdmctemlpate,或mybatis（用的时候还是用主的dao接口） jpa使用大致分二种：（都是基于单个实体的），此二者都有自带分页的参数方法     1，继承JpaRepository的dao可以用@query注解 也可根据名字判别查询     2，继承JpaSpe...
怎么创建一个 Spring Data JPA 的 Repository 接口
最新发布
06-09
创建一个 Spring Data JPA 的 Repository 接口非常简单，只需要按照以下步骤操作即可： 1. 创建一个继承自 `JpaRepository` 的接口，指定实体类和主键类型： ``` public interface UserRepository extends Jpa...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值