SpringDataJpa--jpa基础

T_Ghost

已于 2023-12-21 09:30:24 修改

阅读量170

点赞数

分类专栏： SpringDataJpa 文章标签： spring boot spring

于 2020-08-27 17:36:16 首次发布

本文链接：https://blog.csdn.net/T_Ghost/article/details/108255118

版权

SpringDataJpa 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

JPA基础

1、ORM概述

ORM（Object-Relational Mapping）: 表示对象关系映射。在面向对象的软件开发中，通过ORM，就可以把对象映射到关系型数据库中。只要有一套程序能够做到建立对象与数据库的关联，操作对象就可以直接操作数据库数据，就可以说这套程序实现了ORM对象关系映射
优势： 当实现一个应用程序时（不使用O/R Mapping），我们可能会写特别多数据访问层的代码，从数据库保存数据、修改数据、删除数据，而这些代码都是重复的。而使用ORM则会大大减少重复性代码。对象关系映射（Object Relational Mapping，简称ORM），主要实现程序对象到关系数据库数据的映射。

2、Hibernate概述

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。

3、JPA概述—面向对象操作数据

JPA的全称是Java Persistence API，即Java 持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成。
JPA通过JDK 5.0注解描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。

4、具体实现

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.spring.data.test</groupId>
  <artifactId>SpringDataJpaTest</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  
    <properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.hibernate.version>5.0.7.Final</project.hibernate.version>
	</properties>
	
	<dependencies>
		<!-- junit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>

		<!-- hibernate对jpa的支持包 -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-entitymanager</artifactId>
			<version>${project.hibernate.version}</version>
		</dependency>

		<!-- c3p0 -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-c3p0</artifactId>
			<version>${project.hibernate.version}</version>
		</dependency>

		<!-- log日志 -->
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.17</version>
		</dependency>

		<!-- Mysql and MariaDB -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.6</version>
		</dependency>
	</dependencies>
</project>

2、建立配置文件
文件目录
在这里插入图片描述

文件详情–注意，url的形式不同于application.yml中的配置，需用分号隔离

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence  
    http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
	version="2.0">
	<!-- 配置持久化单元
	name：持久化单元名称 
		transaction-type：事务类型
		 	RESOURCE_LOCAL：本地事务管理 
		 	JTA：分布式事务管理 -->
	<persistence-unit name="myHibernate" transaction-type="RESOURCE_LOCAL">
		<!-- 配置jpa服务提供商 -->
		<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
		<properties>
			<!-- 数据库驱动 -->
			<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
			<!-- 数据库地址 -->
			<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/my_test?useUnicode=true&amp;characterEncoding=utf8"/>
			<!-- 数据库用户名 -->
			<property name="javax.persistence.jdbc.user" value="root"/>
			<!-- 数据库密码 -->
			<property name="javax.persistence.jdbc.password" value="666666"/>
			
			<!--jpa提供者的可选配置：我们的JPA规范的提供者为hibernate，所以jpa的核心配置中兼容hibernate的配置 -->
			
			<!-- 设置在控制台打印操作的sql语句 -->
			<property name="hibernate.show_sql" value="true"/>
			
			<!-- create：表示启动的时候先drop，再create
				create-drop: 也表示创建，只不过再系统关闭前执行一下drop
				update: 这个操作启动的时候会去检查schema是否一致，如果不一致会做scheme更新，没有表时候会创建表
				validate: 启动时验证现有schema与你配置的hibernate是否一致，如果不一致就抛出异常，并不做更新 -->
			<property name="hibernate.hbm2ddl.auto" value="update"/>
			
			<!-- 格式化控制台打印的sql语句 -->
			<property name="hibernate.format_sql" value="true" />
		</properties>
	</persistence-unit>
</persistence>

3、创建实体并添加相应的注解

@Entity //声明实体类
@Table(name = "jpa_test") //建立实体类和表的映射关系
class JpaTest{
	
	@Id //声明当前私有属性为主键
	@GeneratedValue(strategy = GenerationType.IDENTITY)  //设置主键生成策略 IEDNTITY时，主键自增
	@Column(name="id")  //指定和表中id字段的映射关系
	private Integer id;
	
	@Column(name = "name")
	private String name;
	
	@Column(name = "age")
	private Integer age;
	
	@Column(name = "address")
	private String address;
	
	@Column(name = "descripe")
	private String descripe;

	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 getDescripe() {
		return descripe;
	}

	public void setDescripe(String descripe) {
		this.descripe = descripe;
	}
	
}

4、手动加载相应的配置文件

public class MyJpaTest {
	/*
	 * 创建实体管理类工厂，借助Persistence的静态方法获取 
	 * 其中传递的参数为持久化单元名称，需要jpa配置文件中指定
	 * */
	public static void main(String[] args) {
		EntityManagerFactory factory = Persistence.createEntityManagerFactory("myHibernate");
		EntityManager manager = factory.createEntityManager();
		EntityTransaction transaction = manager.getTransaction();
		//开启事务
		transaction.begin();
		JpaTest jpaTest = new JpaTest();
		//jpaTest.setId(1);
		jpaTest.setAddress("aa");
		jpaTest.setAge(11);
		jpaTest.setDescripe("asdf");
		jpaTest.setName("bb");
		//保存操作
		manager.persist(jpaTest);
		//提交事务
		transaction.commit();
		//释放资源
		manager.close();
		factory.close();
	}
}

5、常用注解说明

@Entity
作用：指定当前类是实体类。
@Table
作用：指定实体类和表之间的对应关系。
属性：
name：指定数据库表的名称
@Id
作用：指定当前字段是主键。
@GeneratedValue
作用：指定主键的生成方式。。
属性：
strategy ：指定主键生成策略。
@Column
作用：指定实体类属性和数据库表之间的对应关系
属性：
name：指定数据库表的列名称。
unique：是否唯一
nullable：是否可以为空
inserttable：是否可以插入
updateable：是否可以更新
columnDefinition: 定义建表时创建此列的DDL
secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字搭建开发环境[重点

6、JPA中的主键生成策略

通过annotation（注解）来映射hibernate实体的,基于annotation的hibernate主键标识为@Id, 其生成规则由@GeneratedValue设定的.这里的@id和@GeneratedValue都是JPA的标准用法。
1、strategy四种取值（指定persistence.xml中的hibernate.hbm2ddl.auto值为create来测试）
a、IDENTITY ---- 主键由数据库自动生成自动增长数据库支持—mysql
在这里插入图片描述

b、SEQUENCE ---- 根据底层数据库的序列来生成主键，条件是数据库支持
序列适用于oracle
c、TABLE ---- 使用一个特定的数据库表格来保存主键
@TableGenerator属性的含义
在这里插入图片描述
表结构

注解方式

	@Id //声明当前私有属性为主键
	@TableGenerator(
			name="id_customer",
			allocationSize=3,
			table="generator_tb",
			pkColumnName="PK_COLUMN",
			pkColumnValue="id_customer",
			valueColumnName="PK_VALUE")
	@GeneratedValue(strategy = GenerationType.TABLE,generator = "id_customer")
	@Column(name="id")  //指定和表中id字段的映射关系
	private Integer id;

d、AUTO ---- 主键由程序控制自动选择最适合的策略
2、generator
默认值：JPA 持续性提供程序为它选择的主键生成器分配一个名称。
如果该名称难于处理、是一个保留字、与事先存在的数据模型不兼容或作为数据库中的主键生成器名称无效，则将 generator 设置为要使用的 String 生成器名称。

7、JPA的Api对象

1、Persistence
Persistence对象主要作用是用于获取EntityManagerFactory对象的。通过调用该类的createEntityManagerFactory静态方法，根据配置文件中持久化单元名称创建EntityManagerFactory。
2、EntityManagerFactory
用于创建Entitymanager实例，并使其变为持久化对象
3、EntityManager
在 JPA 规范中, EntityManager是完成持久化操作的核心对象。实体类作为普通 java对象，只有在调用EntityManagerFactory将其持久化后才会变成持久化对象。EntityManager对象在一组实体类与底层数据源之间进行 O/R 映射的管理。它可以用来管理和更新 Entity Bean, 根椐主键查找 Entity Bean, 还可以通过JPQL语句查询实体。
方法说明：
getTransaction : 获取事务对象
persist ：保存操作
merge ：更新操作
remove ：删除操作
find/getReference ：根据id查询
4、EntityTransaction
事务操作核心对象

JPA基本使用

工具类

/**
 * 工具类
 * @author l
 *
 */
final class JPAUtil {
	private static EntityManagerFactory em;
	static {
		em = Persistence.createEntityManagerFactory("myHibernate");
	}
	
	public static EntityManager getEntityManager() {
		return em.createEntityManager();
	}
}

1、crud

1、查询

public static void main(String[] args) {
		EntityManager manager = JPAUtil.getEntityManager();
		EntityTransaction transaction = manager.getTransaction();
		//开启事务
		transaction.begin();
		/*查询*/
		JpaTest jpaTest = manager.find(JpaTest.class, 1);
		System.out.println(jpaTest.toString());
		//释放资源
		manager.close();
	}

2、保存

public static void main(String[] args) {
		EntityManager manager = JPAUtil.getEntityManager();
		EntityTransaction transaction = manager.getTransaction();
		//开启事务
		transaction.begin();
		JpaTest jpaTest = new JpaTest();
		//jpaTest.setId(1);
		jpaTest.setAddress("aa");
		jpaTest.setAge(11);
		jpaTest.setDescripe("asdf");
		jpaTest.setName("bb");
		//保存操作
		manager.persist(jpaTest);
		//提交事务
		transaction.commit();
		//释放资源
		manager.close();
	}

3、修改

EntityManager manager = JPAUtil.getEntityManager();
		EntityTransaction transaction = manager.getTransaction();
		//开启事务
		transaction.begin();
		/*查询出对应的数据转为对象再进行修改*/
		//JpaTest jpaTest = manager.find(JpaTest.class, 5);
		JpaTest jpaTest = new JpaTest();
		jpaTest.setId(5);
		jpaTest.setAddress("abcdef123");
		jpaTest.setAge(15);
		jpaTest.setDescripe("11aaaa111111");
		//修改操作
		manager.merge(jpaTest);
		//提交事务
		transaction.commit();
		//释放资源
		manager.close();

4、删除

	public static void main(String[] args) {
		EntityManager manager = JPAUtil.getEntityManager();
		EntityTransaction transaction = manager.getTransaction();
		//开启事务
		transaction.begin();
		/*查询出对应的数据转为对象再进行删除*/
		JpaTest jpaTest = manager.find(JpaTest.class, 5);
		//修改操作
		manager.remove(jpaTest);
		//提交事务
		transaction.commit();
		//释放资源
		manager.close();
	}

2、复杂查询

基于首次在EJB2.0中引入的EJB查询语言(EJB QL),Java持久化查询语言(JPQL)是一种可移植的查询语言，旨在以面向对象表达式语言的表达式，将SQL语法和简单查询语义绑定在一起·使用这种语言编写的查询是可移植的，可以被编译成所有主流数据库服务器上的SQL。
其特征与原生SQL语句类似，并且完全面向对象，通过类名和属性访问，而不是表名和表的属性。
1、查询全部

public static void main(String[] args) {
		EntityManager manager = JPAUtil.getEntityManager();
		EntityTransaction transaction = manager.getTransaction();
		//开启事务
		transaction.begin();
		/*查询所有*/
		Query query = manager.createQuery("from JpaTest");
		List<JpaTest> list = query.getResultList();
		list.forEach(item -> System.out.println(item.toString()));
		//释放资源
		manager.close();
	}

2、分页查询

public static void main(String[] args) {
		EntityManager manager = JPAUtil.getEntityManager();
		EntityTransaction transaction = manager.getTransaction();
		//开启事务
		transaction.begin();
		/*查询所有*/
		Query query = manager.createQuery("from JpaTest");
		//起始位置
		query.setFirstResult(0);
		//每页显示条数
		query.setMaxResults(1);
		List<JpaTest> list = query.getResultList();
		list.forEach(it -> System.out.println(it.toString()));
		//释放资源
		manager.close();
	}

3、条件查询

public static void main(String[] args) {
		EntityManager manager = JPAUtil.getEntityManager();
		EntityTransaction transaction = manager.getTransaction();
		//开启事务
		transaction.begin();
		/*查询所有*/
		Query query = manager.createQuery("from JpaTest where name like ?");
		query.setParameter(1, "%a%");
		List<JpaTest> list = query.getResultList();
		list.forEach(it -> System.out.println(it.toString()));
		//释放资源
		manager.close();
	}