Hibernate学习之单向多对一映射

最新推荐文章于 2022-10-29 17:01:46 发布
最新推荐文章于 2022-10-29 17:01:46 发布
阅读量426 收藏
点赞数
分类专栏： hibernate 文章标签： hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mmh19891113/article/details/78553451
版权

一个customer对应多个order。在order中有一个customer的引用。

Customer类的java代码

package com.mamh.hibernate.demo.entities;

public class Customer {
    private Integer customerId;
    private String customerName;

    public Customer() {
    }

    public Customer(String name) {
        this.customerName = name;
    }


    public Integer getCustomerId() {
        return customerId;
    }

    public void setCustomerId(Integer customerId) {
        this.customerId = customerId;
    }

    public String getCustomerName() {
        return customerName;
    }

    public void setCustomerName(String customerName) {
        this.customerName = customerName;
    }
}

Order类的java代码

package com.mamh.hibernate.demo.entities;

public class Order {
    private Integer orderId;
    private String orderName;


    private Customer customer;

    public Integer getOrderId() {
        return orderId;
    }

    public void setOrderId(Integer orderId) {
        this.orderId = orderId;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public Customer getCustomer() {
        return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
}

Order类的映射文件，

<hibernate-mapping package="com.mamh.hibernate.demo.entities">

    <class name="Order" table="hb_order" schema="mage">
        <id name="orderId">
            <column name="hb_order_id" sql-type="int(11)"/>
            <generator class="native"/>
        </id>
        <property name="orderName" type="string">
            <column name="hb_order_name"/>
        </property>

        <!-- 映射多对一的关联关系 property不再试用这个多对一的关系了
               name是多这一端关联的那个一那一端属性名称
               class的类全名
               column是多的一端这边数据表的一个列名，一般是外键
        -->
        <many-to-one name="customer" class="Customer" column="customer_id"/>


    </class>
</hibernate-mapping>

Customer类的映射文件

<hibernate-mapping>

    <class name="com.mamh.hibernate.demo.entities.Customer" table="hb_customer" schema="mage">
        <id name="customerId">
            <column name="hb_customer_id" sql-type="int(11)"/>
            <generator class="native"/>
        </id>
        <property name="customerName" type="string">
            <column name="hb_customer_name"/>
        </property>
    </class>
</hibernate-mapping>

1.测试保存order和customer的方法

先保存customer，然后保存order。

    @Test
    public void testManyToOneSave(){

        Customer customer = new Customer("aa");

        Order order1 = new Order();
        order1.setOrderName("order 1");
        Order order2 = new Order();
        order2.setOrderName("order 2");

        order1.setCustomer(customer);
        order2.setCustomer(customer);

        //执行save操作

        //先保存customer，然后保存order。
        session.save(customer);

        session.save(order1);
        session.save(order2);
    }

先保存customer，然后保存order，这个会出现3条插入sql语句。这个是建议这样的顺序的。

Hibernate: 
    insert 
    into
        mage.hb_customer
        (hb_customer_name) 
    values
        (?)
Hibernate: 
    insert 
    into
        mage.hb_order
        (hb_order_name, customer_id) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        mage.hb_order
        (hb_order_name, customer_id) 
    values
        (?, ?)

如果是先保存order，然后再保存customer，情况由如何呢？

//执行save操作
//先保存order，然后保存customer。
session.save(order1);
session.save(order2);

session.save(customer);

如果是先保存order，然后再保存customer，能成功的。会出现3条insert语句，最后还有2条update语句。
这中情况就多了2条update语句。因为order表需要一个外键，先保存oder的是还不知道这个外键
customer是多少。后来保存好了customer，就知道customer ID了。最后会更新一些oder中的外键。
这样就多了2条update更新语句。这样多了2条语句效率就会低一些。

Hibernate: 
    insert 
    into
        mage.hb_order
        (hb_order_name, customer_id) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        mage.hb_order
        (hb_order_name, customer_id) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        mage.hb_customer
        (hb_customer_name) 
    values
        (?)
=destroy=
Hibernate: 
    update
        mage.hb_order 
    set
        hb_order_name=?,
        customer_id=? 
    where
        hb_order_id=?
Hibernate: 
    update
        mage.hb_order 
    set
        hb_order_name=?,
        customer_id=? 
    where
        hb_order_id=?

2.测试查询order和customer的方法

查询多的一端的一个对象，默认情况下，只查询了多的一端的对象，而没有查询关联的那一端的对象。
就是说查询Order对象，只得到了Order对象，而没有得到Customer对象。

    @Test
    public void testManyToOneGet(){
        Order order = (Order) session.get(Order.class, 1);
        System.out.println(order.getOrderName() + ":  "+order.getOrderId());
        //这里值用到了order对象的属性，没有用的customer的属性，所以不会发送取查询customer相关的sql语句的。
    }
Hibernate: //通过这个hibernate的sql输出我们看到没有去查询customer相关的。
    select
        order0_.hb_order_id as hb1_3_0_,
        order0_.hb_order_name as hb2_3_0_,
        order0_.customer_id as customer3_3_0_ 
    from
        mage.hb_order order0_ 
    where
        order0_.hb_order_id=?

order 1:  1

如果我们用到了customer的相关属性，例如获取order中的customer对象，
或者直接打印order对象 都是会发送查询customer表的sql语句的。

    @Test
    public void testManyToOneGet(){
        Order order = (Order) session.get(Order.class, 1);
        System.out.println(order);

        Customer customer = order.getCustomer();
        System.out.println(customer);
    }
Hibernate: 
    select
        order0_.hb_order_id as hb1_3_0_,
        order0_.hb_order_name as hb2_3_0_,
        order0_.customer_id as customer3_3_0_ 
    from
        mage.hb_order order0_ 
    where
        order0_.hb_order_id=?
Hibernate: 
    select
        customer0_.hb_customer_id as hb1_2_0_,
        customer0_.hb_customer_name as hb2_2_0_ 
    from
        mage.hb_customer customer0_ 
    where
        customer0_.hb_customer_id=?

System.out.println(order);的输出结果：      
Order{
    orderId=1, 
    orderName='order 1', 
    customer=Customer{
        customerId=1, 
        customerName='aa'
        }
}

System.out.println(customer);的输出结果：
Customer{
    customerId=1, 
    customerName='aa'
}

如果在查询customer对象的时候，有多的一端导航到一的一端时，若此时session被关闭，则
会发生一个LazyInitializationException异常

    @Test
    public void testManyToOneGet(){
        Order order = (Order) session.get(Order.class, 1);
        System.out.println(order.getOrderName() + ":  "+order.getOrderId());

        session.close();

        Customer customer = order.getCustomer();
        System.out.println(customer);
    }
Hibernate: 
    select
        order0_.hb_order_id as hb1_3_0_,
        order0_.hb_order_name as hb2_3_0_,
        order0_.customer_id as customer3_3_0_ 
    from
        mage.hb_order order0_ 
    where
        order0_.hb_order_id=?
order 1:  1
=destroy=

org.hibernate.LazyInitializationException: could not initialize proxy - no Session

    at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:149)
    at org.hibernate.proxy.AbstractLazyInitializer.getImplementation(AbstractLazyInitializer.java:195)
    at org.hibernate.proxy.pojo.javassist.JavassistLazyInitializer.invoke(JavassistLazyInitializer.java:185)
    at com.mamh.hibernate.demo.entities.Customer_$$_javassist_1.toString(Customer_$$_javassist_1.java)
    at java.lang.String.valueOf(String.java:2994)
    at java.io.PrintStream.println(PrintStream.java:821)
    at com.mamh.hibernate.demo.HibernateTest.testManyToOneGet(HibernateTest.java:61)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
    at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
    at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:26)
    at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:27)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
    at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
    at com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:47)
    at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242)
    at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)

获取order对象时，默认情况下，其关联的customer对象是一个代理对象！

3.测试更新order，customer对象

    @Test
    public void testManyToOneUpdate() {
        Order order = (Order) session.get(Order.class, 1);
        order.getCustomer().setCustomerName("new customer name");
    }
Hibernate: 
    select
        order0_.hb_order_id as hb1_3_0_,
        order0_.hb_order_name as hb2_3_0_,
        order0_.customer_id as customer3_3_0_ 
    from
        mage.hb_order order0_ 
    where
        order0_.hb_order_id=?
Hibernate: 
    select
        customer0_.hb_customer_id as hb1_2_0_,
        customer0_.hb_customer_name as hb2_2_0_ 
    from
        mage.hb_customer customer0_ 
    where
        customer0_.hb_customer_id=?
=destroy=
Hibernate: 
    update
        mage.hb_customer 
    set
        hb_customer_name=? 
    where
        hb_customer_id=?

4.测试删除order和customer

在不设定级联关系的情况下，且1这一端对象有n的对象在引用，不能直接删除。
也就是说customer 的id有在order中作为外键就不能删除这个customer。
要删除也是先把order中的删除完，然后在删除customer中的。

    @Test
    public void testManyToOneDelete() {
        Customer customer = (Customer) session.get(Customer.class, 1);
        session.delete(customer);
    }
Hibernate: 
    select
        customer0_.hb_customer_id as hb1_2_0_,
        customer0_.hb_customer_name as hb2_2_0_ 
    from
        mage.hb_customer customer0_ 
    where
        customer0_.hb_customer_id=?
=destroy=
Nov 17, 2017 2:51:23 PM org.hibernate.engine.jdbc.spi.SqlExceptionHelper logExceptions
WARN: SQL Error: 1451, SQLState: 23000
Hibernate: 
    delete 
    from
        mage.hb_customer 
    where
        hb_customer_id=?
Nov 17, 2017 2:51:23 PM org.hibernate.engine.jdbc.spi.SqlExceptionHelper logExceptions
ERROR: Cannot delete or update a parent row: a foreign key constraint fails (`mage`.`hb_order`, CONSTRAINT `FK1C0AD3C966B2F7AA` FOREIGN KEY (`customer_id`) REFERENCES `hb_customer` (`hb_customer_id`))
Nov 17, 2017 2:51:23 PM org.hibernate.engine.jdbc.batch.internal.BatchingBatch performExecution
ERROR: HHH000315: Exception executing batch [Cannot delete or update a parent row: a foreign key constraint fails (`mage`.`hb_order`, CONSTRAINT `FK1C0AD3C966B2F7AA` FOREIGN KEY (`customer_id`) REFERENCES `hb_customer` (`hb_customer_id`))]

org.hibernate.exception.ConstraintViolationException: Cannot delete or update a parent row: a foreign key constraint fails (`mage`.`hb_order`, CONSTRAINT `FK1C0AD3C966B2F7AA` FOREIGN KEY (`customer_id`) REFERENCES `hb_customer` (`hb_customer_id`))

    at org.hibernate.exception.internal.SQLStateConversionDelegate.convert(SQLStateConversionDelegate.java:128)
    at org.hibernate.exception.internal.StandardSQLExceptionConverter.convert(StandardSQLExceptionConverter.java:49)
    at org.hibernate.engine.jdbc.spi.SqlExceptionHelper.convert(SqlExceptionHelper.java:125)
    at org.hibernate.engine.jdbc.spi.SqlExceptionHelper.convert(SqlExceptionHelper.java:110)
    at org.hibernate.engine.jdbc.internal.proxy.AbstractStatementProxyHandler.continueInvocation(AbstractStatementProxyHandler.java:129)
    at org.hibernate.engine.jdbc.internal.proxy.AbstractProxyHandler.invoke(AbstractProxyHandler.java:81)
    at com.sun.proxy.$Proxy9.executeBatch(Unknown Source)
    at org.hibernate.engine.jdbc.batch.internal.BatchingBatch.performExecution(BatchingBatch.java:110)
    at org.hibernate.engine.jdbc.batch.internal.BatchingBatch.doExecuteBatch(BatchingBatch.java:101)
    at org.hibernate.engine.jdbc.batch.internal.AbstractBatchImpl.execute(AbstractBatchImpl.java:161)
    at org.hibernate.engine.jdbc.internal.JdbcCoordinatorImpl.executeBatch(JdbcCoordinatorImpl.java:162)
    at org.hibernate.engine.spi.ActionQueue.executeActions(ActionQueue.java:357)
    at org.hibernate.engine.spi.ActionQueue.executeActions(ActionQueue.java:280)
    at org.hibernate.event.internal.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:326)
    at org.hibernate.event.internal.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:52)
    at org.hibernate.internal.SessionImpl.flush(SessionImpl.java:1127)
    at org.hibernate.internal.SessionImpl.managedFlush(SessionImpl.java:325)
    at org.hibernate.engine.transaction.internal.jdbc.JdbcTransaction.beforeTransactionCommit(JdbcTransaction.java:101)
    at org.hibernate.engine.transaction.spi.AbstractTransactionImpl.commit(AbstractTransactionImpl.java:175)
    at com.mamh.hibernate.demo.HibernateTest.destroy(HibernateTest.java:315)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
    at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:33)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
    at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
    at com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:47)
    at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242)
    at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)
Caused by: java.sql.BatchUpdateException: Cannot delete or update a parent row: a foreign key constraint fails (`mage`.`hb_order`, CONSTRAINT `FK1C0AD3C966B2F7AA` FOREIGN KEY (`customer_id`) REFERENCES `hb_customer` (`hb_customer_id`))
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
    at com.mysql.cj.core.util.Util.handleNewInstance(Util.java:185)
    at com.mysql.cj.core.util.Util.getInstance(Util.java:168)
    at com.mysql.cj.core.util.Util.getInstance(Util.java:175)
    at com.mysql.cj.jdbc.exceptions.SQLError.createBatchUpdateException(SQLError.java:636)
    at com.mysql.cj.jdbc.PreparedStatement.executeBatchSerially(PreparedStatement.java:1734)
    at com.mysql.cj.jdbc.PreparedStatement.executeBatchInternal(PreparedStatement.java:1217)
    at com.mysql.cj.jdbc.StatementImpl.executeBatch(StatementImpl.java:1009)
    at com.mchange.v2.c3p0.impl.NewProxyPreparedStatement.executeBatch(NewProxyPreparedStatement.java:1723)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at org.hibernate.engine.jdbc.internal.proxy.AbstractStatementProxyHandler.continueInvocation(AbstractStatementProxyHandler.java:122)
    ... 37 more
Caused by: java.sql.SQLIntegrityConstraintViolationException: Cannot delete or update a parent row: a foreign key constraint fails (`mage`.`hb_order`, CONSTRAINT `FK1C0AD3C966B2F7AA` FOREIGN KEY (`customer_id`) REFERENCES `hb_customer` (`hb_customer_id`))
    at com.mysql.cj.jdbc.exceptions.SQLError.createSQLException(SQLError.java:533)
    at com.mysql.cj.jdbc.exceptions.SQLError.createSQLException(SQLError.java:513)
    at com.mysql.cj.jdbc.exceptions.SQLExceptionsMapping.translateException(SQLExceptionsMapping.java:115)
    at com.mysql.cj.jdbc.ConnectionImpl.execSQL(ConnectionImpl.java:1983)
    at com.mysql.cj.jdbc.PreparedStatement.executeInternal(PreparedStatement.java:1826)
    at com.mysql.cj.jdbc.PreparedStatement.executeUpdateInternal(PreparedStatement.java:2034)
    at com.mysql.cj.jdbc.PreparedStatement.executeBatchSerially(PreparedStatement.java:1712)
    ... 45 more


Process finished with exit code 255
「已注销」
关注
专栏目录
Hibernate学习：单向多对一关联 工程
09-08
Hibernate学习：单向多对一关联 工程
hibernate一对多关联映射学习小结
08-29
Hibernate一对多关联映射学习小结 Hibernate是一种流行的Java持久层框架，它提供了强大的对象关系映射（ORM）功能，能够将Java对象与关系数据库中表之间建立映射关系。Hibernate的关联映射是其核心功能之一，可以将...
一口一口吃掉Hibernate（四）——多对一单向关联映射
崔成龙 . 勇往直前
10-25 7996
Hibernate对于数据库的操作，全部利用面向对象的思维来理解和实现的。一般的单独表的映射，相信大家都没有问题，但是对于一些表之间的特殊关系，Hibernate提供了一些独特的方式去简化它。       今天就来说说多对一的关联映射。       数据库中有多对一的关系，Hibernate自然也有对象的多对一的关联关系。比如学生和班级，一名学生只属于一个班级，一个班级有多名学
hibernate单向多对一映射
红桃峰峰 的博客
07-15 468
在实际的开发中，数据库表之间的关系有很多都是多对一的关联关系，这种情况的业务，在hibernate中该怎么处理呢？今天我们就来学习一下hibernate的单向多对一映射关系。 新建一个java项目，名称为：08hibernate_many_to_one 项目结构如图： 需要的jar包和如何从hibernate官网获得，请参见《Hibernate环境搭建和配置》
Hibernate 单向 多对一
weixin_34054931的博客
03-21 82
近来回顾Hibernate，对于单/双向多对一和多对多一直是一个难点和不容易理解的地方，特此写博文以便回顾所用工具：eclipse luna、MySQL、windows7 先来说一下单向一对多，一对多，顾名思义，一个表中一条记录对应另一个表中的多条记录，如一个顾客可以有多个订单，而每一个订单只有一个顾客。这里就用顾客-订单建立持久化类模型和数据关联关系，...
hibernate单向多对一
weixin_43317111的博客
11-15 147
配置hibernate环境（https://blog.csdn.net/weixin_43317111/article/details/103078545） 实体类 package com.wd.pojo; public class Student { private Integer id; private String name; private Teacher tid;//注意映...
JSP开发之hibernate之单向多对一关联的实例
10-19
JSP开发结合Hibernate框架进行单向多对一关联映射的操作是一项在Web应用程序开发中常见的需求。本文将详细解读如何通过Hibernate实现这一功能，并通过实例给出具体的代码实现方法，从而帮助开发者理解和掌握在JSP...
hibernate 单向多对多关联映射练习
03-16
以上就是关于Hibernate单向多对多关联映射的基本介绍和实践。实际应用中，还需考虑性能优化、事务管理、懒加载等问题。通过不断的练习和学习，你可以更熟练地掌握这一重要功能，提升项目开发的效率和质量。
hibernate单向多对多映射(XML版)
05-05
本主题聚焦于"hibernate单向多对多映射"，特别是在XML配置文件中的实现。在这个过程中，我们将探讨多对多关系的原理，以及如何在Hibernate中通过XML配置文件来定义这种关系。 首先，我们需要理解多对多关系的概念。...
hibernate-----单向多对一
文天哥哥的博客
04-07 453
一、项目用到的包 下载地址：https://download.csdn.net/download/wwt819635881/11095021 二、新建一个java项目 在项目中新建一个lib文件夹，把要用到的包粘贴进去，右键build path------ add to build path 三、在src建立两个包，一个Entity,一个Test 目录结构： 四、实...
hibernate单向多对多映射(注解版)
05-05
hibernate单向多对多映射(注解版)
Hibernate错误及解决办法集合
05-17
本人做系统时遇到的一些Hibernate问题及解决方案。
使用Hibernate一些常见错误解决办法
11-22
使用Hibernate一些常见错误解决办法
Hibernate的单向多对一映射
AZHELL的博客
06-10 404
先要搞清楚什么是多对一。我们讲在班级-学生(高中时代，而不是大学时代)关系中，班级处于关系中one的位置，因为一个班级对应多个学生，所以学生处于many的位置。本篇文章也拿这个基本关系来做测试，看看在Hibernate中如何处理这种基本关系。 在此之前，我要声明一个事情，千万不要在数据库中使用SQL的关键字或者保留字。无论是什么数据库都最好不要这样做，因为它会给你带来无穷的麻烦，我亲身体会了实体...
Hibernate实现单向多对一
ahliu9613123的博客
12-22 99
一篇文章可以有多个作者，这就是一个简单的一对多关系。 首先配置pojo <mapping class="qdm.entity.manytoone.Article" /> <mapping class="qdm.entity.manytoone.Author" /> /*多对一中 “多”端的配置*/@Entity ...
Hibernate单向多对一映射
jingde528的博客
10-29 569
Hibernate单向多对一映射
hibernate单向多对一关联
thamsyangsw的专栏
05-04 751
应用场景：在电子购物模型中，一个顾客可以发出多个订单，而每个订单却只能属于一个顾客，现在要建立从订单到顾客的多对一的单向关联。Customer ：顾客类Order：订单类该多对一关系在javabean中表现为：    在Order类中有一个customer的顾客属性；在Customer中没有Order的信息，不建立从Customer到Order的关联该多对一关系在数据库表现
Hibernate学习笔记----单向多对一
太匆匆
07-21 817
在我们以前的数据库设计中，设计表就不是一件轻松的事情。多种事物之间往往都是有这样那样的关系的。那怎样设计表格，才能既将事情描述明白，又能使数据库设计的比较合理呢？那里我们提供了好多规范，好多约束来满足这些事情。在hibernate中，通过对象来创建表，当然也需要有一些东西来维护各个对象之间的关系，以创建出合适的表。这个东西就是映射。通过映射，可以轻松的将对象间的关系表述的非常清楚明白。对象间关系搞
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值