SpringBoot----SpringBoot 整合Spring Data JPA(一)

最新推荐文章于 2023-02-23 10:46:39 发布
最新推荐文章于 2023-02-23 10:46:39 发布
阅读量214 收藏
点赞数
分类专栏： SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Miracle_Gaaral/article/details/102914542
版权

一.Spring Data JPA介绍

二.SpringBoot 整合Spring Data JPA

1.修改pom文件,添加坐标

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

		<!-- spring data jpa的启动器 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>

2.在项目中添加application.properties文件

spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
spring.datasource.username=root
spring.datasource.password=root

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

3.添加实体类

package com.kennosaur.pojo;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "t_users")
public class Users implements Serializable{
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "id")
	private Integer id;
	@Column(name = "name")
	private String name;
	@Column(name = "age")
	private Integer age;
	@Column(name = "address")
	private String 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 Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	@Override
	public String toString() {
		return "Users [id=" + id + ", name=" + name + ", age=" + age + ", address=" + address + "]";
	}
	
	
	
}

5.编写DAO接口

package com.kennosaur.dao;

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

import com.kennosaur.pojo.Users;

/**
 * 参数一T:当前需要映射的实体
 * 参数二ID:当前映射的实体中的OID的类型
 * @author Administrator
 *
 */
public interface UsersRepository extends JpaRepository<Users, Integer> {

}

6.在pom文件中添加测试启动器的坐标

		<!-- 添加junit环境的jar包 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
		</dependency>

7.创建启动类

package com.kennosaur;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class App {
	public static void main(String[] args) {
		SpringApplication.run(App.class, args);
	}
}

8.编写测试代码

package com.kennosaur.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.kennosaur.App;
import com.kennosaur.dao.UsersRepository;
import com.kennosaur.pojo.Users;

/**
 * 测试类
 * @author Administrator
 *
 */

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = App.class)
public class UsersRepositoryTest {
	@Autowired
	private UsersRepository usersRepository;
	
	@Test
	public void testSave() {
		Users users = new Users();
		users.setAddress("北京市海淀");
		users.setAge(20);
		users.setName("张三");
		this.usersRepository.save(users);
	}
}

三.Spring Data JPA提供的核心接口

1.Repository接口

2.CrudRepository接口

3.PagingAndSortingRepository接口

4.JpaRepository接口

5.JPASpecificationExecutor接口

四.Repository接口的使用

1.提供了方法名称命名查询方式

1.1编写接口

//方法的名称必须要遵循驼峰式命名规则。findBy(关键字)+属性名称(首字母要大写)+查询条件(首字母大写)

package com.kennosaur.dao;

import java.util.List;

import org.springframework.data.repository.Repository;

import com.kennosaur.pojo.Users;

/**
 * Repository接口的方法名称命名查询
 *
 *
 */
public interface UsersRepositoryByName extends Repository<Users, Integer> {

	//方法的名称必须要遵循驼峰式命名规则。findBy(关键字)+属性名称(首字母要大写)+查询条件(首字母大写)
	List<Users> findByName(String name);
	
	List<Users> findByNameAndAge(String name,Integer age);
	
	List<Users> findByNameLike(String name);
}

1.2测试代码

package com.kennosaur.test;

import java.util.List;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.kennosaur.App;
import com.kennosaur.dao.UsersRepository;
import com.kennosaur.dao.UsersRepositoryByName;
import com.kennosaur.pojo.Users;

/**
 * 测试类
 * @author Administrator
 *
 */

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = App.class)
public class UsersRepositoryTest {
	
	@Autowired
	private UsersRepositoryByName usersRepositoryByName;
	
	
	/**
	 * Repository--方法名称命名测试
	 */
	@Test
	public void testFindByName(){
		List<Users> list = this.usersRepositoryByName.findByName("张三");
		for (Users users : list) {
			System.out.println(users);
		}
	}
	
	/**
	 * Repository--方法名称命名测试
	 */
	@Test
	public void testFindByNameAndAge(){
		List<Users> list = this.usersRepositoryByName.findByNameAndAge("张三", 20);
		for (Users users : list) {
			System.out.println(users);
		}
	}
	
	/**
	 * Repository--方法名称命名测试
	 */
	@Test
	public void testFindByNameLike(){
		List<Users> list = this.usersRepositoryByName.findByNameLike("张%");
		for (Users users : list) {
			System.out.println(users);
		}
	}
}

2.提供了基于@Query注解查询与更新

2.1编写接口

@Query("update Users set name=:name where id=:id") --------注意使用?占位符会报错
@Modifying //需要执行一个更新操作

package com.kennosaur.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 com.kennosaur.pojo.Users;

public interface UsersRepositoryQueryAnnotation extends Repository<Users, Integer> {
	@Query("from Users where name=:name")
	List<Users> queryByNameUseHQL(String name);
	
	@Query(value="select * from t_users where name = ?",nativeQuery=true)
	List<Users> queryByNameUseSQL(String name);
	
	@Query("update Users set name=:name where id=:id")
	@Modifying //需要执行一个更新操作
	void updateUsersNameById(String name,Integer id);
}

2.2测试代码

    @Transactional //@Transactional与@Test 一起使用时 事务是自动回滚的。
    @Rollback(false) //取消自动回滚

package com.kennosaur.test;

import java.util.List;

import javax.transaction.Transactional;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.kennosaur.App;
import com.kennosaur.dao.UsersRepository;
import com.kennosaur.dao.UsersRepositoryByName;
import com.kennosaur.dao.UsersRepositoryQueryAnnotation;
import com.kennosaur.pojo.Users;

/**
 * 测试类
 * @author Administrator
 *
 */

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = App.class)
public class UsersRepositoryTest {
	@Autowired
	private UsersRepositoryQueryAnnotation usersRepositoryQueryAnnotation;
	
	/**
	 * Repository--@Query测试
	 */
	@Test
	public void testQueryByNameUseHQL() {
		List<Users> list = this.usersRepositoryQueryAnnotation.queryByNameUseHQL("张三");
		for (Users users : list) {
			System.out.println(users);
		}
	}

	/**
	 * Repository--@Query测试
	 */
	@Test
	public void testQueryByNameUseSQL() {
		List<Users> list = this.usersRepositoryQueryAnnotation.queryByNameUseSQL("张三");
		for (Users users : list) {
			System.out.println(users);
		}
	}
	
	/**
	 * Repository--@Query测试
	 */
	@Test
	@Transactional //@Transactional与@Test 一起使用时 事务是自动回滚的。
	@Rollback(false) //取消自动回滚
	public void testUpdateUsersNameById() {
		this.usersRepositoryQueryAnnotation.updateUsersNameById("张三三", 1);
	}
	

	
	
}

五.CrudRepository接口-----主要作用是完成一些增删改查的操作,CrudRepository接口继承了Repository接口

1.编写接口

package com.kennosaur.dao;

import org.springframework.data.repository.CrudRepository;

import com.kennosaur.pojo.Users;

/**
 * CrudRepository接口
 *
 *
 */
public interface UsersRepositoryCrudRepository extends CrudRepository<Users, Integer> {

}

2.测试代码

注意:Optional<Users> users = this.usersRepositoryCrudRepository.findById(4);

	/**
	 * CrudRepository测试
	 */
	@Test
	public void testCrudRepositorySave() {
		Users user = new Users();
		user.setAddress("天津");
		user.setAge(32);
		user.setName("张三丰");
		this.usersRepositoryCrudRepository.save(user);
	}
	
	/**
	 * CrudRepository测试
	 */
	@Test
	public void testCrudRepositoryUpdate() {
		Users user = new Users();
		user.setId(4);
		user.setAddress("南京");
		user.setAge(40);
		user.setName("张三丰");
		this.usersRepositoryCrudRepository.save(user);
	}
	
	/**
	 * CrudRepository测试
	 */
	@Test
	public void testCrudRepositoryFindOne() {
		Optional<Users> users = this.usersRepositoryCrudRepository.findById(4);
		System.out.println(users);
	}
	
	/**
	 * CrudRepository测试
	 */
	@Test
	public void testCrudRepositoryFindAll() {
		List<Users> list  =  (List<Users>)this.usersRepositoryCrudRepository.findAll();
		for (Users users : list) {
			System.out.println(users);
		}
	}
	
	/**
	 * CrudRepository测试
	 */
	@Test
	public void testCrudRepositoryDeleteById() {
		this.usersRepositoryCrudRepository.deleteById(4);
		
	}

六.PagingAndSortingRepository接口-------提供了分页与排序操作,该接口继承了CrudRepository接口

1.编写接口

package com.kennosaur.dao;

import org.springframework.data.repository.PagingAndSortingRepository;

import com.kennosaur.pojo.Users;
/**
 * 
 *PagingAndSortingRepository接口
 *
 */
public interface UsersRepositoryPagingAndSorting extends PagingAndSortingRepository<Users,Integer> {

}

2.测试代码

注意:Sort sort = new Sort(order);报错

Pageable pageable = new PageRequest(1, 2);报错

Pageable pageable = new PageRequest(1, 2, sort);报错

	/**
	 * PagingAndSortingRepository   排序测试
	 */
	@Test
	public void testPagingAndSortingRepositorySort() {
		//Order 定义排序规则
		Order order = new Order(Direction.DESC,"id");
		//Sort对象封装了排序规则
//		Sort sort = new Sort(order);
		List<Users> list = (List<Users>)this.usersRepositoryPagingAndSorting.findAll(Sort.by(order));
		for (Users users : list) {
			System.out.println(users);
		}
	}
	
	/**
	 * PagingAndSortingRepository   分页测试
	 */
	@Test
	public void testPagingAndSortingRepositoryPaging() {
		//Pageable:封装了分页的参数，当前页，每页显示的条数。注意：他的当前页是从0开始。
		//PageRequest(page,size) page:当前页。size:每页显示的条数
//		Pageable pageable = new PageRequest(1, 2);
		Pageable pageable = PageRequest.of(1, 2);
	    Page<Users> page = this.usersRepositoryPagingAndSorting.findAll(pageable);
		System.out.println("总条数："+page.getTotalElements());
		System.out.println("总页数"+page.getTotalPages());
		List<Users> list = page.getContent();
		for (Users users : list) {
			System.out.println(users);
		}
	}
	
	/**
	 * PagingAndSortingRepository   排序+分页
	 */
	@Test
	public void testPagingAndSortingRepositorySortAndPaging() {
		
//		Sort sort = new Sort(new Order(Direction.DESC, "id"));		
//		Pageable pageable = new PageRequest(1, 2, sort);
		
		Sort sort = Sort.by(new Order(Direction.DESC, "id"));		
		Pageable pageable = PageRequest.of(1, 2, sort);
				
		Page<Users> page = this.usersRepositoryPagingAndSorting.findAll(pageable);
		System.out.println("总条数："+page.getTotalElements());
		System.out.println("总页数"+page.getTotalPages());
		List<Users> list = page.getContent();
		for (Users users : list) {
			System.out.println(users);
		}
	}

 

七.JpaRepository接口----------开发中用的比较多.

继承了PagingAndSortingRepository接口,对继承的父接口中的方法的返回值进行适配(不需要做强制类型转换)

1.编写接口

package com.kennosaur.dao;

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

import com.kennosaur.pojo.Users;

/**
 * 参数一T:当前需要映射的实体
 * 参数二ID:当前映射的实体中的OID的类型
 * @author Administrator
 *
 */
public interface UsersRepository extends JpaRepository<Users, Integer> {

}

2.测试代码

	/**
	 * JapRepository   排序测试
	 */
	@Test
	public void testJpaRepositorySort() {
		//Order 定义排序规则
		Order order = new Order(Direction.DESC,"id");
		//Sort对象封装了排序规则
//		Sort sort = new Sort(order);
		List<Users> list = this.usersRepository.findAll(Sort.by(order));
		for (Users users : list) {
			System.out.println(users);
		}
	}

 

八.JPASpecificationExecutor接口----是单独存在,完全独立的(与上文中的四个接口不存在继承关系)

该接口主要提供了多条件查询的支持,并且可以在查询中添加分页和排序.通常与JpaRepository共同作用

1.编写接口

package com.kennosaur.dao;

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

import com.kennosaur.pojo.Users;
/**
 * 
 *JpaSpecificationExecutor
 *
 */
public interface UsersRepositorySpecification extends JpaRepository<Users, Integer>, JpaSpecificationExecutor<Users> {

}

2.测试代码

/**
	 * JpaSpecificationExecutor   单条件测试
	 */
	@Test
	public void testJpaSpecificationExecutor1() {
		
		/**
		 * Specification<Users>:用于封装查询条件
		 */
		Specification<Users> spec = new Specification<Users>() {
			
			//Predicate:封装了 单个的查询条件
			/**
			 * Root<Users> root:查询对象的属性的封装。
			 * CriteriaQuery<?> query：封装了我们要执行的查询中的各个部分的信息，select  from order by
			 * CriteriaBuilder cb:查询条件的构造器。定义不同的查询条件
			 */
			@Override
			public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
				// where name = '张三三'
				/**
				 * 参数一：查询的条件属性
				 * 参数二：条件的值
				 */
				Predicate pre = cb.equal(root.get("name"), "张三三");
				return pre;
			}
		};
		List<Users> list = this.usersRepositorySpecification.findAll(spec);
		for (Users users : list) {
			System.out.println(users);
		}
	}
	
	/**
	 * JpaSpecificationExecutor   多条件测试
	 */
	@Test
	public void testJpaSpecificationExecutor2() {
		
		/**
		 * Specification<Users>:用于封装查询条件
		 */
		Specification<Users> spec = new Specification<Users>() {
			
			//Predicate:封装了 单个的查询条件
			/**
			 * Root<Users> root:查询对象的属性的封装。
			 * CriteriaQuery<?> query：封装了我们要执行的查询中的各个部分的信息，select  from order by
			 * CriteriaBuilder cb:查询条件的构造器。定义不同的查询条件
			 */
			@Override
			public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
				// where name = '张三三' and age = 20				
			    List<Predicate> list = new ArrayList<>();
			    list.add(cb.equal(root.get("name"),"张三三"));
			    list.add(cb.equal(root.get("age"),20)); Predicate[] arr = new
			    Predicate[list.size()];				
				return cb.and(list.toArray(arr));
			}
		};
		List<Users> list = this.usersRepositorySpecification.findAll(spec);
		for (Users users : list) {
			System.out.println(users);
		}
	}

3.多条件查询测试第二种写法

/**
	 * JpaSpecificationExecutor   多条件测试第二种写法
	 */
	@Test
	public void testJpaSpecificationExecutor3() {
		
		/**
		 * Specification<Users>:用于封装查询条件
		 */
		Specification<Users> spec = new Specification<Users>() {
			
			//Predicate:封装了 单个的查询条件
			/**
			 * Root<Users> root:查询对象的属性的封装。
			 * CriteriaQuery<?> query：封装了我们要执行的查询中的各个部分的信息，select  from order by
			 * CriteriaBuilder cb:查询条件的构造器。定义不同的查询条件
			 */
			@Override
			public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
				// where name = '张三三' and age = 20
				/*List<Predicate> list = new ArrayList<>();
				list.add(cb.equal(root.get("name"),"张三三"));
				list.add(cb.equal(root.get("age"),20));
				Predicate[] arr = new Predicate[list.size()];*/
				//(name = '张三' and age = 20) or id = 2
				return cb.or(cb.and(cb.equal(root.get("name"),"张三三"),cb.equal(root.get("age"),20)),cb.equal(root.get("id"), 2));
			}
		};
		
		Sort sort = Sort.by(new Order(Direction.DESC,"id"));
		List<Users> list = this.usersRepositorySpecification.findAll(spec,sort);
		for (Users users : list) {
			System.out.println(users);
		}
	}

 

Miracle_Gaaral
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
<artifactId>spring-boot-starter-data-jpa</artifactId>
BLOG域名:programb.blog.csdn.net
05-07 751
服务编排 主要的作用是减少项目中的相互依赖。比如现在有项目a调用项目b，项目b调用项目c…一直到h，是一个调用链，那么项目上线的时候需要先更新最底层的h再更新g…更新c更新b最后是更新项目a。这只是这一个调用链，在复杂的业务中有非常多的调用，如果要记住每一个调用链对开发运维人员来说就是灾难。 有这样一个好办法可以尽量的减少项目的相互依赖，就是服务编排，一个核心的业务处理项目，负责和各个微服务打交道...
Spring Boot (一)：spring-boot-starter-data-jpa 解析
热门推荐
Lee_Ho_的博客
07-12 2万+
一：引言    对于传统关系型数据库，Spring Boot使用JPA（Java Persistence API）资源库来实现对数据库的操作，简单来说，JPA就是为POJO（Plain Ordinary Java Object）提供持久化的标准规范，即将Java普通对象通过对象关系映射（Object Relational Mapping，ORM）持久化到数据库中。二：使用方式2.1：JPA配置  ...
spring-boot与spring-data-JPA的简单整合
weixin_30896511的博客
06-05 50
如何在boot中轻松使用JPA <!--首先引入JPA依赖--><dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </depend...
＜artifactId＞spring-boot-starter-data-jpa＜/artifactId＞
tongxin_tongmeng的博客
01-07 186
＜artifactId＞spring-boot-starter-data-jpa＜/artifactId＞
spring-boot整合spring-data-jpa
cnfly8
04-25 149
依赖 <!--spring data jpa--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <!--mysql--> <dependency> <groupId>mysql
SpringBoot整合spring-data-jpa的方法
08-19
主要介绍了SpringBoot整合spring-data-jpa的方法，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
springboot-spring-data-jpa.zip
02-04
springboot整合spring data jpa进行增删改查
springboot-spring-data-jpa项目练习
08-14
springboot-spring-data-jpa项目练习，整合了增删改查springboot-spring-data-jpa项目练习，整合了增删改查
springboot-集成达梦数据库-源代码
03-02
jpa-hibernate-dm: 数据库为{国产达梦数据库},持久层技术为jpa-hibernate mybatis-dm: 数据库为{国产达梦数据库},持久层技术为mybatis mybatis-plus-dm: 数据库为{国产达梦数据库},持久层技术为mybatis-plus 补充...
SpringBoot使用Spring-data-jpa简化数据访问层
05-09
对数据库的操作无非就“增删改查”。就最为普遍的单表操作而言，除了表和字段不同外，语句都是类似的，开发人员需要写...Spring-data-jpa的出现正可以让这样一个已经很“薄”的数据访问层变成只是一层接口的编写方式。
springboot第一章04----spring-boot-starter-data-jpa
fjz_lihuapiaoxiang的博客
11-01 323
第一步：添加依赖pom.xml <!-- 添加Mysql数据库驱动依赖 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency>...
spring-boot-starter-data-jpa 的使用。
青冬的博客
04-15 1万+
Springboot版本为2.1.8.RELEASE 本文包含内容，怎么使用SpringBoot-JPA进行数据查询。不定期更新。 依赖 <!--springboot 整合的数据连接--> <dependency> <groupId>org.springframework.boot</g...
springboot整合springdata jpa全能书
hotpots--火锅技术栈
02-23 760
springboot整合springdatajpa
Spring Boot系列 —（二）SpringBoot 项目使用 JPA
YidaHu的博客
02-12 499
SpringBoot 项目使用 JPA
springboot集成springDataJpa详细过程
itboy
06-20 505
一、导入jar包 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.2.RELEASE</version&...
SpringBoot学习笔记九：Spring Data Jpa的使用
cxu123321的博客
10-09 2852
SpringBoot学习笔记九：Spring Data Jpa的使用 fulgens关注 72018.08.27 22:17:29字数 3,562阅读 110,836 Spring Data Jpa 简介 JPA JPA(Java Persistence API)意即Java持久化API，是Sun官方在JDK5.0后提出的Java持久化规范（JSR 338，这些接口所在包为javax.persistence，详细内容可参考https://github.com/javaee/jpa-spec） JP
spring boot 中使用 jpa(详细操作)
qq_45381772的博客
11-01 6907
1.maven依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <!
Spring Boot Jpa 的使用（转载）
黑米粥的锅
11-06 396
Spring Boot Jpa 介绍 首先了解 Jpa 是什么？ Jpa (Java Persistence API) 是 Sun 官方提出的 Java 持久化规范。它为 Java 开发人员提供了一种对象/关联映射工具来管理 Java 应用中的关系数据。它的出现主要是为了简化现有的持久化开发工作和整合 ORM 技术，结束现在 Hibernate，TopLink，JDO 等 ORM 框架各自为营的局面。 值得注意的是，Jpa是在充分吸收了现有 Hibernate，TopLink，JDO 等 ORM 框架
SpringDataJPA教程 三种配置方式
qq_42058998的博客
05-31 1万+
SpringDataJPA教程 三种配置方式
springboot整合Spring Data JPA
最新发布
07-14
要在Spring Boot中整合Spring Data JPA，可以按照以下步骤进行操作： 1. 添加依赖：在项目的pom.xml文件中添加Spring Data JPA的依赖。可以使用以下依赖项： ```xml <groupId>org.springframework.boot ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值