SpringDataJpa基本使用

已于 2023-12-21 09:29:18 修改
阅读量222 收藏
点赞数
分类专栏： SpringDataJpa 文章标签： spring boot
于 2020-08-30 17:17:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/T_Ghost/article/details/108272840
版权

SpringDataJpa简单使用步骤

1、添加相关依赖

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.my.data.test</groupId>
  <artifactId>SpringDataJpaTest</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  
   <properties>
        <spring.version>5.1.2.RELEASE</spring.version>
        <hibernate.version>5.4.1.Final</hibernate.version>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
        <c3p0.version>0.9.5.2</c3p0.version>
        <mysql.version>8.0.15</mysql.version>
    </properties>

    <dependencies>
        <!-- junit单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope> 
        </dependency>

        <!-- spring beg -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- spring对orm框架的支持包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- spring end -->

        <!-- hibernate beg -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.2.1.Final</version>
        </dependency>
        <!-- hibernate end -->

        <!-- c3p0 beg -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>${c3p0.version}</version>
        </dependency>
        <!-- c3p0 end -->

        <!-- log end -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- log end -->


        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>

        <!-- spring data jpa 的坐标-->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.9.0.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- el beg 使用spring data jpa 必须引入 -->
        <dependency>
            <groupId>javax.el</groupId>
            <artifactId>javax.el-api</artifactId>
            <version>2.2.4</version>
        </dependency>

        <dependency>
            <groupId>org.glassfish.web</groupId>
            <artifactId>javax.el</artifactId>
            <version>2.2.4</version>
        </dependency>
        <!-- el end -->
    </dependencies>
</project>

2、整合SpringData与Spring及其配置文件–applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
		http://www.springframework.org/schema/data/jpa 
		http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
		
		<!-- 配置数据库连接池 -->
		<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
			<property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
			<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/my_test?serverTimezone=GMT%2B8"/>
			<property name="user" value="root" />
			<property name="password" value="666666" />
		</bean>
		
		<!-- 配置entityManagerFactory -->
		<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
			<property name="dataSource" ref="dataSource"></property>
			<property name="packagesToScan" value="com.my.data.test.entity" />
			<property name="persistenceProvider">
				<bean class="org.hibernate.jpa.HibernatePersistenceProvider" />
			</property>
			<property name="jpaVendorAdapter">
				<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
					<!-- 根据entity自动生成表 -->
					<property name="generateDdl" value="false"/>
					<property name="database" value="MYSQL"/>
					<property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
					<property name="showSql" value="true" />
				</bean>
			</property>
			<property name="jpaDialect">
				<bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"></bean>
			</property>
		</bean>
		
		<!-- 事务管理器 -->
		<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
			<property name="entityManagerFactory" ref="entityManagerFactory" />
		</bean>
		
		<!-- 整合spring data jpa -->
		<jpa:repositories base-package="com.my.data.test.dao" 
			transaction-manager-ref="transactionManager"
			entity-manager-factory-ref="entityManagerFactory">
		</jpa:repositories>
		
		<!-- 扫描指定包下所有 -->
		<context:component-scan base-package="com.my.data.test"/>
</beans>

3、创建对应实体类，并添加相应的映射关系配置

package com.my.data.test.entity;

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 = "data_jpa_test")
public class DataJpaTest {
	
	@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;
	
	@Column(name = "des")
	private String des;

	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;
	}

	public String getDes() {
		return des;
	}

	public void setDes(String des) {
		this.des = des;
	}

	@Override
	public String toString() {
		return "DataJpaTest [id=" + id + ", name=" + name + ", age=" + age + ", address=" + address + ", des=" + des
				+ "]";
	}
}

4、创建相应的dao层接口，并继承所需接口

package com.my.data.test.dao;

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

import com.my.data.test.entity.DataJpaTest;

public interface SpringDataJpaDao extends JpaRepository<DataJpaTest, Integer>, JpaSpecificationExecutor<DataJpaTest> {
	
}

5、测试并加载applicationContext配置文件

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpringDataJpaTest {
	@Autowired
	private SpringDataJpaDao jpaDao;
	
	@Test
	public void test1() {
		DataJpaTest dataJpa = new DataJpaTest();
		dataJpa.setAddress("地址");
		dataJpa.setAge(11);
		dataJpa.setName("姓名");
		dataJpa.setDes("描述");
		jpaDao.save(dataJpa);
	}
}

6、使用JPQL的方式 — 自定义sql
dao配置自定义sql

public interface SpringDataJpaDao extends JpaRepository<DataJpaTest, Integer>, JpaSpecificationExecutor<DataJpaTest> {
	
	@Query(value = "from DataJpaTest d where d.id = :id")
	public DataJpaTest findById(@Param("id") Integer id);
	
	/*更新删除需添加如下注解*/
	@Transactional/*开启事务*/
	@Modifying/*将该操作标识为修改或删除操作,默认为只读*/
	@Query(value = "update DataJpatest d set d.name = :name where d.id = :id")
	public Integer updateById(@Param("id") Integer id,@Param("name") String name);
}

使用测试

@Test
	public void test1() {
		DataJpaTest dataJpa = jpaDao.findById(1);
		System.out.println(dataJpa.toString());
	}
	
	@Test
	public void test2() {
		int res = jpaDao.updateById(1, "gg");
		System.out.println(res);
	}

多表映射

1、Specifications动态查询
查询方法
在这里插入图片描述

查询方式

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpringDataJpaTest {
	@Autowired
	private SpringDataJpaDao jpaDao;
	
	@Test
	public void testSpecifications() {
		Specification<DataJpaTest> specification = new Specification<DataJpaTest>() {
			public Predicate toPredicate(Root<DataJpaTest> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
				//cb:构建查询，添加查询方式 
				//root:从实体DataInfo对象中按照dataSource属性进行查询
				return cb.like(root.get("name").as(String.class), "%g%");
			}
		};
		
		DataJpaTest jpaTest = jpaDao.findOne(specification);
		System.out.println(jpaTest.toString());
	}
}

2、JPA中一对多
主表

@Entity
@Table(name = "data_jpa_test")
//toString时添加，避免溢出
@Proxy(lazy = false)
public class DataJpaTest {
	
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name="test1_id")
	private Integer test1Id;
	
	
	@Column(name="name")
	private String name;
	
	@Column(name = "age")
	private Integer age;
	
	@Column(name = "address")
	private String address;
	
	@Column(name = "des")
	private String des;
	
	/**
	 * @OneToMany指向从表
	 * 一对多：@JoinColumn中name指向从表外键，referencedColumnName指向自己对应的主键
	 * 注意：referencedColumnName指向表中的column，不是实体类中的属性名
	 */
	@OneToMany(targetEntity = DataJpaTest2.class)
	@JoinColumn(name = "cid",referencedColumnName = "test1_id")
	private Set<DataJpaTest2> test2List = new HashSet<DataJpaTest2>();
	
	public Integer getTest1Id() {
		return test1Id;
	}

	public void setTest1Id(Integer test1Id) {
		this.test1Id = test1Id;
	}

	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;
	}

	public String getDes() {
		return des;
	}

	public void setDes(String des) {
		this.des = des;
	}
	
	public Set<DataJpaTest2> getTest2List() {
		return test2List;
	}

	public void setTest2List(Set<DataJpaTest2> test2List) {
		this.test2List = test2List;
	}

	@Override
	public String toString() {
		return "DataJpaTest [name=" + name + ", age=" + age + ", address=" + address + ", des=" + des
				+ "]";
	}
}

从表

@Entity
@Table(name = "data_jpa_test2")
//toString时添加，避免溢出
@Proxy(lazy = false)
public class DataJpaTest2 {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name="test2_id")
	private Integer test2Id;
	
	/**
	 * @ManyToOne指向主表
	 * 多对一：@JoinColumn中name指向自己对应主表的外键，refereencedColumnName指向主表外键
	 * 注意：referencedColumnName指向表中的column，不是实体类中的属性名
	 */
	@ManyToOne(targetEntity = DataJpaTest.class)
	@JoinColumn(name = "cid",referencedColumnName = "test1_id")
	private DataJpaTest dataJpaTest;
	
	/**
	 * 相应的外键必须设置为不能存储更新，只能随主表进行修改或增加
	 */
	@Column(name = "cid",insertable=false,updatable=false)
	private Integer cid;
	
	@Column(name="name")
	private String name;
	
	@Column(name = "age")
	private Integer age;
	
	@Column(name = "address")
	private String address;
	
	@Column(name = "des")
	private String des;

	

	public Integer getTest2Id() {
		return test2Id;
	}

	public void setTest2Id(Integer test2Id) {
		this.test2Id = test2Id;
	}

	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;
	}

	public String getDes() {
		return des;
	}

	public void setDes(String des) {
		this.des = des;
	}
	
	

	public DataJpaTest getDataJpaTest() {
		return dataJpaTest;
	}

	public void setDataJpaTest(DataJpaTest dataJpaTest) {
		this.dataJpaTest = dataJpaTest;
	}
	
	

	public Integer getCid() {
		return cid;
	}

	public void setCid(Integer cid) {
		this.cid = cid;
	}

	@Override
	public String toString() {
		return "DataJpaTest2 [name=" + name + ", age=" + age + ", address=" + address + ", des=" + des
				+ "]";
	}
}

测试方法

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpringDataJpaTest {
	@Autowired
	private SpringDataJpaDao jpaDao;
	
	@Autowired
	private SpringDataJpaDao2 jpaDao2;
	
	@Test
	public void oneToManyTest() {
		
		DataJpaTest2 test2 = new DataJpaTest2();
		test2.setAddress("地址2");
		test2.setName("姓名2");
		test2.setAge(12);
		test2.setDes("描述2");
		
		DataJpaTest test = new DataJpaTest();
		test.setAddress("地址1");
		test.setName("姓名1");
		test.setAge(11);
		test.setDes("描述");
		
		//主表中加入从表
		test.getTest2List().add(test2);
		
		
		//先存从表再存主表
		jpaDao2.save(test2);
		jpaDao.save(test);
	}
}

3、JPA中多对多
主表

@Entity
@Table(name = "data_jpa_test")
//toString时添加，避免溢出
@Proxy(lazy = false)
public class DataJpaTest {
	
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name="test1_id")
	private Integer test1Id;
	
	
	@Column(name="name")
	private String name;
	
	@Column(name = "age")
	private Integer age;
	
	@Column(name = "address")
	private String address;
	
	@Column(name = "des")
	private String des;
	
	/**CascadeType:
	 * 1、MERGE：主表添加数据，并新增从表数据，会在从表中搜索，若不存在则添加
	 * 2、REMOVE：删除主表数据，会删除对应主表数据
	 * 3、PERSIST：新增主表数据并加入相应从表数据时，若从表数据不存在，则报错，反之添加成功
	 * 4、REFRESH：级联刷新，获取主表对象里也同时也重新获取最新的从表的对象
	 * 5、ALL：所有
	 * @JoinTable：
	 * 	name:中间表表名
	 *  joinColumns:当前表在中间表中的字段
	 *  inverseJoinColumns:关联表在中间表中的字段
	 */
	@ManyToMany(targetEntity = DataJpaTest2.class,cascade = CascadeType.PERSIST)
	@JoinTable(name = "test_t1t2",
		joinColumns = {@JoinColumn(name = "t1_id",referencedColumnName = "test1_id")},
		inverseJoinColumns = {@JoinColumn(name = "t2_id",referencedColumnName = "test2_id")})
	private List<DataJpaTest2> test2List = new ArrayList<DataJpaTest2>();
	
	public Integer getTest1Id() {
		return test1Id;
	}

	public void setTest1Id(Integer test1Id) {
		this.test1Id = test1Id;
	}

	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;
	}

	public String getDes() {
		return des;
	}

	public void setDes(String des) {
		this.des = des;
	}
	
	

	public List<DataJpaTest2> getTest2List() {
		return test2List;
	}

	public void setTest2List(List<DataJpaTest2> test2List) {
		this.test2List = test2List;
	}

	@Override
	public String toString() {
		return "DataJpaTest [name=" + name + ", age=" + age + ", address=" + address + ", des=" + des
				+ "]";
	}
}

从表

@Entity
@Table(name = "data_jpa_test2")
//toString时添加，避免溢出
@Proxy(lazy = false)
public class DataJpaTest2 {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name="test2_id")
	private Integer test2Id;
	
	/**
	 * mappedBy指向关联表中的属性名
	 */
	@ManyToMany(mappedBy = "test2List")
	private List<DataJpaTest> testList = new ArrayList<DataJpaTest>();
	
	/**
	 * 相应的外键必须设置为不能存储更新，只能随主表进行修改或增加
	 */
	@Column(name = "cid",insertable=false,updatable=false)
	private Integer cid;
	
	@Column(name="name")
	private String name;
	
	@Column(name = "age")
	private Integer age;
	
	@Column(name = "address")
	private String address;
	
	@Column(name = "des")
	private String des;

	

	public Integer getTest2Id() {
		return test2Id;
	}

	public void setTest2Id(Integer test2Id) {
		this.test2Id = test2Id;
	}

	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;
	}

	public String getDes() {
		return des;
	}

	public void setDes(String des) {
		this.des = des;
	}
	

	public Integer getCid() {
		return cid;
	}

	public void setCid(Integer cid) {
		this.cid = cid;
	}
	
	
	public List<DataJpaTest> getTestList() {
		return testList;
	}

	public void setTestList(List<DataJpaTest> testList) {
		this.testList = testList;
	}

	@Override
	public String toString() {
		return "DataJpaTest2 [name=" + name + ", age=" + age + ", address=" + address + ", des=" + des
				+ "]";
	}
}

测试方法

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpringDataJpaTest {
	@Autowired
	private SpringDataJpaDao jpaDao;
	
	@Autowired
	private SpringDataJpaDao2 jpaDao2;
	
	@Test
	@Transactional
	@Rollback(false)
	public void oneToManyTest() {
		
		DataJpaTest2 test2 = new DataJpaTest2();
		test2.setAddress("地址2"); 
		test2.setName("姓名2");
		test2.setAge(12);
		test2.setDes("描述2");
		
		DataJpaTest test = new DataJpaTest();
		test.setAddress("地址1");
		test.setName("姓名1");
		test.setAge(11);
		test.setDes("描述");
		
		//主表中加入从表
		test.getTest2List().add(test2);
		
		//直接存储
		jpaDao.save(test);
	}
}

4、多表查询
1、查询所有
2、fetch的用法

T_Ghost
关注
专栏目录
springdata教程
liu289747235的专栏
01-06 3082
github:https://github.com/leelun/springdata-example Spring Data Spring 的一个子项目。用于简化数据库访问，支持NoSQL 和 关系数据存储。其主要目标是使数据库的访问变得方便快捷。 SpringData 项目所支持 NoSQL 存储： MongoDB （文档数据库） Neo4j（图形数据库） Redis（键/值存储...
十三、Spring Data JPA 入门 - 测试项目创建
weixin_45611944的博客
01-28 1340
十三、Spring Data JPA 入门
手把手教你如何玩转Spring Data
Cs_hnu_scw的博客
06-23 9790
前导博文：https://blog.csdn.net/cs_hnu_scw/article/details/80720206情景引入：小白：快起床快起床，起来学习起来学习~~~~我：你能不能让我安心点，今天周末，咱们不学习，放假放假！（适当的休息还是很有用的哦，劳逸结合~！）小白：不行，昨天不是才休息的吗？我遇到问题遇到问题了~~我：快说，你又有什么问题？你是十万个为什么吗？小白：我学习完你上次对...
SpringDataJpa框架使用【超详细！】
HydeRobin的博客
02-15 2396
jpa 的全称是 Java Persistence API , 中文的字面意思就是 java 的持久层 API , jpa 就是定义了一系列标准，让实体类和数据库中的表建立一个对应的关系，当我们在使用 java 操作实体类的时候能达到操作数据库中表的效果(不用写sql ,就可以达到效果），jpa 的实现思想即是 ORM （Object Relation Mapping），对象关系映射，用于在关系型数据库和业务实体对象之间作一个映射。
Spring Data Jpa 使用方法及注意事项
一个刚刚开始学习java的小白
08-10 179
SpringBoot Data Jpa使用
Spring Data JPA基本使用及部分原理(核心概念)
01-20
**Spring Data JPA基本使用及部分原理** Spring Data JPA是Spring框架的一部分，它为Java开发者提供了方便的数据访问层抽象，使得与各种持久化技术（如JPA、Hibernate）的交互变得简单。本文将深入探讨Spring Data ...
spring注解+spring data jpa文档+JPA文档.rar
04-05
"spring data jpa官方文档中文翻译"则提供了Spring Data JPA的详细指南，包括其设计原理、基本概念、使用方法和最佳实践。"JPA2.0官方文档"则深入讲解了JPA规范的各个方面，包括实体管理、查询、事务和并发控制等。 ...
Spring Data JPA 笔记
04-16
至于压缩包中的“helloworld”文件，可能是一个简单的示例项目，通常会包含一个基础的Spring Data JPA配置，一个实体类，以及对应的Repository接口，用于展示Spring Data JPA的基本用法。通过查看这个例子，你可以更...
Spring Data JPA中文文档[1.4.3].zip
09-26
10. **审计功能**：Spring Data JPA可以通过`@Audited`注解提供基本的审计跟踪，记录实体何时以及由谁进行了修改。 11. **集成测试**：学习如何使用`@DataJpaTest`和`@Transactional`注解进行数据库相关的单元测试...
Spring Data JPA详细使用教程
子月生的博客
09-03 1909
Spring Data JPA详细使用教程 简介 Spring Data提供了针对数据库（包括SQL和NOSQL）的整合方案，对Hibernate JPA、Jedis等工具的api进行高级的封装，为我们提供简单方便地操作接口。 Spring Data JPA 是Spring Data项目下的一个模块。整合了基于JPA的持久层框架（默认Hibernate JPA），并对API进行了封装，让我们可以更...
spring Data Jpa 基本使用
z616026782的专栏
10-15 860
spring Data Jpa 基本使用 Spring Data JPA 基本使用 大体内容 一、 创建SpringDataJPA项目 1 导入依赖 2 配置数据源信息 3 编写Dao 4 user 5 编写测试代码 二、 Spring Data JPA 的接口继承结构 三、 Spring Data JPA 的运行原理 四、 Repository 接口 1 方法名称命名规则查询 2 基于@Query 注解的查询 2.1通过 JPQL 语句查询 2.2通过 SQL 语句查询
Spring Data JPA 分页接口的使用方法——PageHelper分页查询方法
AI天才研究院
07-28 2336
2017年，全国IT企业纷纷转向云计算、容器技术，并掀起了一股“容器潮流”。容器化、微服务架构以及分布式系统架构模式越来越流行，对于大型复杂系统而言，数据库分页查询在性能上就成为一个重要的优化点。基于此，当下互联网中最流行的开源框架之一， MyBatis 和 SpringData JPA 等都提供了分页查询功能。PageHelper 是 MyBatis 中的一个分页插件，作用是在不用改变 SQL 查询的前提下，实现自定义物理分页，非常方便开发者使用。
SpringData JPA学习使用笔记
EricItman的博客
10-31 283
Spring Data JPA（Java Persistence API）是Spring生态系统中的一个子项目，用于简化JPA（Java Persistence API）的使用，使数据访问层的开发更加容易和高效。它提供了一组工具和库，以简化与数据库进行数据访问和持久化的操作。: Spring Data JPA引入了Repository接口，允许你定义数据库操作的自定义方法，而无需手动编写SQL查询语句。只需继承Repository接口并使用方法命名约定，Spring Data JPA会自动为你生成查询方法。
Spring Data JPA系列2：SpringBoot集成JPA详细教程，快速在项目中熟练使用JPA
是Vzn呀
06-23 1025
作为SpringData JPA系列内容的第二篇，此处以SpringBoot项目为基准，讲一下集成SpringData JPA的相关要点，带你快速的上手SpringData JPA，并用实例演示常见的DB操作场景，让你分分钟轻松玩转JPA。
SpringData高级应用之SpringData JPA全面使用（增删改查操作完整代码）
熊凯瑞的博客
07-20 1260
SpringDataJPA是SpringData家族的一个成员，是SpringData对JPA封装之后的产物，目的在于简化基于JPA的数据访问技术。使用SpringDataJPA技术之后，开发者只需要声明Dao层的接口，不必再写实现类或其它代码，剩下的一切交给SpringDataJPA来搞定。根据方法的名字，创建查询。SpringDataJPA在程序执行的时候会根据方法名称进行解析，并自动生成查询语句进行查询。也就是说要使用实体类名代替表名，使用属性名代替字段名[面向对象查询]...
Spring Data JPA进行数据库操作
编程小弟的博客
05-09 418
使用Spring Data JPA进行数据库操作涉及几个关键步骤，包括配置、定义实体类、创建仓库接口以及执行具体的数据库操作
使用数据库作为接口还怕难以测试？@DataJpaTest 稳稳接住
最新发布
2301_78976656的博客
07-14 914
最后，就可以对 Repository 进行局部测试了，这样做的好处是可以独立测试 Repository，不需要连接外部数据库，也不需要加载所有 Bean。testModifierUser 添加了 @BeforeEach，用于执行数据访问测试前构造访问用户信息，测试不同用户访问数据，就可以调用 changeModifyUser 修改。用户配置在架构设计上是与数据访问是分离的，测试上也是如此，不应在数据访问层完成，隔离审计用户获取的方式，可以使用。这才是 ORM 该有的测试，JPA Test。
jpa使用自定义sql 一对多 @Query
weixin_49723367的博客
08-18 553
这是我最近写测试的时候用到的方法，因这种方法，不是特别可取。数据量很多的时候，此批量查询时是最快的。这时查询出来的值就是多条，用代码分组后组装数据，返回数据。table1 与table 2 是一对多的关系。
SpringData系列二：基本使用
苍穹尘的博客
05-03 471
1、引入依赖 <dependencies> <!-- hibernate依赖 --> <dependency> <groupId>org.hibernate.common</groupId> <artifactId>hibernate-co...
Spring Data JPA深度解析与实战指南
"springdatajpa使用详解(推荐)" Spring Data JPA 是 Spring 框架的一个模块，旨在简化数据访问并提高效率，特别是在使用 Java Persistence API (JPA) 的情况下。它通过提供自动化的仓储接口实现，使得开发者可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值