Nhibernate学习起步之many-to-one篇

最新推荐文章于 2024-07-01 08:57:56 发布
最新推荐文章于 2024-07-01 08:57:56 发布
阅读量1.6k 收藏
点赞数
分类专栏： NHibernate 文章标签： null user session class hibernate 测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kybd2006/article/details/1733321
版权
1.     

通过进一步学习nhibernate基础知识，在实现单表CRUD的基础上，实现两表之间one-to-many的关系.

2.     开发环境+必要准备

开发环境: windows 2003,Visual studio .Net 2005,Sql server 2005 developer edition

必要准备: 学习上篇文章单表操作   

3) 更改User.cs,在User里面添加SalaryList属性：4）修改User.hbm.xml，加入bag节点
5）编写类Salary的映射文件:Salary.hbm.xml 

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2">
  <class name="NhibernateSample1.Salary,NhibernateSample1" table="Salary" lazy="false">
    <id name="Id" column="Id" unsaved-value="0">
      <generator class="native" />
    </id>
    <property name="Year" column="Year" type="Int32" not-null="true"></property>
    <property name="Month"  column="Month"  type="Int32" not-null="true"></property>
    <property name="Envy"  column="Envy"  type="Int32" not-null="true"></property>
    <property name="Money"  column="Money"  type="Decimal" not-null="true"></property>
    <many-to-one name="Employee" column="Uid" not-null="true"></many-to-one>
  </class>
</hibernate-mapping>

6）编写CRUD类 
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
using NHibernate;
using NHibernate.Cfg;
using NHibernate.Tool.hbm2ddl;

namespace NhibernateSample1
{
    public  class UserSalaryFixure
    {
        private ISessionFactory _sessions; 
        public void Configure()
        {
            Configuration cfg = GetConfiguration();      
            _sessions = cfg.BuildSessionFactory();
        }
        Configuration GetConfiguration()
        {
            string cfgPath = @"E:/my project/nhibernate study/simle 1/NHibernateStudy1/NhibernateSample1/hibernate.cfg.xml";
            Configuration cfg = new Configuration().Configure(cfgPath);
            return cfg;
        }
        public void ExportTables()
        {
            Configuration cfg = GetConfiguration();           
            new SchemaExport(cfg).Create(true, true);
        }
        public User CreateUser(String name,string pwd)
        {
            User u = new User();
            u.Name = name;
            u.Pwd = pwd;
            u.SalaryList = new ArrayList();

            ISession session = _sessions.OpenSession();

            ITransaction tx = null;

            try
            {
                tx = session.BeginTransaction();
                session.Save(u);
                tx.Commit();
            }
            catch (HibernateException e)
            {
                if (tx != null) tx.Rollback();
                throw e;
            }
            finally
            {
                session.Close();
            }

            return u;
        }
        public Salary CreateSalary(User u, int year,int month,int envy,decimal money)
        {
            Salary item = new Salary();
            item.Year = year;
            item.Money = money;
            item.Envy = envy;
            item.Month = month;
            item.Employee = u;
            u.SalaryList.Add(item);
            ISession session = _sessions.OpenSession();
            ITransaction tx = null;

            try
            {
                tx = session.BeginTransaction();
                session.Update(u);
                tx.Commit();
            }
            catch (HibernateException e)
            {
                if (tx != null) tx.Rollback();
                throw e;
            }
            finally
            {
                session.Close();
            }
            return item;
        }
        public Salary CreateSalary(int uid,int year, int month, int envy, decimal money)
        {
            Salary item = new Salary();
            item.Year = year;
            item.Money = money;
            item.Envy = envy;
            item.Month = month;
            
            ISession session = _sessions.OpenSession();
            ITransaction tx = null;
            try
            {
                tx = session.BeginTransaction();
                User u = (User)session.Load(typeof(User), uid);
                item.Employee = u;
                u.SalaryList.Add(item);
                tx.Commit();
            }
            catch (HibernateException e)
            {
                if (tx != null) tx.Rollback();
                throw e;
            }
            finally
            {
                session.Close();
            }
            return item;
        }
        public Salary GetSalary(int salaryID)
        {
            ISession session = _sessions.OpenSession();
            ITransaction tx = null;
            try
            {
                tx = session.BeginTransaction();
                Salary item = (Salary)session.Load(typeof(Salary),
                    salaryID);               
                tx.Commit();
                return item;
            }
            catch (HibernateException e)
            {
                if (tx != null) tx.Rollback();
                return null;
            }
            finally
            {
                session.Close();
            }
            return null;
        }
        public User GetUser(int uid)
        {
            ISession session = _sessions.OpenSession();
            ITransaction tx = null;
            try
            {
                tx = session.BeginTransaction();
                User item = (User)session.Load(typeof(User),
                    uid);
                tx.Commit();
                return item;
            }
            catch (HibernateException e)
            {
                if (tx != null) tx.Rollback();
                return null;
            }
            finally
            {
                session.Close();
            }
            return null;
        }
        public void UpdateSalary(int salaryID, decimal money)
        {
            ISession session = _sessions.OpenSession();
            ITransaction tx = null;
            try
            {
                tx = session.BeginTransaction();
                Salary item = (Salary)session.Load(typeof(Salary),
                    salaryID);
                item.Money = money;
                tx.Commit();
            }
            catch (HibernateException e)
            {
                if (tx != null) tx.Rollback();
                throw e;
            }
            finally
            {
                session.Close();
            }
        }

        public void Delete(int uid)
        {
            ISession session = _sessions.OpenSession();
            ITransaction tx = null;
            try
            {
                tx = session.BeginTransaction();
                Salary item = session.Load(typeof(Salary), uid) as Salary; ;
                session.Delete(item);
                tx.Commit();
            }
            catch (HibernateException e)
            {
                if (tx != null) tx.Rollback();
                throw e;
            }
            finally
            {
                session.Close();
            }
        }

    }
}

7) 编写单元测试类：UnitTest1.cs 
using System;
using System.Text;
using System.Collections.Generic;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using NhibernateSample1;

namespace TestProject1
{
    /**//// <summary>
    /// UnitTest1 的摘要说明
    /// </summary>
    [TestClass]
    public class UnitTest1
    {
        public UnitTest1()
        {
            //
            // TODO: 在此处添加构造函数逻辑
            //
        }
        NhibernateSample1.UserSalaryFixure usf = new UserSalaryFixure();
        其他测试属性#region 其他测试属性
        //
        // 您可以在编写测试时使用下列其他属性:
        //
        // 在运行类中的第一个测试之前使用 ClassInitialize 运行代码
        // [ClassInitialize()]
        // public static void MyClassInitialize(TestContext testContext) { }
        //
        // 在类中的所有测试都已运行之后使用 ClassCleanup 运行代码
        // [ClassCleanup()]
        // public static void MyClassCleanup() { }
        //
        // 在运行每个测试之前使用 TestInitialize 运行代码 
        // [TestInitialize()]
        // public void MyTestInitialize() { }
        //
        // 在运行每个测试之后使用 TestCleanup 运行代码
        // [TestCleanup()]
        // public void MyTestCleanup() { }
        //
        #endregion

        [TestMethod]
        public void Test1()
        {
            usf.Configure();
            usf.ExportTables();
            User u = usf.CreateUser(Guid.NewGuid().ToString(), "ds");
            Assert.IsTrue(u.Id>0);
            Salary s = usf.CreateSalary(u, 2007, 3, 1, (decimal)8000.00);
            Assert.IsTrue(s.Id > 0);
            Salary s1 = usf.CreateSalary(u.Id, 2007, 3, 1, (decimal)7500);
            Assert.IsTrue(s1.Id>0);
            usf.UpdateSalary(s1.Id, (decimal)6000);
            s1 = usf.GetSalary(s1.Id);
            Assert.IsTrue(s1.Money == (decimal)6000);
            usf.Delete(s1.Id);
            s1 = usf.GetSalary(s1.Id);
            Assert.IsNull(s1);
            User u1 = usf.GetUser(1);
            Assert.IsTrue(u1.SalaryList.Count>0);
        }

    }
}


加载测试元数据，直到Test()通过。


源码下载

总结：通过进一步学习nhiberate，发现ORM框架真是非常强大。今天先到这里。明天继续。

 

private System.Collections.IList _salaryList;
/**//// <summary>
/// 工资列表
/// </summary>
public System.Collections.IList SalaryList
{
    get
    {
        return _salaryList;
    }
    set
    {
        _salaryList = value;
    }
}

 

3． 对上篇文章中部分解释

 1）在User.hbm.xml中class节点中有一个lazy的属性，这个属性用于指定是否需要延迟加载（lazy loading），在官方文档中称为:lazy fecting.可以说延迟加载是nhibernate最好的特点，因为它可以在父类中透明的加载子类集合，这对于many-to-one的业务逻辑中，真是方便极了。但是有些时候，父类是不需要携带子类信息的。这时候如果也加载，无疑对性能是一种损失。在映射文件的class节点中可以通过配置lazy属性来指定是否支持延迟加载，这就更灵活多了。 

 2) 在User.hbm.xml中generate节点，代表的是主键的生成方式，上个例子中的”native”根据底层数据库的能力选择identity,hilo,sequence中的一个，比如在MS Sql中，使我们最经常使用的自动增长字段，每次加1. 

3) 在NHibernateHelper.cs中，创建Configuration对象的代码：new Configuration().Configure(@"E:/myproject/nhibernatestudy/simle1/NHibernateStudy1/NhibernateSample1/hibernate.cfg.xml")；因为我是在单元测试中调试，所以将绝对路径的配置文件传递给构造函数。如果在windows app或者web app可以不用传递该参数。 

4． 实现步骤

1）确定实现的业务需求：用户工资管理系统

2) 打开上篇文章中的NHibernateStudy1解决方案。向项目NhibernateSample1添加类Salary;代码如下

using System;
using System.Collections.Generic;
using System.Text;

namespace NhibernateSample1
{
    public partial class Salary
    {
        int _id;
        User _user;
        int _year;
        int _month;
        int _envy;
        decimal _money;
        /**//// <summary>
        /// 工资编号
        /// </summary>
        public virtual int Id
        {
            get
            {
                return _id;
            }
            set
            {
                _id = value;
            }
        }
        /**//// <summary>
        /// 雇员
        /// </summary>
        public virtual User Employee
        {
            get
            {
                return _user;
            }
            set
            {
                _user = value;
            }
        }
        /**//// <summary>
        /// 年度
        /// </summary>
        public int Year
        {
            get
            {
                return _year;
            }
            set
            {
                _year = value;
            }
        }
        /**//// <summary>
        /// 月份
        /// </summary>
        public int Month
        {
            get
            {
                return _month;
            }
            set
            {
                _month = value;
            }
        }
        /**//// <summary>
        /// 季度
        /// </summary>
        public int Envy
        {
            get
            {
                return _envy;
            }
            set
            {
                _envy = value;
            }
        }
        /**//// <summary>
        /// 工资
        /// </summary>
        public decimal Money
        {
            get
            {
                return _money;
            }
            set
            {
                _money = value;
            }
        }
    }
}



<bag name="SalaryList" table="Salary" inverse="true" lazy="true" cascade="all">
	<key column="Id"/>
	<one-to-many class="NhibernateSample1.Salary,NhibernateSample1"></one-to-many>
</bag>

学习目的:
kybd2006
关注
专栏目录
Hibernate：many-to-one（多对一）关联映射详解
SirouW的博客
09-02 3962
理解多对一映射，并分3种情况，对many-to-one在Hibernate中的应用进行探索。
Hibernate：many-to-many（多对多）关联映射详解
SirouW的博客
09-05 1562
多对多关联映射的实现和使用
(4)Hibernate中的many-to-one和one-to-many关系
03-17
NULL 博文链接：https://zhouxianglh.iteye.com/blog/569471
Nhibernate学习起步之many-to-one篇（转）
weixin_30445169的博客
03-29 132
1. 学习目的: 通过进一步学习nhibernate基础知识，在实现单表CRUD的基础上，实现两表之间one-to-many的关系. 2. 开发环境+必要准备 开发环境: windows 2003,Visual studio .Net 2005,Sql server 2005 developer edition 必要准备: 学习上篇文章单表操作 3． 对上篇文章...
Hibernate通过many-to-one元素的一对一映射
最新发布
unber的博客
07-01 981
在这里，我们将通过多对一的many-to-one元素进行一对一的映射。在这种情况下，在主表中创建外键。在这个例子中，一个员工只能有一个地址，一个地址只能属于一个员工。在这里使用双向关联。我们来看看持久化类。
NHibernate学习笔记many-to-one/one-to-many/many-to-many(转)
acg98401的博客
09-03 351
本文的内容： 　　介绍NH如何处理对象间many-to-one，one-to-many和many-to-many的双向映射关系（本文主要介绍了映射文件，对于类的生成可以跟据前两篇描述的方法生成）； 经验教训： 相关类图：（下面的类图包含一对一，多对一，一对多和多对多） many-to-one：描述多对一的一种数据模型，它指定many一方是不能独立存在的，我个人认为many...
NHibernate----many-to-one/one-to-many/many-to/one-to-one
芒果.net
11-19 650
<br /><br />many-to-one：描述多对一的一种数据模型，它指定many一方是不能独立存在的，我个人认为many-to-one是NHB中保证数据有效性的最有用的一种映射，通过使用many-to-one能有效的防治孤儿记录被写入到数据表中。在本文描述的例子中，Student类和Classes类之间是多对一关系．<br /><br />　　通过many-to-one元素,可以定义一种常见的与另一个持久化类的关联。这种关系模型是多对一关联。（实际上是一个对象引用。）在映射文件中用many-to-o
Many-to-One映射
codecross的专栏
04-24 523
Many-to-One映射 分类： 我学Hibernate 2011-08-03 13:11 987人阅读 评论(0) 收藏 举报 userstringclass存储tabledelete 举例如下： 1.Group.java [java] view plaincopyprint? package edu.study.hibernate;
NHibernate-3.3.3.SP1-reference(201308)
05-06
NHibernate是.NET社区中最受欢迎的ORM框架之一，其设计灵感来源于Java的Hibernate。 ### NHibernate 3.3.3 SP1 特性 1. **持久化模型**：NHibernate允许开发者定义实体类，通过属性映射到数据库表字段，减少了手动...
nhibernate one-to-meny
06-08
"one-to-many"是数据库关系模型中的一种关联类型，表示一个实体可以与多个其他实体相关联。在这个例子中，我们将深入探讨如何在NHibernate中实现这种关系。 在传统的数据库设计中，one-to-many关系通常体现在一个表...
NHibernate One-to-Many一对多映射-xxlinux_com
01-04
NHibernate One-to-Many一对多映射-xxlinux_com
多对一（many-to-one）
ailihx的专栏
11-30 8261
通过many-to-one元素,可以定义一种常见的与另一个持久化类的关联。 这种关系模型是多对一关联（实际上是一个对象引用－译注）：这个表的一个外键引用目标表的 主键字段。<many-to-one name="propertyName" column="column_name" class="ClassName" casc
NHibernate many-to-one映射
weixin_30435261的博客
01-12 104
many-to-one 数据方面，多条对一条。 非主键字段与主键字段的关联，在类中实现了一对一的单向映射。在类中是单实体映射。 订单充值业务。显然，一单位可以有多个充值信息。 通过表Deposit里面的CompanyId字段关联表Company主键Id字段。 订单信息。 [Serializable] public class DepositInfo {...
Hibernate 多对一（Many-to-One）映射
技术何
10-30 1530
多对一（many-to-one）关联是最常见的关联关系，其中一个对象可以与多个对象相关联。例如，一个相同的地址对象可以与多个雇员的对象相关联。 定义RDBMS表： 考虑一个情况，我们需要员工记录存储在EMPLOYEE表，将有以下结构： create table EMPLOYEE ( id INT NOT NULL auto_increment, first_name
Nhibernate学习起步之many-to-one篇(转 明了篇)
acg98401的博客
09-04 139
1. 学习目的: 通过进一步学习nhibernate基础知识，在实现单表CRUD的基础上，实现两表之间one-to-many的关系. 2. 开发环境+必要准备 开发环境: windows 2003,Visual studio .Net 2005,Sql server 2005 developer edition 必要准备: 学习上篇文章单表操作 3． ...
Many-to-one
weixin_30673715的博客
01-14 161
创建模型 from django.db import models class Reporter(models.Model): first_name = models.CharField(max_length=30) last_name = models.CharField(max_length=30) email = models.EmailF...
Hibernate级联实践之二（many-to-one）
hanqunfeng的专栏
08-27 2478
一。mapping这里使用两张表，分别是TBL_OSU_PRODUCT_I和TBL_OSU_PRODUCTMESSAGE_I，前者与后者是一对多的关系，映射文件如下： 1.TBL_OSU_PRODUCT_I"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">              SEQ_OSU_PRODUC
NHibernate对象关系映射详解-双向关联映射实践
在NHibernate的映射文件中，`<many-to-one>`元素用于定义这种关系，将`Student`类中的`Class`属性映射到数据库的`ClassID`列。 双向关联映射不仅定义了从学生到班级的引用，而且通常还需要在班级对象中设置一个反向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值