jpa开发手册
jpa教程
jpa教程JPA(Java Persistence API) 是Java平台上的一个ORM(Object-Relational Mapping)标准,它允许开发人员将Java对象映射到关系数据库。
JPA提供了一种简单且一致的方式来执行常见的数据库操作,如插入、更新、删除和查询数据。
JPA的核心是实体类(Entity Class),它们是映射到数据库表的Java类。
通过使用JPA注解来注释实体类,开发人员可以指定实体类的属性与数据库表的列之间的映射关系。
这些注解包括@Entity 、@Table、@Column等。
开发人员还可以使用关系注解,如@OneToMany、@ManyToOne等来定义实体类之间的关系。
在使用JPA时,开发人员通常需要创建一个实体管理器(Entity Manager),它是JPA的核心接口之一。
通过实体管理器,可以执行各种数据库操作,如持久化(Persist)、合并(Merge)、删除(Remove)和查询(Query)等。
为了获取实体管理器,可以通过JPA的实体管理器工厂(Entity Manager Factory)来创建。
JPA支持各种查询操作。
可以使用Java Persistence Query Language(JPQL)编写查询语句,它类似于SQL。
JPQL支持基本的查询功能,如选择(Select)、过滤(Where)、排序(Order by)等。
此外,还可以使用JPA的Criteria API来编程式地构建查询。
Criteria API提供了一种类型安全的查询方式,利用编译时检查来避免运行时错误。
除了基本的CRUD操作,JPA还提供了一些高级特性。
例如,可以使用继承来实现对象间的多态关系,通过映射继承层次结构到数据库表。
还可以使用JPA的事务管理机制,确保数据的一致性和完整性。
另外,JPA还支持延迟加载(Lazy loading)和缓存(Caching),以提高应用程序的性能。
java jpa 用法
java jpa 用法Java JPA（Java Persistence API）是一种用于管理Java应用程序持久化数据的API。
它提供了一种标准化的方式来实现对象-关系映射（ORM），使开发人员可以通过简单的注解和接口来访问数据库。
在本文中，我们将探讨Java JPA的用法，包括实体类的创建、持久化操作、查询操作等方面。
首先，我们需要创建一个实体类，实体类对应数据库中的一张表。
在实体类中，我们需要使用JPA的注解来映射表的字段。
例如，@Entity注解用于标识一个类为实体类，@Id注解用于标识主键字段，@Column注解用于指定列的属性。
除此之外，还有许多其他的注解可以用来定义表的关系、约束等。
接下来，我们需要定义一个接口来管理实体类的持久化操作。
这个接口通常继承自JPA提供的CrudRepository接口，该接口包含了一些常用的CRUD操作方法，如save、findById、delete等。
我们可以直接使用这些方法来实现数据的增删改查操作，无需手动编写SQL语句。
在进行持久化操作时，我们需要使用JPA的EntityManager来管理实体对象的生命周期。
通过调用EntityManager的persist方法可以将实体对象持久化到数据库中，通过调用find方法可以根据主键查找实体对象，通过调用merge方法可以更新实体对象，通过调用remove方法可以删除实体对象。
除了基本的持久化操作外，我们还可以使用JPQL（Java Persistence Query Language）来进行更复杂的查询操作。
JPQL类似于SQL，但是查询的对象是实体对象而不是表。
我们可以在查询语句中使用实体类的属性来过滤和排序数据，也可以使用一些内置的函数来进行计算和聚合操作。
最后，我们需要配置一个实现JPA规范的持久化提供者，如Hibernate、EclipseLink等。
持久化提供者负责实现JPA规范定义的接口，将实体对象映射到数据库表中，并提供实现JPA的各种功能。
JPA从入门到精通
创建EntityManagerFactory(Hibernate中的SessionFactory); 创建EntityManager(实体管理器)(Hibernate中的Session); 创建实体类,使用annotation来描述实体类跟数据库表之间的一 一映射关系. 使用JPA API完成数据增加、删除、修改和查询操作
使用JPA实现增加、删除、修改和查询操作
EntityManagerFactory
实体管理器的工厂，类似于Hibernate 中的SessionFactory 通过持久化提供者Persistence Provider创建这个对象应用程 序管理 用来创建EntityManager实例 一个数据库创建一个EntityManagerFactory对象
JPA的使用步骤
JPA的使用步骤
JPA的使用步骤
主要内容
JPA概述 使用JPA的步骤 实体 JPA的API JPQL
三、实体
三、实体
三、实体
三、实体
三、实体—实体的定义
实体具备以下的条件： 必须使用 javax.persistence.Entity注解或者在 XML映射文 件中有对应的元素； 必须具有一个不带参的构造函数， 类不能声明为final， 方法和需要持久化的属性也不能声明为 final； 如果游离状的实体对象需要以值的方式进行传递，如通 Session bean的远程业务接口传递，则必须实现 Serializable接口； 需要持久化的属性，其访问修饰符不能是public，它们必须通 过实体类方法进行访问。
OpenJPA
OpenJPA 是 Apache 组织提供的开源项目
SpringDataJPA开发手册
SpringDataJPA开发手册作者：chszs，转载需注明。
博客主页：/chszs我发现网上几乎没有讲述spring Data JPA原理的文章，很多Guide一上来就是如何配置，接着就是几大段代码，没有一篇文章能把Spring Data JPA原理及构成说清楚的。
所以，我写了这个系列的文章。
用Java Persistence API库创建持久层是很繁琐的，也很耗时，而且需要大量的样板代码。
我们可以通过以下步骤消除一些样板代码：1）创建一个抽象的基类，它提供了对实体的CRUD操作。
2）创建继承此基类的具体操作类。
这种方法的问题是，我们仍然要编写创建数据库查询和调用它们的代码。
更糟糕的是，当我们要创建新的数据库查询时，我们还是要这么做一次。
这太浪费时间了。
如果我告诉你，我们可以在创建JPA持久层时无需编写任何样板代码，你信不？Spring Data JPA可以帮助我们做到这一点。
Spring Data JPA官网声称：实现应用程序的数据访问层一直是很繁琐的，总是要写很多的样板代码来执行简单的查询，比如分页、审计。
Spring Data JPA旨在改进数据访问层的实现，减少开发时间。
开发者在编写数据库接口时，包括自定义的查询方法，Spring Data JPA会自动提供其实现。
本文介绍了Spring Data JPA，下面让我们开始吧。
作者：chszs，转载需注明。
博客主页：/chszs一、什么是Spring Data JPASpring Data JPA不是一个JPA实现，它是一个框架或库，提供了JPA Provider之上的一个额外的抽象层。
如果我们决定使用Spring Data JPA，那么应用程序的后端部分至少会包含三层：1）Spring Data JPASpring Data JPA提供了JPA Provider的抽象层。
2）Spring Data CommonsSpring Data Commons提供了共享的基础构件。
JPA开发文档
1JPA批注参考版本：5/12/06作为Java企业版5(Java EE5)Enterprise Java Bean(EJB)3.0规范的组成部分，Java持续性API(JPA)显著简化了EJB持续性并提供了一个对象关系映射方法，该方法使您可以采用声明方式定义如何通过一种标准的可移植方式（在Java EE5应用服务器内部以及Java标准版(Java SE)5应用程序中的EJB容器外部均可使用）将Java对象映射到关系数据库表。
在JPA之前，Java EE应用程序将持续类表示为容器管理的实体bean。
使用JPA，您可以将任何普通的旧式Java对象(POJO)类指定为JPA实体：一个应使用JPA 持续性提供程序的服务将其非临时字段持久保存到关系数据库（在Java EE EJB容器的内部或在简单Java SE应用程序中的EJB容器的外部）的Java对象。
使用JPA时，可以使用批注配置实体的JPA行为。
批注是一种使用元数据修饰Java源代码的简单表达方法，它编译为相应的Java类文件，以便在运行时由JPA 持续性提供程序解释以管理JPA行为。
例如，要将Java类指定为JPA实体，请使用@Entity批注，如下所示：@Entitypublic class Employee implements Serializable{...}您可以有选择地使用批注来修饰实体类以覆盖默认值。
这称作按异常进行配置(configuration by exception)。
本参考广泛引用了JSR-220Enterprise JavaBean版本3.0Java持续性API规范，以按类别汇总批注信息（请参阅表1-1），并解释了何时以及如何使用这些批注来自定义JPA行为，以满足应用程序的需要。
有关详细信息，请参阅：∙批注索引∙完整的JPA批注Javadoc表1-1按类别划分的JPA批注类别说明批注实体默认情况下，JPA持续性提供程序假设Java 类是非持续类，并且仅当使用此批注对其进行修饰的情况下才可用于JPA服务。
JPA教程：使用Java持久性API（JPA）存储数据库对象的临时内存副本说明书
JAVA PERSISTENCEAPI (JPA)TutorialSimply Easy Learning2About the T utorialThis tutorial provides a basic understanding of how to store a copy of database objects into temporary memory using JAVA Persistence API (JPA).AudienceThis tutorial is designed for readers intend to do Java programing with Database connectivity, using Persistence API.PrerequisitesAwareness of Java programming with JDK 1.6 or later is a prerequisite to understand this tutorial. In addition, we assume the readers are acquainted with the concepts of JDBC in Java.Copyright & DisclaimerCopyright 2014 by Tutorials Point (I) Pvt. Ltd.All the content and graphics published in this e-book are the property of Tutorials Point (I) Pvt. Ltd. The user of this e-book is prohibited to reuse, retain, copy, distribute or republish any contents or a part of contents of this e-book in any manner without written consent of the publisher.We strive to update the contents of our website and tutorials as timely and as precisely as possible, however, the contents may contain inaccuracies or errors. Tutorials Point (I) Pvt. Ltd. provides no guarantee regarding the accuracy, timeliness or completeness of our website or its contents including this tutorial. If you discover any errors on our website or in this tutorial, please notify us at **************************.3T able of ContentsAbout the Tutorial (3)Audience (3)Prerequisites (3)Copyright & Disclaimer (3)Table of Contents (4)1.JPA – INTRODUCTION (7)Mismatch between Relational and Object Models (7)What is JPA? (7)Where to use JPA? (7)JPA History (8)JPA Providers (8)2.JPA – ARCHITECTURE (9)Class Level Architecture (9)JPA Class Relationships (10)3.JPA – ORM COMPONENTS (12)Object Relational Mapping (12)Advanced Features (12)ORM Architecture (12)Mapping.xml (14)Annotations (17)Java Bean Standard (19)Bean Conventions (19)44.JPA – INSTALLATION (21)Step 1 : Verify your Java Installation (21)Step 2 : Set your Java Environment (22)Step 3 : Installing JPA (22)Adding MySQL connector to the Project (27)5.JPA – ENTITY MANAGERS (29)Creating Entities (30)Persistence Operations (34)Create Employee (34)Update Employee (35)Deleting Employee (38)6.JPA – JPQL (40)Java Persistence Query language (40)Query Structure (40)Scalar and Aggregate Functions (41)Between, And, Like Keywords (43)Ordering (45)Named Queries (46)Eager and Lazy Fetching (50)7.JPA – ADVANCED MAPPINGS (51)Inheritance Strategies (51)Single Table strategy (51)Joined Table Strategy (58)5Table per Class Strategy (66)8.JPA – ENTITY RELATIONSHIPS (74)@ManyToOne Relation (74)@OneToMany Relation (81)@OneToOne Relation (89)@ManyToMany Relation (96)9.JPA – CRITERIA API (106)History of Criteria (106)Criteria Query Structure (106)Example of Criteria API (107)6JAVA PERSISTENCE API (JPA)7Any enterprise application performs database operations by storing and retrieving vast amounts of data. Despite all the available technologies for storage management, application developers normally struggle to perform database operations efficiently.Generally, Java developers use lots of code, or use the proprietary framework to interact with the database, whereas using JPA, the burden of interacting with the database reduces significantly. It forms a bridge between object models (Java program) and relational models (database program).Mismatch between Relational and Object ModelsRelational objects are represented in a tabular format, while object models are represented in an interconnected graph of object format. While storing and retrieving an object model from a relational database, some mismatch occurs due to the following reasons:∙ Granularity : Object model has more granularity than relational model.∙Subtypes : Subtypes (means inheritance) are not supported by all types of relational databases.∙Identity : Like object model, relational model does not expose identity while writing equality.∙Associations : Relational models cannot determine multiple relationships while looking into an object domain model.∙Data navigation : Data navigation between objects in an object network is different in both models.What is JP A?Java Persistence API is a collection of classes and methods to persistently store the vast amounts of data into a database which is provided by the Oracle Corporation.Where to use JP A?To reduce the burden of writing codes for relational object management, a programmer follows the ‘JPA Provider’ framework, which allows easy interaction with database instance. Here the required framework is taken over by JPA. 1.JAVA PERSISTENCE API (JPA)JP A HistoryEarlier versions of EJB, defined the persistence layer combined with the business logic layer using javax.ejb.EntityBean Interface.∙While introducing EJB 3.0, the persistence layer was separated and specified as JPA1.0 (Java Persistence API). The specifications of this API were released along with thespecifications of JAVA EE5 on May 11, 2006 using JSR 220.∙JPA 2.0 was released with the specifications of JAVA EE6 on December 10, 2009 as a part of Java Community Process JSR 317.∙JPA 2.1 was released with the specification of JAVA EE7 on April 22, 2013 using JSR 338.JP A ProvidersJPA is an open source API, therefore various enterprise vendors such as Oracle, Redhat, Eclipse, etc. provide new products by adding the JPA persistence flavor in them. Some of these products include:∙Hibernate∙Eclipselink∙Toplink∙Spring Data JPA8JAVA PERSISTENCE API (JPA)9Java Persistence API is a source to store business entities as relational entities. It shows how to define a Plain Oriented Java Object (POJO) as an entity and how to manage entities with relations.Class Level ArchitectureThe following image shows the class level architecture of JPA. It shows the core classes and the interfaces of JPA.The following table describes each of the units shown in the above architecture.2.JAVA PERSISTENCE API (JPA)The above classes and interfaces are used for storing entities into a database as a record. They help programmers by reducing their efforts to write codes for storing data into a database so that they can concentrate on more important activities such as writing codes for mapping the classes with database tables.JP A Class RelationshipsIn the above architecture, the relations between the classes and interfaces belong to the javax.persistence package. The following diagram shows the relationship between them.10JAVA PERSISTENCE API (JPA)∙The relationship between EntityManagerFactory and EntityManager is one-to-many. It is a factory class to EntityManager instances.∙The relationship between EntityManager and EntityTransaction is one-to-one. For each EntityManager operation, there is an EntityTransaction instance.∙The relationship between EntityManager and Query is one-to-many. A number of queries can execute using one EntityManager instance.∙The relationship between EntityManager and Entity is one-to-many. One EntityManager instance can manage multiple Entities.11JAVA PERSISTENCE API (JPA)12Most contemporary applications use relational database to store data. Recently, many vendors switched to object database to reduce their burden on data maintenance. It means object database or object relational technologies are taking care of storing, retrieving, updating, and maintaining data. The core part of this object relational technology is mapping orm.xml files. As xml does not require compilation, we can easily make changes to multiple data sources with less administration.Object Relational MappingObject Relational Mapping (ORM) briefly tells you about what is ORM and how it works. ORM is a programming ability to covert data from object type to relational type and vice versa. The main feature of ORM is mapping or binding an object to its data in the database. While mapping, we have to consider the data, the type of data, and its relations with self-entity or entities in any other table.Advanced Features∙Idiomatic persistence : It enables you to write persistence classes using object orientedclasses.∙ High Performance : It has many fetching techniques and helpful locking techniques.∙Reliable : It is highly stable and used by many professional programmers.ORM ArchitectureThe ORM architecture looks as follows.3.The above architecture explains how object data is stored into a relational database in three phases.Phase 1The first phase, named as the object data phase, contains POJO classes, service interfaces, and classes. It is the main business component layer, which has business logic operations and attributes.For example, let us take an employee database as a schema.∙Employee POJO class contains attributes such as ID, name, salary, and designation. It also contains methods like setter and getter of those attributes.∙Employee DAO/Service classes contain service methods such as create employee, find employee, and delete employee.13Phase 2The second phase, named as mapping or persistence phase, contains JPA provider, mapping file (ORM.xml), JPA Loader, and Object Grid.∙JPA Provider: It is the vendor product that contains the JPA flavor (javax.persistence). For example Eclipselink, Toplink, Hibernate, etc.∙Mapping file: The mapping file (ORM.xml) contains mapping configuration between the data in a POJO class and data in a relational database.∙JPA Loader: The JPA loader works like a cache memory. It can load the relational grid data. It works like a copy of database to interact with service classes for POJO data (attributes of POJO class).∙Object Grid: It is a temporary location that can store a copy of relational data, like a cache memory. All queries against the database is first effected on the data in the object grid. Only after it is committed, it affects the main database.Phase 3The third phase is the relational data phase. It contains the relational data that is logically connected to the business component. As discussed above, only when the business component commits the data, it is stored into the database physically. Until then, the modified data is stored in a cache memory as a grid format. The process of the obtaining the data is identical to that of storing the data.The mechanism of the programmatic interaction of the above three phases is called as object relational mapping.Mapping.xmlThe mapping.xml file instructs the JPA vendor to map the entity classes with the database tables.Let us take an example of Employee entity that contains four attributes. The POJO class of Employee entity named Employee.java is as follows:1415The above code is the Employee entity POJO class. It contain four attributes eid, ename, salary, and deg. Consider these attributes as the table fields in a table and eid as the primary key of this table. Now we have to design the hibernate mapping file for it. The mapping file named mapping.xml is as follows:16The above script is used for mapping the entity class with the database table. In this file, ∙<entity-mappings> tag defines the schema definition to allow entity tags into the xml file.∙<description> tag provides a description of the application.∙<entity> tag defines the entity class which you want to convert into a table in a database. Attribute class defines the POJO entity class name.∙<table> tag defines the table name. If you want to have identical names for both the class as well as the table, then this tag is not necessary.∙<attributes> tag defines the attributes (fields in a table).∙<id> tag defines the primary key of the table. The <generated-value> tag defines how to assign the primary key value such as Automatic, Manual, or Taken from Sequence.∙<basic> tag is used for defining the remaining attributes of the table.∙<column-name> tag is used to set user-defined field names in the table.AnnotationsGenerally xml files are used to configure specific components, or mapping two different specifications of components. In our case, we have to maintain xml files separately in a17framework. That means while writing a mapping xml file, we need to compare the POJO class attributes with entity tags in the mapping.xml file.Here is the solution. In the class definition, we can write the configuration part using annotations. Annotations are used for classes, properties, and methods. Annotations start with ‘@’ symbol. Annotations are declared prior to a class, property, or method. All annotations of JPA are defined in the javax.persistence package.The list of annotations used in our examples are given below.18Java Bean StandardThe Java class encapsulates the instance values and their behaviors into a single unit called object. Java Bean is a temporary storage and reusable component or an object. It is a19serializable class which has a default constructor and getter and setter methods to initialize the instance attributes individually.Bean Conventions∙Bean contains its default constructor or a file that contains a serialized instance.Therefore, a bean can instantiate another bean.∙The properties of a bean can be segregated into Boolean properties or non-Boolean properties.∙Non-Boolean property contains getter and setter methods.∙Boolean property contains setter and is method.∙Getter method of any property should start with small lettered get(Java method convention) and continued with a field name that starts with a capital letter. For example, the field name is salary, therefore the getter method of this field is getSalary ().∙Setter method of any property should start with small lettered set(Java method convention), continued with a field name that starts with a capital letter and the argument value to set to field. For example, the field name is salary, therefore the setter method of this field is setSalary (double sal).∙For Boolean property, the is method is used to check if it is true or false. For example, for the Boolean property empty, the is method of this field is isEmpty ().20JAVA PERSISTENCE API (JPA)End of ebook previewIf you liked what you saw…Buy it from our store @ https://21。
springDataJpa基本使用
springDataJpa基本使⽤Spring Data JPA 基本使⽤⼤体内容⼀、创建SpringDataJPA项⽬1 导⼊依赖2 配置数据源信息3 编写Dao4 user5 编写测试代码⼆、 Spring Data JPA 的接⼝继承结构三、 Spring Data JPA 的运⾏原理四、 Repository 接⼝1 ⽅法名称命名规则查询2 基于@Query 注解的查询2.1通过 JPQL 语句查询2.2通过 SQL 语句查询3 通过@Query 注解完成数据更新五、 CrudRepository 接⼝六、 PagingAndSortingRepository 接⼝1 分页处理2 排序的处理七、 JpaRepository 接⼝⼋、 JpaSpecificationExecutor 接⼝1 单条件查询2 多条件查询2.1给定查询条件⽅式⼀2.2 给定查询条件⽅式⼆3 分页4 排序5 分页与排序九、⽤户⾃定义Repository接⼝⼗、关联映射操作1 ⼀对⼀的关联关系2 ⼀对多的关联关系3 多对多的关联关系Spring Data JPA:Spring Data JPA 是 spring data 项⽬下的⼀个模块。
提供了⼀套基于 JPA标准操作数据库的简化⽅案。
底层默认的是依赖 Hibernate JPA 来实现的。
Spring Data JPA 的技术特点:我们只需要定义接⼝并集成 Spring Data JPA 中所提供的接⼝就可以了。
不需要编写接⼝实现类。
⼀、创建SpringDataJPA项⽬1 导⼊依赖<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency>2 配置数据源信息spring.datasource.driver-class-name=com.mysql.jdbc.Driverspring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?useSSL=falseername=rootspring.datasource.password=tianyaspring.jpa.hibernate.ddl-auto=nonespring.jpa.database-platform=org.hibernate.dialect.MySQL5Dialectserver.port=8010.springframework=error#spring.jpa.generate-ddl=spring.jpa.show-sql=truespring.jpa.properties.hibernate.format_sql=truespring.jpa.properties.hibernate.type=tracee_sql_comments=truespring.jpa.properties.hibernate.jdbc.batch_size=50.hibernate.type.descriptor.sql=trace3 编写Daopublic interface UsersDao extends JpaRepository<Users, Integer> {}4 Userimport 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)//strategy=GenerationType.IDENTITY ⾃增长@Column(name="userid")private Integer userid;@Column(name="username")private String username;@Column(name="userage")private Integer userage;public Integer getUserid() {return userid;}public void setUserid(Integer userid) {erid = userid;}public String getUsername() {return username;}public void setUsername(String username) {ername = username;}public Integer getUserage() {return userage;}public void setUserage(Integer userage) {erage = userage;}@Overridepublic String toString() {return "Users [userid=" + userid + ", username=" + username + ", userage=" + userage + "]";}}5 编写测试代码@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration("classpath:applicationContext.xml")public class UsersDaoImplTest {@Autowiredprivate UsersDao usersDao;/*** 添加⽤户*/@Test@Transactional// 在测试类对于事务提交⽅式默认的是回滚。
在Java中使用JPA进行数据库操作
在Java使用JPA行数据库操作Java Persistence API (JPA) 是Java EE 平台中用于ORM的标准API。
使用JPA，你可以将Java 对象映射到数据库表中，并可以轻松地进行查询和更新操作。
以下是在Java 中使用JPA 进行数据库操作的基本步骤：1.添加依赖：首先，你需要在项目中添加JPA 的依赖。
如果你使用Maven，可以在pom.xml文件中添加如下依赖：xml复制代码<dependency><groupId>org.hibernate</groupId><artifactId>hibernate-core</artifactId><version>5.4.31.Final</version></dependency>2.配置数据源：在项目中配置数据源。
如果你使用Maven，可以在pom.xml文件中添加如下依赖：xml复制代码<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.23</version></dependency>然后在src/main/resources目录下创建persistence.xml文件，内容如下：xml复制代码<persistence-unit name="myPersistenceUnit" transaction-type="RESOURCE_LOCAL"><properties><property name="hibernate.connection.driver_class"value="com.mysql.cj.jdbc.Driver" /><property name="hibernate.connection.url"value="jdbc:mysql://localhost:3306/mydatabase" /><property name="ername"value="username" /><property name="hibernate.connection.password"value="password" /></properties></persistence-unit>3.创建实体类：创建一个实体类，并通过注解来定义它与数据库表之间的映射关系。
jpa开发手册
JPA 开发文档1. 发展中的持久化技术 (2)1.1 JDBC (2)1.2 关系对象映射( Object Relational Mapping ，ORM ) (2)1.3 Java 数据对象( Java Data Object ，JDO ) (2)1.4 Java Persistence API ( JPA) (2)2. JPA 体系架构 (3)清单 1 在非Java EE 环境使用JPA 接口的例子 (4)清单 2 在容器中运行的JPA 例子 (5)3. Entity Bean (6)3.1 定义对Entity 中属性变量的访问 (6)3.2 主键和实体标识( Primary Key and Entity Identity) (8)4. EntityManager (9)4.1 配置和获得EntityManager (9)4.2 Entity 的生命周期和状态 (10)4.3 持久化Entity(Persist) (11)4.4 获取Entity (13)4.5 更新Entity (13)4.6 删除Entity (14)4.7 脱离/附合(Detach/Merge) (14)5. JPA Query (15)5.1 Query 接口. (15)5.2 简单查询 (16)5.3 使用参数查询 (17)5.4 排序(order by) (17)5.5 查询部分属性 (18)5.6 查询中使用构造器(Constructor) (18)5.7 聚合查询(Aggregation) (19)5.8 关联(join) (20)5.9 比较Entity (22)5.10 批量更新(Batch Update) (22)5.11 批量删除(Batch Remove) (22)1. 发展中的持久化技术1.1 JDBC很多企业应用的开发者选择使用JDBC 管理关系型数据库中的数据。
JDBC 支持处理大量的数据，能够保证数据的一致性，支持信息的并发访问，提供SQL 查询语言查找数据。
java jpa用法
java jpa用法Java JPA用法什么是Java JPAJava JPA（Java Persistence API）是一种用于Java应用程序中持久化对象的规范。
它提供了一种简化数据库访问和操作的方式，使开发人员能够更方便地使用Java语言来进行数据存储的相关操作。
如何使用Java JPA以下是Java JPA的一些常见用法：1.定义实体类在使用Java JPA之前，首先需要定义实体类，这些实体类对应着数据库中的表。
可以使用@Entity注解将Java类声明为JPA实体类，使用@Table注解指定对应的数据库表名。
@Entity@Table(name = "user")public class User {// 实体类的属性和方法}2.配置数据源JPA需要通过数据源来连接数据库。
可以使用JPA提供的``文件或通过代码进行配置。
在配置数据源时，需要指定数据库的URL、用户名、密码等信息。
("", "jdbc:("", "root");("", "password");3.编写Repository接口Repository接口用于定义对实体类进行CRUD操作的方法。
可以通过在接口中声明方法的命名规则来自动生成具体实现。
public interface UserRepository extends Jp aRepository<User, Long> {List<User> findByUsername(String username);}4.使用EntityManager进行操作EntityManager是JPA的核心接口之一，提供了对实体类进行增删改查的方法。
可以通过@PersistenceContext注解将EntityManager注入到Java类中，方便进行数据库操作。
jpa_注解_手册
核心提示：JPA 注解的几个要点1.设置Pojo为实体@Entity //标识这个pojo是一个jpa实体public class Users implements Serializable{ }2.设置表名@Entity @Table (name= users ) //指定表名为users public class Users implements Serializable{ }3.设置主键publicJPA 注解的几个要点1.设置Pojo为实体@Entity //标识这个pojo是一个jpa实体public class Users implements Serializable {}2.设置表名@Entity@Table(name = "users") //指定表名为userspublic class Users implements Serializable {}3.设置主键public class Users implements Serializable {@Idprivate String userCode;4. 设置字段类型通过@Column注解设置，包含的设置如下.name：字段名.unique：是否唯一.nullable：是否可以为空.inserttable：是否可以插入.updateable：是否可以更新.columnDefinition: 定义建表时创建此列的DDL.secondaryTable: 从表名。
如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字。
@Column(name = "user_code", nullable = false, length=32)//设置属性userCode对应的字段为user_code，长度为32，非空private String userCode;@Column(name = "user_wages", nullable = true, precision=12, scale=2)//设置属性wages 对应的字段为user_wages，12位数字可保留两位小数，可以为空private double wages;@Temporal(T emporalType.DATE)//设置为时间类型private Date joinDate;5.字段排序在加载数据的时候可以为其指定顺序，使用@OrderBy注解实现@Table(name = "USERS")public class User {@OrderBy(name = "group_name ASC, name DESC")private List books = new ArrayList();}6.主键生成策略public class Users implements Serializable {@Id@GeneratedValue(strategy=GenerationType.IDENTITY)//主键自增，注意，这种方式依赖于具体的数据库，如果数据库不支持自增主键，那么这个类型是没法用的@Column(name = "user_id", nullable = false)private int userId;public class Users implements Serializable {@Id@GeneratedValue(strategy=GenerationType.TABLE)//通过一个表来实现主键id的自增，这种方式不依赖于具体的数据库，可以解决数据迁移的问题@Column(name = "user_code", nullable = false)private String userCode;public class Users implements Serializable {@Id@GeneratedValue(strategy=GenerationType.SEQUENCE)//通过Sequence来实现表主键自增，这种方式依赖于数据库是否有SEQUENCE，如果没有就不能用@SequenceGenerator(name="seq_user")@Column(name = "user_id", nullable = false)private int userId;7.一对多映射关系有T_One和T_Many两个表，他们是一对多的关系，注解范例如下主Pojo@Entity@Table(name = "T_ONE")public class One implements Serializable {private static final long serialVersionUID = 1L;@Id@Column(name = "ONE_ID", nullable = false)private String oneId;@Column(name = "DESCRIPTION")private String description;@OneToMany(cascade = CascadeType.ALL, mappedBy = "oneId")//指向多的那方的pojo 的关联外键字段private Collection<Many> manyCollection;子Pojo@Entity@Table(name = "T_MANY")public class Many implements Serializable {private static final long serialVersionUID = 1L;@Id@Column(name = "MANY_ID", nullable = false)private String manyId;@Column(name = "DESCRIPTION")private String description;@JoinColumn(name = "ONE_ID", referencedColumnName = "ONE_ID")//设置对应数据表的列名和引用的数据表的列名@ManyToOne//设置在“一方”pojo的外键字段上private One oneId;8.多对多映射关系貌似多对多关系不需要设置级联，以前用hibernate的时候着实为多对多的级联头疼了一阵子，JPA的多对多还需要实际的尝试一下才能有所体会。
JAVAJPA,JPA手册
JPA关联关系映射JPA中规定，多的一方为关系维护端，关系维护端负责外键记录的更新。
关系被维护端是没有权利更新外键记录。
一对多@OneToMany(cascade={CascadeType.REFRESH,CascadeType.PER SIST,CascadeType.MERGE,CascadeType.REMOVE},fetch=FetchT ype.EAGER,mappedBy="order")cascade表示级联fetch=FetchType.EAGER表示马上加载数据fetch=ZY表示延迟加载数据mappedBy="order" 表示是关系被维护端相当于hibernate中的invserse后面是Many的一方，默认是延迟加载后面是Oen的一方，默认是立即加载多对一@ManyToOne(cascade={CascadeType.REFRESH,CascadeType.MER GE},optional=false)@JoinColumn(name="order_id") 表示外键列optionnal表示是否可以为空 true表示可以为空 false表示不能为空一对一关系@OneToOne(mappedBy = "idCard", cascade ={ CascadeType.REFRESH,CascadeType.PERSIST,CascadeType.MERGE },optional=false)@OneToOne(optional=false,cascade=CascadeType.ALL)@JoinColumn(name="c_id")多对多关系维护端设为student维护端的注解@ManyToMany(cascade = CascadeType.REFRESH)@JoinTable(name = "student_teacher", inverseJoinColumns = @JoinColumn(name = "teacher_id"), joinColumns = @JoinColumn(name = "stu_id"))@ JoinTable表示第三方关系表的信息inverseJoinColumns = @JoinColumn(name = "teacher_id")表示被维护端外键在第三方关系表的定义joinColumns = @JoinColumn(name = "stu_id"))表示维护端在第三方关系表的定义被维护端的注解@ManyToMany(cascade=CascadeType.REFRESH,mappedBy="teach ers")联合主键定义主键类1.需要空的构造方法2.必须实现序列化接口3.类上注解@Embeddable 告诉JPA这个类里面的属性作为其他类的属性，也就是嵌入到其他类中在使用上面定义的联合主键类的属性上标注@EmbeddedIdpublic CompositeKey getId() {return id;}代表 id是一个使用联合主键的属性大多数人以为hashCode()方法就是JAVA地址转换而来，这其实是一个误解。
【java框架】JPA（1）--JPA入门
【java框架】JPA（1）--JPA⼊门1. JPA认识JPA是Java Persistence API的简称，它是Sun公司在充分吸收现有ORM框架（Hibernate）的基础上，开发⽽来的⼀个Java EE 5.0平台标准的开源的对象关系映射（ORM）规范。
Hibernate与JPA的关系：Hibernate是⼀个开放源代码的对象关系映射（ORM）框架，它对JDBC进⾏了⾮常轻量级的对象封装，将POJO与数据库表建⽴映射关系，是⼀个全⾃动的ORM框架，Hibernate可以⾃动⽣成SQL语句，⾃动执⾏，使Java程序员可以随⼼所欲地使⽤⾯向对象思维来操纵数据库。
⽽JPA是Sun官⽅提出的Java持久化规范，⽽JPA是在充分吸收Hibernate、TopLink等ORM框架的基础上发展⽽来的。
总结⼀句话就是：JPA是持久化的关系映射规范、接⼝API，⽽Hibernate是其实现。
1.1. JPA的优缺点优点：①操作代码很简单，插⼊—persist、修改—merge、查询—find、删除—remove；②直接⾯向持久化对象操作；③提供了世界级的数据缓存：包括⼀级缓存、⼆级缓存、查询缓存；④切换数据库移植性强，对应各种数据库抽取了⼀个⽅⾔配置接⼝，换数据库只需修改⽅⾔配置、驱动jar包、数据库连接4个信息即可。
缺点：①不能⼲预SQL语句的⽣成；②对于SQL优化效率要求较⾼的项⽬，不适合使⽤JPA；③对于数据量上亿级别的⼤型项⽬，也不适合使⽤JPA。
2. ⼿动创建⼀个Hello World的JPA项⽬2.1. 导⼊JPA项⽬所需jar包这⾥作为学习使⽤Hibernate 4.3.8的版本jar包，即JPA2.1版本为例进⾏项⽬jar包的构建：导⼊项⽬所需要的Hibernate的jar包分为三类：① Hibernate所必需的jar包：⽬录路径位置：\hibernate-release-4.3.8.Final\lib\required导⼊如下图所⽰jar包集合：②还需要导⼊JPA⽀持的jar包，⽬录路径：\hibernate-release-4.3.8.Final\lib\jpa与数据库Mysql连接驱动jar包；2.2. 配置核⼼配置⽂件persistence.xml配置⽂件必需放在项⽬的classpath⽬录的资源⽂件resources\META-INF⽬录下（JPA规范要求）；persistence.xml⽂件具体配置如下：<persistence xmlns="/xml/ns/persistence" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/persistence /xml/ns/persistence/persistence_2_0.xsd"version="2.0"><!--持久化单元 name：和项⽬名称对应--><persistence-unit name="cn.yif.jpa01" transaction-type="RESOURCE_LOCAL"><properties><!-- 必须配置4个连接数据库属性：配置信息可以在project/etc/hibernate.properties中找到 --><property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver"/><property name="hibernate.connection.url" value="jdbc:mysql:///jpa01_0307"/><property name="ername" value="root"/><property name="hibernate.connection.password" value="admin"/><!-- 必须配置1个数据库⽅⾔属性 --><!-- 实现跨数据库关键类 :查询MySQLDialect的getLimitString⽅法 --><property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/> <!-- 可选配置 --><!-- 是否⾃动⽣成表 --><property name="hibernate.hbm2ddl.auto" value="create"/><!-- 是否显⽰sql --><property name="hibernate.show_sql" value="true"/><!-- 格式化sql --><property name="hibernate.format_sql" value="true"/></properties></persistence-unit></persistence>2.3.创建持久化Domain类Employeepackage cn.yif.domain;import javax.persistence.*;//@Entity表⽰该类是由jpa管理的持久化对象，对应数据库中的⼀张表@Entity//@Table表⽰对应数据库的表名@Table(name = "t_employee")public class Employee {//@Id是必须的注解，表⽰对应数据库的主键@Id//@GeneratedValue表⽰主键的⽣成策略,多数都是使⽤AUTO//@GeneratedValue默认不配置也是AUTO@GeneratedValue(strategy = GenerationType.AUTO)private Integer id;//@Column表⽰如果数据库列名与属性名不⼀致，需要配置@Column(name = "e_name")private String name;@Column(name = "e_age")private Integer age;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}@Overridepublic String toString() {return "Employee{" +"id=" + id +", name='" + name + '\'' +", age=" + age +'}';}}2.4.创建Junit4测试类代码import cn.yif.domain.Employee;import org.junit.Test;import javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence.EntityTransaction;import javax.persistence.Persistence;public class JPAHelloTest {@Testpublic void testInsertEmpByJPA(){Employee employee = new Employee();employee.setName("⾼伟翔");employee.setAge(34);// 对应配置⽂件⾥⾯的persistence-unit name="cn.yif.jpa01"// 通过持久化类创建⼀个实体类管理⼯⼚EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("cn.yif.jpa01");//创建⼀个实体管理类，可以实现CRUDEntityManager entityManager = entityManagerFactory.createEntityManager();//由entityManager来开启事务EntityTransaction transaction = entityManager.getTransaction();transaction.begin();//持久操作CRUD 写⼊persistentityManager.persist(employee);// 提交事务mit();//关闭资源entityManager.close();entityManagerFactory.close();}}通过以上的步骤，就可以在创建的jpa01_0307数据库⾥⾯由JPA⾃动创建⼀张t_employee表并插⼊⼀条数据：3. 实现完整的JPA CRUD流程3.1.抽取JPAUtil类package cn.yif.utils;import javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence.Persistence;/*** ⼯具类:单例模式/静态单例模式静态⽅法*/public class JPAUtil {// 私有化这个构造器,不让其它⼈创建这个类private JPAUtil(){}// 实体管理⼯⼚// 注意:EntityManagerFactory这个类是线程安全private static EntityManagerFactory entityManagerFactory;/*** 静态代码块，类加载的时候就会执⾏⾥⾯的代码，只会执⾏⼀次*/static{try {entityManagerFactory = Persistence.createEntityManagerFactory("cn.yif.jpa01");} catch (Exception e) {e.printStackTrace();throw new RuntimeException("拿到EntityManagerFactory运⾏时出错："+e.getMessage());}}// 拿到⼀个EntityManager对象// 每次拿EntityManager都需要重新创建(EntityManager不是线程安全的对象，每次使⽤都重新创建⼀次)public static EntityManager getEntityManager(){return entityManagerFactory.createEntityManager();}public static void close(EntityManager entityManager){//关闭资源entityManager.close();entityManagerFactory.close();}}4. persitence.xml中hibernate.hbm2ddl.auto属性值配置如上，hibernate.hbm2ddl.auto属性的value值⼀共有4种配置：create-drop、create、update、validate。
JPA使用规范说明书2.0
JPA使用规范说明书科大讯飞股份有限公司2017年10月26日1 / 20版本记录1、JPA概述1.1 什么是JPA规范JPA规范（java持久化API）JPA和Hibernate等框架一样，都是java 持久化解决方案，负责把数据保存到数据库。
不同的是，JPA只是一种标注，规范，而不是框架。
JPA自己没有具体的实现。
使用JPA后，程序不在依赖于某种ORM框架。
具体实现有TopLink，Eclipselink, OpenJPA等。
随着ibatis,hibernate等优秀的ORM管理框架的出现，相比以上供应商，使得JPA性能有了很大的提升。
1.2 JPA原理实现我们知道JPA 只是一个规范，下面的JPA Provider 可以由不同的ORM 框架提供。
ORM 框架可以根据映射关系，操作PO对象，自动生成增查改删的SQLJPA包括以下3方面的技术：1. ORM映射元数据，JPA支持XML和JDK 5.0注解两种元数据的形式，元数据描述对象和表之间的映射关系，框架据此将实体对象持久化到数据库表中；2. JPA的API，用来操作实体对象，执行CRUD操作，框架在后台替我们完成所有的事情，开发者从繁琐的JDBC和SQL代码中解脱出来。
3. 查询语言，这是持久化操作中很重要的一个方面，通过面向对象而非面向数据库的查询语言查询数据，避免程序的SQL语句紧密耦合。
使用JPA的优点也是有很多：继承Repository接口，在注解中书写JPQL语句即可访问数据库；支持方法名解析方式访问数据库；使用Predicate支持动态查询JPA当访问数据库主要工作1.得到JDBC驱动程序2.得到持久性提供者相关类库和配置文件3.提供实体类4.使用Persistence、EntityManagerFactory和Entity等接口。
2、JPA使用2.1 使用前的准备及配置2.1.1 原生配置方式java-persistenceMaven依赖：<dependency><groupId>org.eclipse.persistence</groupId><artifactId>javax.persistence</artifactId><version>2.0.0</version></dependency><dependency><groupId>org.eclipse.persistence</groupId><artifactId>eclipselink</artifactId><version>2.0.0</version></dependency>配臵文件（MATA-INF>下的persistence.xml）怎么去掉persistence.xml的实体类配置？使用了 persistence 配置文件，去掉“persistenceUnitName”属性，添加“packagesToScan”属性，persistence.xml配置文件中的persistence-unit名字照样保留，但是 persistence 配置文件中不需要对实体类进行配置，会自动识别。
SpringDataJPA基础教程（论文资料）
Java 私塾《深入浅出学Spring Data JPA 》——系列系列精品教程j a v a 私塾《深入浅出学Spring Data JPA 》—系列精品教程真正高质量培训签订就业协议网址：整体课程概览n 系统学习Spring Data JPA 的核心开发知识，循序渐进，系统掌握n 第一章：Spring Data JPA 入门包括：是什么、能干什么、有什么、HelloWorld 等n 第二章：JpaRepository 基本功能包括：代码示例JpaRepository 提供的CRUD 功能，还有翻页、排序等功能n 第三章：JpaRepository 的查询包括：解析方法名称以自动生成查询、NamedQueries 、@Query 指定查询、本地查询、命名化参数、更新查询、创建查询的顺序等内容n 第四章：客户化扩展JpaRepository包括：讲述如何在JpaRepository 基础上扩展我们自己需要的功能n 第五章：Specifications 查询包括：Specifications 基础、Criteria 查询基本概念、Criteria 查询实现、多表联接等内容j a v a 私塾真正高质量培训签订就业协议网址：第一章：Spring Data JPA 入门j av a 私塾真正高质量培训签订就业协议网址：Spring Data JPA 是什么n Spring Data 是什么Spring Data 是一个用于简化数据库访问，并支持云服务的开源框架。
其主要目标是使得对数据的访问变得方便快捷，并支持map-reduce 框架和云计算数据服务。
Spring Data 包含多个子项目：Commons -提供共享的基础框架，适合各个子项目使用，支持跨数据库持久化JPA -简化创建JPA 数据访问层和跨存储的持久层功能Hadoop -基于Spring 的Hadoop 作业配置和一个POJO 编程模型的MapReduce 作业Key-Value -集成了Redis 和Riak ，提供多个常用场景下的简单封装Document -集成文档数据库：CouchDB 和MongoDB 并提供基本的配置映射和资料库支持Graph -集成Neo4j 提供强大的基于POJO 的编程模型Graph Roo AddOn -Roo support for Neo4jJDBC Extensions -支持Oracle RAD 、高级队列和高级数据类型Mapping -基于Grails 的提供对象映射框架，支持不同的数据库Examples -示例程序、文档和图数据库Guidance -高级文档n Spring Data JPA 是什么由Spring 提供的一个用于简化JPA 开发的框架j a v a 私塾真正高质量培训签订就业协议网址：Spring Data JPA 能干什么和有什么n Spring Data JPA 能干什么可以极大的简化JPA 的写法，可以在几乎不用写实现的情况下，实现对数据的访问和操作。
第十三章 开发JPA应用
MyEclipse 6 Java 开发中文教程第十三章 开发 JPA 应用第十三章 开发JPA应用 ..................................................................................................... 1 13.1 介绍 ................................................................................................................... 2 13.1.1 JPA 简介.................................................................................................. 2 13.1.2 MyEclipse提供的JPA开发功能 ................................................................. 4 13.1.3 JPA的代码结构和相关理论知识................................................................ 4 13.1.3.1 JPA代码结构 .................................................................................. 4 13.1.3.2 配置文件persistence.xml............................................................... 4 13.1.3.3 实体类及标注 ................................................................................ 6 13.1.3.4 使用EntityManager来管理实体.................................................... 13 13.1.3.5 Query对象.................................................................................... 18 13.1.3.6 JPA 查询语言（JPA QL）简介 .................................................... 19 13.1.3.7 回调方法 ..................................................................................... 21 13.2 准备工作.......................................................................................................... 22 13.3 创建JPAHello项目 ............................................................................................ 22 13.3.1 创建表格................................................................................................. 22 13.3.2 创建 HelloJPA Java Project ................................................................... 23 13.3.3 添加 JPA Capabilities 到现有项目......................................................... 23 13.3.4 使用JPA配置文件编辑器修改文件 ......................................................... 25 13.3.5 使用反向工程快速生成JPA实体类和DAO .............................................. 28 13.3.6 调整生成的实体类标注 .......................................................................... 42 13.3.7 编写测试代码 ........................................................................................ 43 13.4 JPA 工具高级部分............................................................................................ 46 13.4.1 MyEclipse Java Persistence Perspective透视图 .................................... 46 13.4.2 JPA Details 视图.................................................................................... 47 13.4.3 JPA 代码编辑辅助 ................................................................................. 49 13.4.4 生成一对多等复杂映射代码 ................................................................... 49 13.5 Spring整合JPA开发 .......................................................................................... 58 13.5.1 添加Spring开发功能 .............................................................................. 59 13.5.2 从数据库反向工程生成实体和Spring DAO............................................. 60 13.5.3 编写并运行测试代码.............................................................................. 71 13.5.3.1 支持标注事务时的调试代码 ......................................................... 71 13.5.3.2 不支持标注事务时的调试代码 ..................................................... 73 13.6 小结 ................................................................................................................. 74 13.7 参考资料.......................................................................................................... 751刘长炯著MyEclipse 6 Java 开发中文教程在本章我们将会介绍 JPA 的开发，一共包括三部分内容：独立运行的 JPA 应用开发； Spring 整合 JPA 开发； EJB 查询语言开发。
JPA使用指南javax.persistence的注解配置
JPA使用指南javax.persistence的注解配置JPA使用指南 javax.persistence的注解配置文章分类:Java编程JPA注解持久化类很方便，需要jar包：ejb3-persistence.jar。
我用以下三个类来说明用法。
sh原创转载请注明：Java代码1.@SuppressWarnings("serial")2.@Entity3.@Table(name="T_X")4.public class X implements Serializable5.{6.@Id7.@GeneratedValue(strategy = GenerationType.AUTO)8.private int id;9.10.@Column(length=32)11.private String name;12.13.@Transient//表示此数据不在数据库表里建立属性14.private String temp;15.16.@Temporal(TemporalType.TIMESTAMP) //这个是带时分秒的类型17.private Date date;18.19.@OneT oOne(cascade = CascadeType.ALL, mappedBy = "x")20.private A a;22.@SuppressWarnings("serial")23.@Entity24.@Table(name="T_A")25.public class A implements Serializable26.{27.@Id28.@GeneratedValue(strategy = GenerationType.AUTO)29.private int id;30.31.@OneT oMany(cascade = CascadeType.ALL, mappedBy = "a", fetch = FetchType.EAGER)32.private List<B> b = new ArrayList<B>();33.34.@OneT oOne()35.@JoinColumn(name = "x_Id") //加这句后就会双方共同维护关系36.private X x;37.}38.39.@SuppressWarnings("serial")40.@Entity41.public class B implements Serializable{42.@Id43.@GeneratedValue(strategy = GenerationType.AUTO)44.protected int id;45.46.@ManyToOne()47.@JoinColumn(name = "a_id")48.protected A a;要注意的是：fetch = FetchType.EAGER这句话在一个类里面只能出现一次，出现两次就会报错“cannot simultaneously fetch multiple bags”，要把其他的改为fetch = ZY延迟加载就可以了。
jpa 教程
jpa 教程JPA（Java Persistence API）是Java平台上的ORM（对象关系映射）规范。
它为开发人员提供了一种通过面向对象的方式来操作数据库的方法，从而简化了数据持久化的开发工作。
下面将介绍JPA的一些基本概念和用法。
1. 实体类（Entity）：在JPA中，实体类用于映射数据库中的表。
实体类必须使用`@Entity`注解进行标识。
2. 实体属性（Entity Property）：实体类中的成员变量对应数据库表中的字段。
通过使用`@Column`注解可以设置属性在数据库中的列名、长度、是否可为空等。
3. 主键（Primary Key）：每个实体类必须定义一个属性作为主键，用于唯一标识实体。
常用的主键生成策略有自增、UUID、序列等。
4. 实体管理器工厂（Entity Manager Factory）：使用`EntityManagerFactory`类可以创建一个可用于管理实体的实体管理器。
5. 实体管理器（Entity Manager）：实体管理器用于执行数据库操作，如插入、更新、删除等。
通过`EntityManager`接口提供的方法可以实现对实体的持久化操作。
6. 查询语言（Query Language）：JPA支持使用JPQL（基于面向对象的查询语言）进行查询操作。
JPQL类似于SQL，但是操作的对象是实体类而不是表。
7. 关联关系（Relationship）：JPA支持定义实体类之间的关联关系，如一对一、一对多、多对多等。
通过在实体类中使用`@OneToOne`、`@OneToMany`、`@ManyToMany`等注解进行标识，可以实现关联关系的映射。
8. 事务管理（Transaction Management）：JPA提供了事务支持，可以保证对实体的操作具备原子性、一致性、隔离性和持久性。
以上是对JPA的简要介绍，希望对你有所帮助。
通过学习JPA，你可以更便捷地在Java平台上进行数据库操作，提高开发效率。