十、ManyToOne的实现

最新推荐文章于 2024-11-17 23:14:02 发布
原创 最新推荐文章于 2024-11-17 23:14:02 发布 · 1.1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#integer #accessor #null #string #float #class

本文详细介绍了如何使用BDBJE对包含OneToMany关系的数据进行存储，包括部门和员工的关系建模、索引创建、实体获取及更新等操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

BDB JE对复杂数据的储存 (三)、ManyToOne关系的存储

 


部门类:

 @Entity

public class Department {

    @PrimaryKey

    int departmentId;

    @SecondaryKey(relate=Relationship.ONE_TO_ONE)

    String departmentName;

    String location;

    public Department(int departmentId,String departmentName,String location){

       this.departmentId=departmentId;

       this.departmentName=departmentName;

       this.location=location;

    }

    Department(){ }

}

员工类:

@Entity

public class Employee {

    @PrimaryKey

    int employeeId;

    @SecondaryKey(relate=Relationship.MANY_TO_ONE)

    String employeeName;

    @SecondaryKey(relate=Relationship.MANY_TO_ONE)

    float salary;

@SecondaryKey

(relate=Relationship.MANY_TO_ONE,relatedEntity=Employee.class,onRelatedEntityDelete=DeleteActio

n.NULLIFY)

    Integer managerId;

@SecondaryKey

(relate=Relationship.MANY_TO_ONE,relatedEntity=Department.class,onRelatedEntityDelete=DeleteAct

ion.CASCADE)

    Integer departmentId;

    String address;

    public Employee(int employeeId,String employeeName,float salary,Integer managerId,int

departmentId,String address){

       this.employeeId=employeeId;

       this.employeeName=employeeName;

       this.salary=salary;

       this.managerId=managerId;

       this.departmentId=departmentId;

       this.address=address;

    }

    public Employee(){}

}

操作类:

public class Accessor {

    PrimaryIndex<Integer, Employee> employeeById;

    SecondaryIndex<String, Integer, Employee> employeeByName;

    SecondaryIndex<Float, Integer, Employee> employeeBySalary;

    SecondaryIndex<Integer, Integer, Employee> employeeByManagerId;

    SecondaryIndex<Integer, Integer, Employee> employeeByDepartmentId;

    PrimaryIndex<Integer, Department> departmentById;

    SecondaryIndex<String, Integer, Department> departmentByName;

    public Accessor(EntityStore store) throws DatabaseException{

       employeeById=store.getPrimaryIndex(Integer.class, Employee.class);

       employeeByName=store.getSecondaryIndex(employeeById, String.class, "employeeName");

       employeeBySalary=store.getSecondaryIndex(employeeById, Float.class, "salary");

       employeeByManagerId=store.getSecondaryIndex(employeeById, Integer.class, "managerId");

       employeeByDepartmentId=store.getSecondaryIndex(employeeById, Integer.class,

"departmentId");

       departmentById=store.getPrimaryIndex(Integer.class, Department.class);

       departmentByName=store.getSecondaryIndex(departmentById, String.class,

"departmentName");

    }

}

public class test {

 

    public static void main(String[] args) {

       EnvironmentConfig envConfig = new EnvironmentConfig();

       envConfig.setAllowCreate(true);

       envConfig.setTransactional(true);

       try {

           Environment env = new Environment(new File("d://bdb//many2oneje2"),

                  envConfig);

           StoreConfig storeConfig = new StoreConfig();

           storeConfig.setAllowCreate(true);

           storeConfig.setTransactional(true);

           EntityStore store = new EntityStore(env, "EmployeeStore",

                  storeConfig);

           Accessor dao = new Accessor(store);

           Transaction txn = env.beginTransaction(null, null);

 

             dao.departmentById.put(txn,new

             Department(1,"CEO Office","North America"));

             dao.departmentById.put(txn,new Department(2,"Sales","EURO"));

             dao.departmentById.put(txn,new Department(3,"HR","MEA"));

             dao.departmentById.put(txn,new

             Department(4,"Engineering","APAC"));

             dao.departmentById.put(txn,new Department(5,"Support","LATAM"));

             dao.employeeById.put(txn,new

             Employee(1,"Abraham Lincoln",1000.0f,

             null,1,"Washington D.C.,USA")); dao.employeeById.put(txn,new

             Employee(2,"Augustus",9000.0f,1,2,"Rome,Italy"));

             dao.employeeById.put(txn,new

             Employee(3,"Cleopartra",7000.0f,1,3,"Cairo,Egypt"));

             dao.employeeById.put(txn,new

             Employee(4,"Confucius",7500.0f,1,4,"Beijing,China"));

             dao.employeeById.put(txn,new

             Employee(5,"Toussaint Louverture",6800.0f

             ,1,5,"Port-au-prince,Haiti")); dao.employeeById.put(txn,new

             Employee(6,"William Shakespeare",7300.0f,2,2,"London,Englad"));

             dao.employeeById.put(txn,new

             Employee(7,"Vistor Hugo",7000.0f,2,2,"paris,France"));

             dao.employeeById.put(txn,new

             Employee(8,"Yitzhak Rabin",6500.0f,3,3,"Jerusalem,Israel"));

             dao.employeeById.put(txn,new

             Employee(9,"Nelson Rolihlahla Mandela"

             ,6400.0f,3,3,"Cape Town,South Africa"));

             dao.employeeById.put(txn,new

             Employee(10,"Mei ji Emperor",6600.0f,4,4,"Tokyo,Japan"));

             dao.employeeById.put(txn,new

             Employee(11,"Mohandas Karamchand Gandhi"

             ,7600.0f,4,4,"New Delhi,India")); dao.employeeById.put(txn,new

             Employee

             (12,"Ayrton Senna da Silva",5600.0f,5,5,"Brasilia ,Brasil"));

             dao.employeeById.put(txn,new

             Employee(13,"Ronahlinho De Assis Moreiar"

             ,6100.0f,5,5,"Brasilia ,Brasil"));

           

 

           // 通过游标得到实体

           System.out.println("得到部门的信息，其按ID排序,升序");

           EntityCursor<Department> deptcursor = dao.departmentById.entities(

                  txn, null);

           for (Department dept : deptcursor) {

              System.out.println(dept.departmentId + "     "

                     + dept.departmentName);

           }

           deptcursor.close();

 

           System.out.println("得到部门的信息，其按部门名称排序,升序");

           deptcursor = dao.departmentByName.entities(txn, null);

           for (Department dept : deptcursor) {

              System.out.println(dept.departmentId + "     "

                     + dept.departmentName);

           }

           deptcursor.close();

           System.out.println("******************************");

           // 通过get得到实体

           System.out.println("得到部门id为1的信息");

           Department d = dao.departmentById.get(txn, 1, LockMode.DEFAULT);

           System.out.println(d.departmentId + "   " + d.departmentName);

           System.out.println("--------/////////////////////------");

           // 通过关键字

           System.out.println("得到部门名称为sales的信息");

           d = dao.departmentByName.get(txn, "Sales", LockMode.DEFAULT);

           if (d != null) {

              System.out.println(d.departmentId + "   " + d.departmentName);

           }

           System.out.println("-------------------");

           // 限制游标的范围

           // 第一个参数代表为开始位置,按ACSII码查询，第二个参数代表(trur:>= false:>)

           // 第三个参数代表为结束位置,按ACSII码结束，其为一个字符的比较，第四个为(true：<=

false:<)

           deptcursor = dao.departmentByName.entities(txn, "C", true, "Sales",

                  true, null);

           for (Department dept : deptcursor) {

              System.out.println(dept.departmentName);

           }

           deptcursor.close();

 

           System.out.println("----------------------------");

 

           deptcursor = dao.departmentByName.subIndex("Sales").entities(txn,

                  null);

           for (Department dept : deptcursor) {

              System.out.println(dept.departmentId + "    "

                     + dept.departmentName);

           }

           deptcursor.close();

 

           System.out

                  .println("得到部门名为Sales,其ID为2的部门信息(如果get中为其他的值的时候都会报

错,因为部门名为Sales的部门ID为2)");

           d = dao.departmentByName.subIndex("Sales").get(txn, 2,

                  LockMode.DEFAULT);

           if (d != null) {

              System.out.println(d.departmentId + "   " + d.departmentName);

           }

           // dao.departmentById.delete(1);

           System.out

                  .println("////////////////////////////////////////////////");

           // 得到第一个部门的名称

           d = dao.departmentById.get(txn, 1, LockMode.DEFAULT);

           System.out.println(d.departmentName);

           System.out

                  .println("************************************************");

           // 得到部门ID为1的第一个员工的名字

           System.out.println("得到部门ID为2的第一个员工的名字:");

           System.out.println(dao.employeeByDepartmentId.get(txn, 2,

                  LockMode.DEFAULT).employeeName);

           System.out.println("+++++++++++++++++++++++++++++++++++++");

 

           System.out.println("查询工资在6000-8000之间的所有员工;");

           EntityCursor<Employee> ecursor = dao.employeeBySalary.entities(txn,

                  new Float(6000), true, new Float(8000), true, null);

           for (Employee e : ecursor) {

               System.out.println(e.employeeId + "    " + e.salary);

           }

           ecursor.close();

           System.out.println("-------------------");

           // 得到上司的编号为2的第一个员工的名称

           System.out.println("得到上司的编号为2的第一个员工的名称:");

           System.out.println(dao.employeeByManagerId.get(txn, 2,

                  LockMode.DEFAULT).employeeName);

           System.out

                  .println("------------------------------------------------------------------

---");

 

           // 查询公司的所有的员工

           System.out.println("查询公司的所有的员工:");

           System.out.println("编号    " + "名称" + "    " + "工资" + "   " + "地址"

                  + "      " + "部门ID" + "   " + "上司ID");

           EntityCursor<Employee> employeeCursor = dao.employeeById.entities(

                  txn, null);

 

           for (Employee e : employeeCursor) {

              System.out.println(e.employeeId + "  " + e.employeeName + " "

                     + e.salary + " " + e.address + "   " + e.departmentId

                     + "   " + e.managerId);

           }

           employeeCursor.close();

           System.out.println("---------------------");

           // 查询上司编号为1，并且工作为7000.0f的员工

           System.out.println("查询上司编号为1，并且工作为7000.0f的员工:");

 

           EntityJoin<Integer, Employee> entityJoin = new EntityJoin(

                  dao.employeeById);

           entityJoin.addCondition(dao.employeeByManagerId, 1);

           entityJoin.addCondition(dao.employeeBySalary, 7000.0f);

 

           ForwardCursor<Employee> c = entityJoin.entities(txn, null);

           for (Employee e : c) {

              System.out.println(e.employeeId + "   " + e.employeeName

                     + "   " + e.salary + "      " + e.managerId);

           }

           c.close();

           System.out.println("===========================================");

 

           // 联合查询（同一部门中的所有人员）

           System.out.println("部门名为Support中的所有人员");

           Department department = dao.departmentByName.get(txn, "Support",

                  LockMode.DEFAULT);

           if (department != null) {

              EntityCursor<Employee> ec = dao.employeeByDepartmentId

                     .subIndex(department.departmentId).entities(txn, null);

 

              for (Employee emp : ec) {

                  System.out.println(emp.employeeId + "   "

                         + emp.employeeName + "   " + emp.address);

              }

              ec.close();

           }

           System.out.println("相应的部门中所有员工显示:");

           EntityCursor<Department> deptc = dao.departmentById.entities(txn,

                  null);

           for (Department dd : deptc) {

              EntityCursor<Employee> eec = dao.employeeByDepartmentId

                     .subIndex(dd.departmentId).entities(txn, null);

              for (Employee emp : eec) {

                  System.out.println(emp.employeeId + "   "

                         + emp.employeeName + "   " + emp.address + "   "

                         + dd.departmentName);

              }

              eec.close();

           }

           deptc.close();

           System.out

                  .println("删除部门名为:Support,由于用到了CASCADE,在删除部门时，会把对应的部门

里的员工也会删除掉");

           deptc = dao.departmentById.entities(txn, null);

           for (Department dd : deptc) {

              if (dd.departmentName.trim().equals("Support")) {

                  // 最好用游标来进行删除和修改的操作

                  deptc.delete();

              }

              if (dd.departmentName.trim().equals("Sales")) {

                  dd.departmentName = dd.departmentName.toUpperCase();

                  deptc.update(dd);

              }

           }

           deptc.close();

           System.out.println("相应的部门中所有员工显示:");

           deptc = dao.departmentById.entities(txn, null);

           for (Department dd : deptc) {

              EntityCursor<Employee> eec = dao.employeeByDepartmentId

                     .subIndex(dd.departmentId).entities(txn, null);

              for (Employee emp : eec) {

                  System.out.println(emp.employeeId + "   "

                         + emp.employeeName + "   " + emp.address + "   "

                         + dd.departmentName);

              }

               eec.close();

           }

           deptc.close();

           store.close();

           txn.commit();

           env.close();

       } catch (Exception e) {

           e.printStackTrace();

       }

    }

}

 

Java 开发：利用 Hibernate 实现分页查询
AI开发架构师
04-30 990
本文旨在为Java开发者提供使用Hibernate实现高效分页查询的全面指南。Hibernate分页的核心API不同数据库的分页语法差异处理性能优化策略与Spring框架的集成大数据量场景下的特殊处理文章首先介绍Hibernate分页的基础知识，然后深入探讨实现细节和优化策略。随后提供实际代码示例和性能分析，最后讨论高级主题和未来发展趋势。: 对象关系映射，将数据库表与Java对象进行映射的技术分页查询(Pagination): 将大数据集分成多个小部分(页)进行查询和显示的技术。
Spring Boot实现密码策略强制：提升账户安全性
最新发布
专注Java开发与国产数据库技术分享，涵盖达梦DM8/OceanBase/GaussDB核心原理与实战，兼及DeepSeek大模型部署、YOLOv11训练等AI技术，为开发者提供从基础到进阶的技术干货。
08-02 1040
摘要 本文介绍了密码策略的定义、重要性及在Spring Boot中的实现方法。密码策略通过复杂度要求、有效期限制等要素防御暴力破解和凭证填充攻击，符合GDPR等安全标准。Spring Security提供完整的密码管理支持，包括PasswordEncoder接口和认证流程。实现步骤包括：初始化项目、设计用户实体、配置密码编码器（推荐BCrypt），并使用Passay库实施密码复杂度验证（长度、字符多样性、黑名单等规则）。文章提供了代码示例和配置建议，帮助开发者构建安全的密码认证系统。
Entity Bean (3) : 一对多关系[转]
Tomson Xu
07-23 2677
 知识点：双向一对多关系，一是关系维护端（owner side），多是关系被维护端（inverse side）。在关系被维护端需要通过@JoinColumn建立外键列指向关系维护端的主键列。  publicclass Order implements Serializable {    privateSet orderItems = new HashSet();      
【转】转载：@ManyToOne　
iteye_11813的博客
04-05 690
  @ManyToOne注解的这端，是多端 1.在注释@ManyToOne(cascade=CascadeType.REFRESH,optional=true)中将属性optional设置为true，这可以使得即使外键为空时仍可以向表中添加数据。 2.假设Person和Book是一对多的关系，其中Person的成员变量为： private Integer personId; priv...
manytoone
我行我能
06-23 393
<br />用注解配置好两张表的关系<br />查询两张表：<br /> <br />hql:select e from Yjkcb as e left join e.yjbmb as b
@ManyToOne
Scalaaaaaa的博客
07-08 5867
这个注解写在哪？ 肯定是写在getter上 写在哪个Entity里，哪个Entity就是Many 注解参数：（fetch = FetchType.LAZY, cascade = { CascadeType.ALL }, targetEntity = Student.class, mappedBy = "classes") fetch = FetchType. LAZY , cascad
Hibernate入门-搭建框架实现基本的增删改查（源码）
10-04
2. **级联操作**：设置`@OneToMany`、`@ManyToOne`等关联关系的`cascade`属性，可以在操作主体对象时自动处理关联对象。 **十、缓存机制** Hibernate 提供了第一级缓存（Session级别的）和第二级缓存...
.NET ORM 仓储层必备的功能介绍之 FreeSql Repository 实现篇
dotnetCore的博客
05-06 1421
FreeSql.Repository 除了 CRUD 还有很多实用性功能，不防耐下心花10分钟看完。支持 .NetFramework4.0+、.NetCore、Xamarin、MAUI、Blazor、以及还有说不出来的运行平台，因为代码绿色无依赖，支持新平台非常简单。目前单元测试数量：6336+，Nuget下载数量：900K+。支持 MySql/SqlServer/PostgreSQL/Oracle/Sqlite/Firebird/达梦/神通/人大金仓/翰高/MsAccess Ado.net 实现包，以及
第二百九十节 JPA教程 - JPA查询左连接示例
2301_78772942的博客
10-21 931
第二百九十节 JPA教程 - JPA查询左连接示例
ManyToOne 详解
tyust512的专栏
06-09 6275
一 意义: 用来定义多对于一的表关联关系 (多指的是本实体的外键字段,可以有多个重复的值, 一指的是被关联的实体的主键, 只能是一个值) 二  他自带的属性(全部可选) 1 cascade 实例: @ManyToOne(cascade = {CascadeType.PERSIST, CascadeType.Remove, CascadeType.MERGE, CascadeT
ManyToOne问题
scychina的专栏
05-08 840
对于hibernate注释方式些ManyToOne和OneToMany 的时候，如果你要保存Many 一方但是不向保存One的一方可以尝试在之前设置的时候把 One的一方只设置一个ID值 在dao层可以save many的一方  ！！！！记下来下次遇到不会忘   ！！！！ 如果出现这个异常java.lang.NullPointerException com.examonline.ac
spring mvc的@manytoone
anzhuangguai的专栏
10-21 938
manytoone注释，在一个实体类中使用另一个实体类（类似嵌套）使用时必须要加上。否则hibernate不知道应该怎么处理被嵌入的类。 例如 User类中包含一个Office类，而非office_id，此时对于Office类就需要加上这个注释。 参考 http://www.objectdb.com/api/java/jpa/ManyToOne
@OnoToMany,@ManyToOne,@ManayToMany
学而不思则罔 思而不学则殆
03-31 2585
mark： @OneToMany,@ManyToOne Blog地址： http://blog.youkuaiyun.com/gebitan505/article/details/22619175@ManyToMany Blog地址： http://www.cnblogs.com/ranger2016/p/3953053.html
hibernate——manytoone（单向）
archer的技术故事
06-25 953
hibernate——manytoone package com.xueyoucto.xueyou; import org.hibernate.annotations.*; import org.hibernate.annotations.CascadeType; import javax.persistence.*; import javax.persistence.Entity; imp
@ManyToOne和@OneToMany
05-04 2318
ManyToOne:多对一、单向，不产生中间表，但可以用@JoinColumn(name=" ")来指定生成外键的名字，外键在多的一方表中产生。 OneToMany:一对多、单向，会产生中间表，此时可以用@OneToMany@JoinColumn(name=" ") 避免产生中间表，并且指定了外键的名字，同样，外键在多的表中存在着。 OneToMany+ManyToOne双向（一起用）。如果不在@OneToMany中加mappedy属性就会产生中间表，此时，通常在@ManyToOne的注解下再填上注解@J.
（5）OneToMany单向、双向manytoone
FixedStar 的博客
11-12 2080
一、OneToMany单向 OneToMany说明是一个组知道有哪些成员，而成员不知道自己是哪个组（这是类层面的理解）。数据库方面还是多端（User）有外键属性。 若两个表中只写OneToMany,则必须写@JoinColumn(name=”groupId”)，否则hibernate会当成多对多建立中间表 Group（一端）/* * 一对多，即在一端加 * 并且不需要在多端加外键。 *
OneToMany 和 ManyToOne
jefferylong的博客
11-17 715
ManyToOne是外键的维护者它在数据库中定义外键列（如authorId用于指向关系的 “一” 侧。@OneToMany是关系的反向映射它没有单独的数据库列。它仅用作@ManyToOne的反向映射，表示 “一” 侧可以访问所有 “多” 侧的记录。relations必须手动加载TypeORM 默认不会加载关联字段，需在查询时指定relations。cascade选项允许保存或删除时级联操作（如在保存用户时自动保存其文章）。
转@OneToMany或@ManyToOne的用法-annotation关系映射篇（上)
weixin_30681121的博客
11-28 139
原文：http://blog.sina.com.cn/s/blog_6fef491d0100obdm.html 例如我们用一个例子来开启JPA的一对多和多对一的学习。 比如你去当当网上买书籍，当当网就给你一个订单。 通过上面的业务活动描述你可以分析得出：一个订单可以包含一个或多个订单项.那么我们将将订单和订单项设计关系为(1:N)一对多的关系(排除0)。得出关系我们就使用J...
如何实现ManytoOne保存product集合
06-13
要实现 ManyToOne 关系并保存 Product 集合，可以按照以下步骤进行操作： 1. 定义两个实体类，一个是包含 Product 集合的实体类，另一个是 Product 实体类。 2. 在包含 Product 集合的实体类中，定义一个 ManyToOne 关系，指向 Product 实体类。 ``` @Entity public class Order { @Id private Long id; @OneToMany(mappedBy = "order") private List<Product> products; // ... } @Entity public class Product { @Id private Long id; @ManyToOne @JoinColumn(name = "order_id") private Order order; // ... } ``` 3. 在保存包含 Product 集合的实体类时，需要先保存 Product 实体类，然后再将 Product 对象添加到包含 Product 集合的实体类中，最后保存包含 Product 集合的实体类即可。具体代码如下： ``` Order order = new Order(); List<Product> products = new ArrayList<>(); Product product1 = new Product(); product1.setOrder(order); products.add(product1); Product product2 = new Product(); product2.setOrder(order); products.add(product2); order.setProducts(products); entityManager.persist(product1); entityManager.persist(product2); entityManager.persist(order); ``` 这样就可以实现 ManyToOne 关系并保存 Product 集合了。注意，在保存实体类时，需要将所有关联的实体类都保存到数据库中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值