JPA @OneToMany与1- 1..*关系
JPA（Java Persistence API）是Java持久化规范，用于将Java对象持久化到数据库中。@OneToMany和1-1..*关系是JPA中用于描述实体类之间关联关系的注解。
@OneToMany注解表示一对多关系，即一个实体类（一端）关联多个另一个实体类（多端）的对象。在数据库中，通常通过外键来实现这种关系。使用@OneToMany注解时，需要指定关联的多端实体类，以及在多端实体类中表示一端实体类的属性。
1-1..关系表示一对一或一对多关系，即一个实体类（一端）关联一个或多个另一个实体类（多端）的对象。在数据库中，通常通过外键来实现这种关系。使用1-1..关系时，需要在实体类中定义对应的属性，并使用JPA的相关注解来描述关联关系。
这两种关系在实际应用中有不同的优势和应用场景。@OneToMany关系适用于一对多的情况，例如一个订单对应多个商品，一个部门对应多个员工等。1-1..*关系适用于一对一或一对多的情况，例如一个用户对应一个账户或多个账户，一个学生对应一个班级或多个班级等。
对于@OneToMany关系，腾讯云提供了云数据库MySQL和云数据库MariaDB等产品，用于存储和管理关联的数据。您可以通过以下链接了解更多信息：
对于1-1..*关系，腾讯云提供了云数据库MySQL和云数据库MariaDB等产品，同样可以用于存储和管理关联的数据。您可以通过以下链接了解更多信息：
以上是关于JPA @OneToMany与1-1..*关系的概念、分类、优势、应用场景以及腾讯云相关产品的介绍。希望对您有所帮助！
相关·内容
当然，有很多关于n+1 JPA的问题的文章，还有Q&正如这里所说的，其中一些是从@OneToMany的角度来讨论这个问题，另一些是从@ManyToOne的角度来讨论这个问题，这个问题与两者都相关吗？ @OneToMany：当查询实体具有带注释的@OneToMany字段集合时 @ManyToOne：当查询实体具有注释为@ManyToOne的字段时
浏览 64提问于2021-11-18得票数 0
回答已采纳
对于Spring (4.0.8当前)和Hibernate (4.2.16当前)，我在获取分页以执行JPA OneToMany列表的子选择命中时遇到了问题。在内部列表中，子选择选择所有要与主元素组合的元素，而不仅仅是给定页面的元素。
例如：
JPA的主要实体：
@Entity
@NamedQuery(name="Message.findAll", query="SELECT m FROM Message m")
public class Message implements Serializable {
...
//uni-directional many-to-
浏览 3提问于2016-07-07得票数 2
回答已采纳
我想了解为什么JPA在映射中需要双重注释，在主导类中需要OneToMany，在弱类中需要ManyToOne，如果事件是ManyToOne，类别是OneToMany。
@Entity
@Table(name = "event")
public class Event {
@ManyToOne
@JoinColumn(name = "category_id")
private Category category;
public Category getCategory() {
return category;
浏览 3提问于2021-12-05得票数 0
4回答
有没有办法限制JPA中@OneToMany关系的列表大小？下面是我的代码示例：
@OneToMany(mappedBy = "publication", cascade=CascadeType.PERSIST)
private List<Comment> commentList;
我使用的是EclipseLink 2.3JPA实现。提前谢谢。
浏览 3提问于2011-10-26得票数 16
我正在尝试执行JPA/Hibernate映射来映射两个表，但是得到了这个错误。任何帮助都将不胜感激！！
Restaurants.java
@Entity
@Table(name="RESTAURANTS")
public class Restaurants{
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private Long id;
@OneToMany(mappedBy="restaurant")
private LinkedList<Menus>
浏览 7提问于2011-07-20得票数 0
回答已采纳
1回答
我有一个带有一些外键的DB，这些外键没有配置ON DELETE CASCADE；如果可能的话，我想避免更改它。类似地，我们的JPA关系不是用cascade = CascadeType.REMOVE配置的。
是否仍然可以“级联模式”删除实体，即自动为其子实体生成所有必要的删除查询？
理想情况下，我希望通过JPA完成这项工作，但原始SQL查询也可以。主要的问题是，并不是所有(但大多数)外键约束都反映在OneToOne、OneToMany等JPA关系中。
浏览 1提问于2019-12-26得票数 1
默认情况下，@OneToMany注释会创建一个联接表，除非指定了mappedBy元素。
这种行为的原因是什么？例如，与以下实体：
@Entity
public class User {
// ...
@OneToMany
private List<UserDocument> documents;
// ...
}
@Entity
public class UserDocument {
// ...
@ManyToOne
private User user;
// ...
}
对于User实体，为什么不简单地Hiber
浏览 2提问于2017-12-15得票数 0
回答已采纳
在 JPA示例中，有一个代码：
@OneToOne(cascade=CascadeType.ALL)
private Deity mother;
@OneToOne(cascade=CascadeType.ALL)
private Deity father;
@OneToMany(cascade=CascadeType.ALL)
private Set<Deity> children;
为什么与父母的关系是通过@OneToOne注释实现的，而不是在@ManyToOne关系中实现的？如果子类和父类是分开的，则父类具有@OneToMany Collection<Child&g
浏览 4提问于2009-10-19得票数 1
回答已采纳
3回答
在JPA中，有没有可能在不创建实体的情况下建立一对多的关系？
举个例子，比如说我有一个“财富饼干”，里面有几个“幸运数字”。这些幸运数字存储在一个只有cookie_id，lucky_number的表中。
在JPA中的中，不需要为它创建一个专门的实体，就能得到幸运数字的列表吗？
这是我尝试过的，但是它给了我一个Use of @OneToMany or @ManyToMany targeting an unmapped class错误
@Entity
@Table(name = "FORTUNE_COOKIE")
class FortuneCookie {
@Id
浏览 8提问于2020-08-07得票数 2
回答已采纳
我正在使用spring数据、jpa和hibernate。
当我获取一个实体时，会发出多个select语句来获取关系。
是否有一种方法可以指示spring数据jpa在可能的情况下始终使用联接？
例如。实体：
@Entity
public class Parent {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private long id;
@Temporal(TemporalType.TIMESTAMP)
private Date ts;
@OneToMany(fetch=FetchT
浏览 0提问于2016-12-09得票数 1
回答已采纳
3回答
我正在尝试建立一个朋友连接模型，但遇到了问题。我使用JPA持久化对象，并用JPA注解定义我的持久化对象。
我的想法是做以下事情：
用户对象：
@Entity
public class User {
@Column(name="user_id")
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Extension(vendorName="datanucleus", key="gae.encoded-pk", value="true")
private Stri
浏览 0提问于2009-04-21得票数 2
4回答
我在JPA中有两个实体: Entry和Comment。Entry包含两个Comment对象集合。
@Entity
public class Entry {
...
@OneToMany(fetch = FetchType.EAGER, cascade = CascadeType.ALL)
@IndexColumn(base = 1, name = "dnr")
private List<Comment> descriptionComments = new ArrayList<Comment>();
@OneTo
浏览 2提问于2009-03-21得票数 15
回答已采纳
2回答
嵌入物和实体之间是否可能存在双向关系，还是只存在单向关系？
@Entity
public class Employee {
@Id
private long id;
...
@Embedded
private EmploymentPeriod period;
...
}
@Embeddable
public class EmploymentPeriod {
@Column(name="START_DATE")
private java.sql.Date startDate;
@Column(name="END_DATE")
浏览 3提问于2014-02-11得票数 1
回答已采纳
我正在努力在JPA-Hibernate设置中插入@OneToMany实体。
有两个关联表，其中一个表将外键作为源表的主键。
employee
- id (PK)
employee_location
- employee_id (FK to employee)
以下是我的实体：
Employee
@Entity(name = "employee")
class Employee {
@Id
@Column(name = "id")
@GeneratedValue()
private Long id;
浏览 78提问于2021-11-08得票数 0
我有三个类，一个名字是User，这个用户有其他类实例。就像这样；
public class User{
@OneToMany(fetch=FetchType.LAZY, cascade = CascadeType.ALL)
public List<APost> aPosts;
@OneToMany(fetch=FetchType.LAZY, cascade = CascadeType.ALL)
public List<BPost> bPosts;
}
public class BPost extends Post {
浏览 4提问于2012-12-11得票数 54
回答已采纳
我将JPA+Hibernate与PostGre SQL数据库一起用于J2SE项目。
我有两个实体A和B。A与B有@OneToMany关系。
在我的域模型中，A可能引用数百万B。当我向集合中添加一个新对象时，需要几分钟才能完成。
@OneToMany(cascade=CascadeType.PERSIST)
Collection<B> foo = new ArrayList<B>(); // might contain millions of records
//...
// this takes a lot of time
foo.add(new B());
我认为JP
浏览 4提问于2010-08-30得票数 6
回答已采纳
我试着用Vaadin和JPA持久层做一个简单的概念验证。
我有一个带有@OneToMany关系的Bean，fetchType = Lazy，当我试图用我的DAO将这个Bean的集合添加到表中时。我有下一个例外：
Caused by: org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: common.domain.Bill.detail, no session or session was closed
有没有办法在不使用JPAContainer的情况下使用Vaa
浏览 2提问于2012-07-05得票数 0
3回答
我一直在学习JPA 2，并了解了OneToMany和ManyToOne的关系。这是我的标准。
有两个实体，雇员和反馈。
员工可以收到多个反馈。也就是说，反馈和员工之间存在着ManyToOne关系。我已经做到了这一点。
但是，员工也可以为多名员工编写多个反馈。这就是我被困的地方。
我已经建立了员工反馈关系如下。
反馈类
@ManyToOne
@JoinColumn(name="idEmployee")
private Employee employee;
在员工课上，
@OneToMany(mappedBy = "employee",
浏览 4提问于2014-07-21得票数 1
回答已采纳
3回答
我正在使用EJB3.2和JPA2.1。在我的应用程序中，我有以下几个实体(简而言之)：
@Entity
public class Festival
{
int Id;
String name;
...
@ManyToOne
@JoinColumn(name = "merchant", referencedColumnName = "Id")
Merchant merchant;
}
@Entity
public class Merchant
{
int Id;
String name;
浏览 7提问于2015-04-06得票数 0
回答已采纳
1回答
我一点也不明白为什么JPA创建了两个多对多的关系，而不是两个一对多的关系。我有课堂作者和两套收集电话和电子邮件。
@Entity
public class Author {
@Id
@GeneratedValue
private int id;
private String firstName;
private String lastName;
@OneToMany(cascade = CascadeType.PERSIST, fetch = FetchType.EAGER)
private Set<Phone> ph
浏览 0提问于2018-05-01得票数 0
回答已采纳
2回答
我有三个实体类。产品、类别和SubCategory。
类别与SubCategory具有OneToMany关系
@Entity
@Table(name = "CATEGORY")
public class Category {
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE)
@Column(name = "category_id")
private Long categoryId;
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EA
浏览 1提问于2018-01-06得票数 0
我正在寻找一些关于何时使用上述关系的澄清。
例如，我有一个类A，它由类B的实例引用。
这个关系是应该被OneToMany建模并在类A中定义一个类B的集合，还是应该由ManyToOne建模并在类B中引用类A？
我的问题是，关系的选择是完全取决于程序员，还是依赖于应用程序，还是依赖于JPA？
浏览 0提问于2012-09-28得票数 0
回答已采纳
我有两个实体类，名为Product和ComboProduct。产品包含有关特定产品的所有信息，并具有主键productId。ComboProduct持有一个与产品具有@OneToMany关系的列表，并具有一个名为comboProductId的主键。当我使用同一组产品创建多个Comboproduct实例时，我得到以下DataIntegrityViolationException
public class Product {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
p
浏览 6提问于2020-07-29得票数 0
回答已采纳
2回答
我有个问题。我使用JPA和eclipselink，我有关系：
Table A ---< Table AB >---- Table B
class A {
@OneToMany(mappedBy = "a")
private List<AB> abList
}
class AB {
@ManyToOne(fetch = FetchType.LAZY)
private A a;
@ManyToOne(fetch = FetchType.LAZY)
private B b;
}
class B {
@One
浏览 3提问于2013-06-10得票数 0
4回答
我正在尝试将JOIN与JPA结合使用。这是我的JPA查询：
SELECT o FROM Assessment AS o
INNER JOIN AssessmentText at
WHERE o = at.assessment
AND at.localeCode = :localeCode
从Assessment到AssessmentText的关系是OneToMany。
当我执行这个查询时，我得到了：
org.apache.openjpa.persistence.ArgumentException:
Encountered "INNER JOIN AssessmentTe
浏览 2提问于2013-01-02得票数 1
我无法使用JPA中的单向@OneToMany关系获取记录。有什么东西不见了吗？但是，记录是持久化的；只有检索记录才有问题。
class Employee{
int empId;
...
@OneToMany(cascade = ALL, mappedBy = "deptId",fetch = FetchType.EAGER)
List<Department> departments=new ArrayList<>();
//getters and setters
}
class Department{
浏览 4提问于2020-07-21得票数 2
回答已采纳
对于一些人来说，这似乎是一个愚蠢的问题，但我在任何地方都找不到任何信息，为什么我们在定义实体类时应该在JPA中使用映射(@OneToOne、@OneToMany等)。我知道它的一个优点是减少了代码，这样我们就不必显式地编写查询来从关系表中获取数据。但是，我们是否还有其他好处(从SQL方面的代码优化角度来看)？
浏览 22提问于2021-11-26得票数 0
我有一个现有的谷歌应用程序引擎java应用程序运行在jpa上，现在我正在尝试将其对象化以实现许多不同的目的。
当前应用程序具有以下实体表示形式。
Class Parent{
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Key key;
@OneToMany(cascade=CascadeType.ALL, mappedBy="parent")
private List<Child> childs = null;
}
Class Child{
浏览 1提问于2012-08-05得票数 5
回答已采纳
我正在学习Udemy上使用Hibernate (和JPA)的持久性，演示者解释了前面讨论的关联(单向OneToOne、双向OneToOne、单向OneToMany、双向OneToMany)的替代方案，称为@JoinTable JPA注释。
他提到，有时“许多”实体中只有一小部分与特定类型的“一个”实体相关联，我们不希望“多”实体上的一个字段体现与“一个”实体的关联，因为在大多数情况下，该字段将保持为空。他接着为@JoinTable 推荐了。
我的问题是，考虑到@JoinTable选项对Java实体的影响，为什么不对“一个”实体使用单向@OneToMany注释，并将“多”实体保留为-原样呢？除了
浏览 2提问于2020-06-23得票数 0
回答已采纳
1回答
支持正确映射双向JPA关系的工具
、、、、
我在我的项目中有多个JPA (Hibernate)持久化的@OneToMany和@OneToOne关系，它们的setter和adders方法并不一致，正如所讨论的那样。现在，我需要重构这些关系，以编程方式始终保持一致性。是否存在静态代码分析/通用单元测试或其他工具来支持我执行此任务？
浏览 3提问于2017-05-22得票数 0
我有一个JPA2 (Hibernate)应用程序，它使用只有两个表的MySQL数据库。一个表称为“公司”，另一个表称为“雇员”。在这两张桌子之间有一对多的关系(一家公司有很多雇员)。表"employees“中的外键列称为"company_id”。
在我的JPA2应用程序中，我使用了以下注释：
在实体类"Company“中，我有以下注释
@OneToMany(cascade = CascadeType.ALL)
private Collection<Employee> employees;
在班里的雇员
@ManyToOne
private Company c
浏览 4提问于2013-07-24得票数 0
回答已采纳
我正在尝试将MySql数据库迁移到Postgresql。我正在使用JPA，对MySQL数据库使用Eclipse，但我切换到Postgresql数据库的Hibernate。
以下JPA注释适用于EclipseLink：
UserBean.java：
@OneToMany(mappedBy = "sender", cascade = CascadeType.ALL)
@JoinTable(name = "MESSAGES_SENT")
private List<MessageBean> messagesSent;
@OneToMany(mappedBy
浏览 6提问于2014-04-16得票数 8
回答已采纳
我有以下与JoinColumn的OneToMany UNI映射：
但在中，我读到这是错误的，在JoinColumn的情况下，需要一个反向关系。我不明白为什么。我的代码行得通。诱饵在哪里？
If the OneToMany uses a foreign key in the target object's table JPA requires that the
relationship be bi-directional (inverse ManyToOne relationship must be defined
in the target object), and the
浏览 2提问于2018-01-06得票数 0
1回答
我是新接触JPA的，更不用说使用JPA了，所以我想知道用@ManyToOne关系将对象保存到多个类的最佳方法是什么。
UserJump类的定义如下：
@Entity
public class UserJump extends Model{
@ManyToOne
public User user;
@ManyToOne
public JumpSession jumpSession;
public String parachuteUID;
public String notes;
public int status;
}
从JumpSessi
浏览 1提问于2011-12-13得票数 1
回答已采纳
2回答
如何在EJB3.0 Entity-Beans (JPA)中建立单向关系？
例如，客户知道订单，但订单对客户没有任何方法。使用(@OneToMany或@OneToOne或@ManyToMany)
问候
浏览 1提问于2010-08-19得票数 6
回答已采纳
所以，我在我的一个项目中有一个OneToMany关系：
@OneToMany(cascade = { CascadeType.PERSIST, CascadeType.REFRESH }, fetch = FetchType.LAZY)
@OrderBy("priority")
private List<Result> results
我希望根据一些标准获得这些“结果”中包含的对象：
Stream<Item> itemsToReturn = results.stream().filter(result -> result.getPriori
浏览 13提问于2016-04-30得票数 1
回答已采纳
如何获得JPA实体的OneToMany字段的计数作为查询每个父实体的计数，同时将其作为一个列表获取成本很高，在JPA中是没有办法的。
我想得到每个PostEntity的喜欢和评论的数量。这个字段是Lazy类型，如果我调用likes.size()或comments.size()，那么它将从数据库加载所有的评论和喜欢，并且可以有数以千计的评论和喜欢。
我知道我可以为喜欢和评论创建一个独立的回购来获取计数，但是在从PostRepository调用方法时，如何获取每个实体的计数呢？什么是最好和有效的方式？
父实体
@Entity
@Table(name = "posts")
@Gett
浏览 8提问于2022-05-14得票数 0
我的Spring项目中有这个类用户
@Entity
public class User extends TimeStampModel{
// Extends TimeStampModel so we know when the user was created
@Id
@GeneratedValue
@Column
private long id;
@Column
private String username;
@Column
private String password;
@Column
pri
浏览 0提问于2020-01-02得票数 0
回答已采纳
1回答
为了清晰起见，我试图创建一个收藏夹映射，我对如何实现它有些困惑，为了清晰起见，它只有两个绑定(第一个(文件)- @OneToMany，第二个(最喜欢的文件)- @ManyToMany )。
@OneToMany(mappedBy = "app_user")
@JsonIgnoreProperties("app_user")
private List<File> file;
@ManyToMany(mappedBy = "app_user")
@JsonIgnoreProperties("app_us
浏览 13提问于2022-07-13得票数 -1
回答已采纳
如果我有一个包含集合字段的JPA实体，如
public class Post {
// [...]
@OneToMany
private List<String> tags;
对应的数据库模式通常包含一个单独的表，用于存储标记，其中每个记录包含一个标记和一个对"Post“表的外键引用。
现在，当我从没有标记的数据库中加载一个"Post“实体(即不存在对应的”标记“记录)时，Post.tags的值是多少？它是设置为null，还是设置为空List？或者这是个未知数？
我在JPA规范中找不到这一点。
注意:这个问题和一样，只适用于JPA规范，而不是专
浏览 1提问于2018-06-14得票数 10
回答已采纳
嗨，我在一个实体中有一个OneToMany关系芯片。当我执行findAll JPA时，请将所有@ManyToOne中的数据带给我，但为@OneToMany (集合为空)带来[]空。
这就是主要实体中的关系：
public class Emprendimientos implements Serializable {
.
.
.
@OneToMany(cascade = CascadeType.ALL, mappedBy = "logoId")
private Collection<LogosEmprendimientos> logosEmprendimientos;
浏览 5提问于2022-01-03得票数 1
2回答
我有两张桌子：
第一个是“个人”：
person_id，
person_name
第二个是"PersonsGraphs"：
person_id1，
person_id2，
relation_type
我在寻找一种建立“家谱”的方法。
我的第一个选项是：将personGraphs加载到HashTable中，然后递归地构建树。
是我提出的的第二个选项:使用@OneToMany jpa-relation。这是可行的，但有时我有一些希望/不想包含的relation_types。是否有任何选项允许我在使用@OneToMany时对@JoinTable关
浏览 3提问于2013-05-01得票数 7
4回答
我不知道如何用JPA干净利落地创建一个标签云，其中每个数据库实体都可以有许多标签。
E.g
帖子可以有0个或多个标签用户可以有0个或多个标签
在JPA中，有没有比让所有实体成为类似可标记抽象类的子类更好的方法呢？其中标签实体将引用许多标签。
编辑:标签云只是一个示例，用来简化我遇到的问题。在我的场景中，关系应该是OneToMany，其中标记不能被重用。
谢谢
浏览 0提问于2010-05-27得票数 5
我已经创建了一个具有MySQL后端的Spring Boot JPA微服务。我的模型中有两个简单的实体:用户和技能。这些用来代表我的组织内的技能基础。每个用户可能有许多技能，因此我使用了一对多连接来建模，并可以成功地将技能分配给用户。在我的数据库中，我可以看到JPA已经创建了一个users_skills表来实现这一点。 然而，我现在正在苦苦挣扎，因为对于用户拥有的每一项技能，都需要指定一个经验级别(例如，基础、高级、专家)，而我不确定如何实现这一点。我不确定“级别”是否应该只是技能实体中的枚举类型，或者它应该是一个独立的实体？我是否可以配置JPA，使其生成一个表示这种三向关系的users_sk
浏览 9提问于2019-06-07得票数 0
回答已采纳
2回答
例如，我有这个实体：
public class MessageComment implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
@Column
private String creator;
private List<OtherComments> otherComments = new ArrayList<OtherComments>();
}
在这段代码中，notwhing用
浏览 1提问于2014-03-31得票数 0
我第一次使用实体继承，并坚持在另一个MappedSuperClass中使用MappedSuperClass作为集合。 我有两个相似的实体集，它们必须将数据保存到数据库中的不同表中。但由于业务逻辑完全相同，所以我希望对这些实体使用基类，因此这些基类可以在公共JPA存储库(@NoRepositoryBean)中使用。 @MappedSuperClass
class Classroom {
String std;
}
@MappedSuperClass
class School {
String name;
@OneToMany //ERROR
Set<
浏览 27提问于2021-08-16得票数 0
我在数据库里有12张桌子。所有的表都有相同的列和相同的关系。
所以我用JPA写了代码。
@MappedSuperclass
public class BaseAddress {
... properties and relations (@ManyToOne / @OneToMany)
}
@Entity
public class Address1 extends BaseAddress {
// has no code. properties and relations are inherited.
}
@Entity
public class Address2 extends B
浏览 1提问于2014-02-04得票数 0
回答已采纳
1回答
我需要一些帮助JPA自我参照关系。我认为有些东西我还没有正确定义。
我有一个名为ItemEntity的JPA实体bean。有两种类型的项目。父项和子项。父项可以有多个子项，子项只有一个父项。实际上，这是一个ManyToOne / OneToMany JPA自引用关系。
在我的数据库里，项目表是这样的.
item_no,parent_item_no,item_description
111,null,This is my parent item
222,111,This is my child item
因此，在我的java程序中，当我在项目111上调用itemEntity.getChildre
浏览 2提问于2013-12-13得票数 5
1回答
日安，
我已经开始了我的第一个基于客户关系管理应用程序的JPA项目，我在理解ManyToOne和OneToMany注释的正确使用方面遇到了一些困难。例如，假设我有两个类；它们将是帐户类和用户类：
public class Account {
@OneToMany
private Set<User> userList = new HashSet<User>();
和
public class User {
@ManyToOne
private Account account;
我如何正确诠释多对一和一对多的关系？我已经试着阅读了这些文档，但仍然无法找到正确的结论。
谢
浏览 4提问于2014-04-14得票数 0
回答已采纳
2回答
我有一个Entity类，它包含一些原始数据类型，并包含一些具有OneToMany关系和ManyToOne关系的对象集合。
当我使用JPA Criteria获取数据时，我得到了所有的数据，但是我想使用JPA Criteria where clause过滤结果，我可以应用于它的原始数据类型和它的工作效率，我必须在具有OneToMany关系的对象集合中应用where子句，有些对象有ManyToOne关系，但是在这种情况下如何应用where子句，您能告诉我吗？
浏览 4提问于2015-10-12得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
