Spring.NET学习笔记18——整合NHibernate(基础篇) Level 300

最新推荐文章于 2019-11-11 20:27:44 发布
最新推荐文章于 2019-11-11 20:27:44 发布
阅读量205 收藏
点赞数
分类专栏： .Net

　　NHibernate是一个基于.Net的针对关系型数据库的对象持久化(ORM)类库。NHibernate来源于非常优秀的基于Java的NHibernate关系型持久化工具。从数据库底NHibernate来持久化你的.Net 对象到关系型数据库。NHibernate为你处理这些，远胜于你不得不写SQL去从数据库存取对象。你的代码仅仅和对象关联，NHibernate自动产生SQL语句，并确保对象提交到正确的表和字段中去。

　　Spring.NET对NHibernate提供了很好的支持与封装。Spring.Data.NHibernate.Generic.Support和Spring.Data.NHibernate.Support下的HibernateDaoSupport是Spring.NET提供的数据库访问对象(DAO)的基类，两者的却别在于对泛型的支持程度。我们以Spring.Data.NHibernate.Generic.Support.HibernateDaoSupport为例，讲解Spring.NET整合NHibernate开发。

　　我归纳了一下，分为三个步骤：

　　一、实体对象的建立及配置

　　二、数据访问对象建立及配置

　　三、业务处理层建立及配置

 

　　首先让我们学习一下NHibernate的实体对象的映射：我建立两个实体“用户信息”和“公司信息”。图1所示。

图1

 


     public  class User
    {
         public  virtual  int? UserID {  get;  set; }
         public  virtual  string UserName {  get;  set; }
         public  virtual  int UserAge {  get;  set; }
         public  virtual  bool UserSex {  get;  set; }

         public  virtual Company CurrentCompany {  get;  set; }
    }

     public  class Company
    {
         public  virtual  int? CompanyID {  get;  set; }
         public  virtual  string CompanyName {  get;  set; }

         public  virtual IList<User> UserList {  get;  set; }
    }

　　
　　NHibernate要求实体必须是带有无参构造函数和带有virtual修饰的属性。两个实体的关系是双向(一对多——多对一)映射关系。

 


<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="Model" namespace="Model">
   < class  name ="Model.User, Model"  table ="UserInfo" >
    
     < id  name ="UserID"  column ="UserID"  type ="int"   >
       < generator  class ="native"   />
     </ id >

     < property  name ="UserName"  column ="UserName"  type ="string"  length ="50"  not-null ="true" />
     < property  name ="UserAge"  column ="UserAge"  type ="int" />
     < property  name ="UserSex"  column ="UserSex"  type ="bool" />

     < many-to-one  name ="CurrentCompany"  class ="Model.Company, Model"  foreign-key ="FK_UserInfo_CompanyInfo" >
       < column  name ="CompanyID"  not-null ="true"   />
     </ many-to-one >

   </ class >
</ hibernate-mapping >


< hibernate-mapping  xmlns ="urn:nhibernate-mapping-2.2"  assembly ="Model"  namespace ="Model" >
   < class  name ="Model.Company, Model"  table ="CompanyInfo" >
    
     < id  name ="CompanyID"  column ="CompanyID"  type ="int"   >
       < generator  class ="native"   />
     </ id >

     < property  name ="CompanyName"  column ="Name"  type ="string"  not-null ="true"  length ="50" />

     < bag  name ="UserList"  inverse ="true"  cascade ="all-delete-orphan"  table ="UserInfo" >
       < key  column ="CompanyID"  foreign-key ="FK_UserInfo_CompanyInfo" />
       < one-to-many  class ="Model.User, Model"   />
     </ bag >

   </ class >
</ hibernate-mapping >

 

　　以上就是实体对象与数据的映射文件，提供的配置我不详细说明，请查看NHibernate的帮助手册。

　　接下来，我建立数据库访问对象(DAO)层。在这里我使用了泛型Repository模式。

 


     public  interface IRepository<T>
    {
         void Delete(T entity);
        T Get( object id);
         object Save(T entity);
         void Update(T entity);
    }

    public  class NHibernateRepository<T> : HibernateDaoSupport, IRepository<T>
    {
         public  object Save(T entity)
        {
             return  this.HibernateTemplate.Save(entity);
        }

         public T Get( object id)
        {
             return  this.HibernateTemplate.Get<T>(id);
        }

         public  void Update(T entity)
        {
             this.HibernateTemplate.Update(entity);
        }

         public  void Delete(T entity)
        {
             this.HibernateTemplate.Delete(entity);
        }
    }

 

　　数据库访问对象我们可以让它继承于HibernateDaoSupport类，该类的HibernateTemplate属性我们可以通过Spring.NET从外部注入。

 


<?xml version="1.0" encoding="utf-8" ?>
< objects  xmlns ="http://www.springframework.net"
         xmlns:db ="http://www.springframework.net/database" >
   <!--  用以我们在其它的应用程序中，配置数据访问  -->
   < object  type ="Spring.Objects.Factory.Config.PropertyPlaceholderConfigurer, Spring.Core" >
     < property  name ="ConfigSections"  value ="databaseSettings" />
   </ object >

   <!--  数据库和Nhibernate的相关配置  -->
   < db:provider  id ="DbProvider"  provider ="SqlServer-1.1"  
               connectionString ="Server=${db.datasource};database=${db.database};uid=${db.user};pwd=${db.password};" />

   <!-- SessionFactory对象，其中包括一些比较重要的属性  -->
   < object  id ="NHibernateSessionFactory"  type ="Spring.Data.NHibernate.LocalSessionFactoryObject, Spring.Data.NHibernate21" >
     < property  name ="DbProvider"  ref ="DbProvider" />
     < property  name ="MappingAssemblies" >
       < list >
         < value >Model </ value >
       </ list >
     </ property >
     < property  name ="HibernateProperties" >
       < dictionary >
         < entry  key ="hibernate.connection.provider"  value ="NHibernate.Connection.DriverConnectionProvider" />
         < entry  key ="dialect"  value ="NHibernate.Dialect.MsSql2000Dialect" />
         < entry  key ="hibernate.connection.driver_class"  value ="NHibernate.Driver.SqlClientDriver" />
         < entry  key ="use_outer_join"  value ="true" />
         < entry  key ="show_sql"  value ="false" />
         <!-- 自动建表(反向映射) -->
         < entry  key ="hbm2ddl.auto"  value ="update" />
         < entry  key ="adonet.batch_size"  value ="10" />
         < entry  key ="command_timeout"  value ="60" />
         <!-- 显式启用二级缓存 -->
         < entry  key ="cache.use_second_level_cache"  value ="true" />
         <!-- 启动查询缓存 -->
         < entry  key ="cache.use_query_cache"  value ="false" />
         < entry  key ="query.substitutions"  value ="true 1, false 0, yes 'Y', no 'N" />
         < entry  key ="proxyfactory.factory_class"  value ="NHibernate.ByteCode.Castle.ProxyFactoryFactory, NHibernate.ByteCode.Castle" />
       </ dictionary >
     </ property >
     < property  name ="ExposeTransactionAwareSessionFactory"  value ="true"   />
   </ object >

   < object  id ="HibernateTemplate"  type ="Spring.Data.NHibernate.Generic.HibernateTemplate" >
     < property  name ="SessionFactory"  ref ="NHibernateSessionFactory"   />
     < property  name ="TemplateFlushMode"  value ="Auto"   />
     < property  name ="CacheQueries"  value ="true"   />
   </ object >

   < object  id ="repository.user"  type ="Repository.NHibernateRepository&lt;Model.User>, Repository" >
     < property  name ="HibernateTemplate"  ref ="HibernateTemplate" />
   </ object >

   < object  id ="repository.company"  type ="Repository.NHibernateRepository&lt;Model.Company>, Repository" >
     < property  name ="HibernateTemplate"  ref ="HibernateTemplate" />
   </ object >


</ objects >

 

　　db:provider节点是数据的连接字符串配置，我们引入xmlns:db="http://www.springframework.net/database这项命名空间便可以使用它。其中provider属性为数据库提供者的名称。以下是provider的详细情况：

名称

介绍

SqlServer-1.1

Microsoft SQL Server, provider V1.0.5.0 in framework .NET V1.1

SqlServer-2.0

Microsoft SQL Server, provider V2.0.0.0 in framework .NET V2.0

SqlServerCe-3.1

Microsoft SQL Server Compact Edition, provider V9.0.242.0

SqlServerCe-3.5.1

Microsoft SQL Server Compact Edition, provider V3.5.1.0

OleDb-1.1

provider V1.0.5000.0 in framework .NET V1.1

OleDb-2.0

provider V2.0.0.0 in framework .NET V2.0

OracleClient-2.0

Oracle, Microsoft provider V2.0.0.0

OracleODP-2.0

Oracle, Oracle provider V2.102.2.20

MySql

MySQL provider 1.0.10.1

MySql-1.0.9

MySQL provider 1.0.9

MySql-5.0

MySQL provider 5.0.7.0

MySql-5.0.8.1

MySQL provider 5.0.8.1

MySql-5.1

MySQL provider 5.1.2.2

MySql-5.1.4

MySQL provider 5.1.2.2

MySql-5.2.3

MySQL provider 5.2.3.0

Npgsql-1.0

Postgresql provider 1.0.0.0 (and 1.0.0.1 - were build with same version info)

Npgsql-2.0 -beta1

Postgresql provider 1.98.1.0 beta 1

Npgsql-2.0

Postgresql provider 2.0.0.0

DB2-9.0.0-1.1

IBM DB2 Data Provider 9.0.0 for .NET Framework 1.1

DB2-9.0.0-2.0

IBM DB2 Data Provider 9.0.0 for .NET Framework 2.0

DB2-9.1.0-1.1

IBM DB2 Data Provider 9.1.0 for .NET Framework 1.1

DB2-9.1.0.2

IBM DB2 Data Provider 9.1.0 for .NET Framework 2.

SQLite-1.0.43

SQLite provider 1.0.43 for .NET Framework 2.0

SQLite-1.0.47

SQLite provider 1.0.43 for .NET Framework 2.0

SybaseAse-12

Sybase ASE provider for ASE 12.x

SybaseAse-15

Sybase ASE provider for ASE 15.x

SybaseAse-AdoNet2

Sybase ADO.NET 2.0 provider for ASE 12.x and 15.x

Odbc-1.1

ODBC provider V1.0.5000.0 in framework .NET V1.1

Odbc-2.0

ODBC provider V2.0.0.0 in framework .NET V2

InterSystems.Data.CacheClient

Caché provider Version 2.0.0.1 in framework .NET V2

 

　　可以根据自己的数据库选择不同的提供者名称。connectionString属性为数据库的连接字符串，这里用${xxx}的方式来表示一个占位符，因为我们经常将Spring.NET的配置文件设置为“嵌入系统资源”，这样一来在程序编译后就不能够修改，所以我们就要在应用程序配置文件中填写连接字符串，而不是在Spring.NET的配置文件中填写。

 


<configuration>

< configSections >
< section  name ="databaseSettings"  type ="System.Configuration.NameValueSectionHandler" />
</ configSections >

   <!-- 数据库连接字符串 -->
   < databaseSettings >
     < add  key ="db.datasource"  value ="."   />
     < add  key ="db.user"  value ="sa"   />
     < add  key ="db.password"  value =""   />
     < add  key ="db.database"  value ="SpringNet_Lesson18"   />
   </ databaseSettings >

</ configuration >

 　　

　　NHibernate中的Session控制取决于SessionFactory，Spring.NET提供了LocalSessionFactoryObject类来统一管理SessionFactory。其中MappingAssemblies属性为实体程序集的名称，可以填写多个名称。HibernateProperties为NHibernate的配置，dialect属性为数据库的方言，因为是SQL server 2K数据库，所以使用NHibernate.Dialect.MsSql2000Dialect 。proxyfactory.factory_class属性为延迟加载的代理类驱动，在NHibernate 2.1版中必须配置。hbm2ddl.auto属性为反向建立映射表的配置，我们配置为update后，NHibernate会帮我们自动根据实体的结构生成数据库中的表。

 

　　接下来我们看一下业务处理层。

 


     public  interface IUserManager
    {
         void Delete(User entity);
        User Get( object id);
         object Save(User entity);
         void Update(User entity);
        IRepository<User> UserRepository {  get;  set; }
    }

     public  class UserManager : IUserManager
    {
         public IRepository<User> UserRepository {  get;  set; }

         public  object Save(User entity)
        {
             return  this.UserRepository.Save(entity);
        }

         public  void Delete(User entity)
        {
             this.UserRepository.Delete(entity);
        }

         public User Get( object id)
        {
             return  this.UserRepository.Get(id);
        }

         public  void Update(User entity)
        {
             this.UserRepository.Update(entity);
        }
    }

 


     public  interface ICompanyManager
    {
         void Delete( object id);
        Company Get( object id);
         object Save(Company entity);
         void Update(Company entity);
    }

     public  class CompanyManager : ICompanyManager
    {
         public IRepository<Company> CompanyRepository {  get;  set; }

         public  object Save(Company entity)
        {
             return  this.CompanyRepository.Save(entity);
        }

         public  void Delete( object id)
        {
             this.CompanyRepository.Delete( this.Get(id));
        }

         public Company Get( object id)
        {
             return  this.CompanyRepository.Get(id);
        }

         public  void Update(Company entity)
        {
            Company company =  this.Get(entity.CompanyID);
            company.CompanyName = entity.CompanyName;
             this.CompanyRepository.Update(company);
        }
    }

 

　　代码的编写我不仔细讲，我们主要学习一下相关的配置。

 


<?xml version="1.0" encoding="utf-8" ?>
< objects  xmlns ="http://www.springframework.net" >

   < object  id ="transactionManager"
        type ="Spring.Data.NHibernate.HibernateTransactionManager, Spring.Data.NHibernate21" >
     < property  name ="DbProvider"  ref ="DbProvider" />
     < property  name ="SessionFactory"  ref ="NHibernateSessionFactory" />
   </ object >


   < object  id ="transactionInterceptor"  type ="Spring.Transaction.Interceptor.TransactionInterceptor, Spring.Data" >
     < property  name ="TransactionManager"  ref ="transactionManager" />
     < property  name ="TransactionAttributeSource" >
       < object  type ="Spring.Transaction.Interceptor.AttributesTransactionAttributeSource, Spring.Data" />
     </ property >
   </ object >

   < object  id ="BaseTransactionManager"   type ="Spring.Transaction.Interceptor.TransactionProxyFactoryObject, Spring.Data"  abstract ="true" >
     < property  name ="PlatformTransactionManager"  ref ="transactionManager" />
     < property  name ="TransactionAttributes" >
       < name-values >
         < add  key ="Save*"  value ="PROPAGATION_REQUIRED" />
         < add  key ="Set*"  value ="PROPAGATION_REQUIRED" />
         < add  key ="Finish*"  value ="PROPAGATION_REQUIRED" />
         < add  key ="Update*"  value ="PROPAGATION_REQUIRED" />
         < add  key ="Delete*"  value ="PROPAGATION_REQUIRED" />
         < add  key ="Add*"  value ="PROPAGATION_REQUIRED" />
         < add  key ="Get*"  value ="PROPAGATION_SUPPORTS,readOnly" />
         < add  key ="Find*"  value ="PROPAGATION_SUPPORTS,readOnly" />
         < add  key ="Load*"  value ="PROPAGATION_SUPPORTS,readOnly" />
         < add  key ="*"  value ="PROPAGATION_REQUIRED" />
       </ name-values >
     </ property >
   </ object >

   < object  id ="CompanyManager"  parent ="BaseTransactionManager" >
     < property  name ="Target" >
       < object  type ="Manager.CompanyManager,Manager" >
         < property  name ="CompanyRepository"  ref ="repository.company" />
       </ object >
     </ property >
   </ object >

   < object  id ="UserManager"  parent ="BaseTransactionManager" >
     < property  name ="Target" >
       < object  type ="Manager.UserManager,Manager" >
         < property  name ="UserRepository"  ref ="repository.user" />
       </ object >
     </ property >
   </ object >

</ objects >

 

　　我们在前几篇学过AOP拦截和事务代理。Spring.NET为NHibernate提供的事务代理是TransactionProxyFactoryObject。我们将改类的Target熟悉注入业务处理层的类，这样Spring.NET会为该类包装上事务。

 

　　最后我们写一个单元测试类，对业务层进行单元测试。


[TestFixture]
     public  class UserManagerTest 
    {
         static log4net.ILog logger = log4net.LogManager.GetLogger( " Logger ");

        [SetUp]
         public  void SetUp()
        {
             try
            {
                log4net.Config.XmlConfigurator.Configure();
                IApplicationContext applicationContext = ContextRegistry.GetContext();
                userManager = (IUserManager)applicationContext.GetObject( " UserManager ");
                companyManager = (ICompanyManager)applicationContext.GetObject( " CompanyManager ");
            }
             catch (Exception ex)
            {
                logger.Error(ex);
                 throw ex;
            }
        }

         private IUserManager userManager;
         private ICompanyManager companyManager;

        [Test]
         public  void Delete()
        {
            userManager.Delete(userManager.Get( 2));
        }

        [Test]
         public  void Get()
        {
            User user = userManager.Get( 1);
        }

        [Test]
         public  void Save()
        {
            User user =  new User();
            user.UserName =  " 刘冬 ";
            user.CurrentCompany = companyManager.Get( 1);
            userManager.Save(user);
        }

        [Test]
         public  void Update()
        {
            User user = userManager.Get( 1);
            user.UserName =  " 刘冬冬 ";
            userManager.Update(user);
        }
    }

 


[TestFixture]
     public  class CompanyManagerTest 
    {
         static log4net.ILog logger = log4net.LogManager.GetLogger( " Logger ");

        [SetUp]
         public  void SetUp()
        {
             try
            {
                log4net.Config.XmlConfigurator.Configure();
                IApplicationContext applicationContext = ContextRegistry.GetContext();
                companyManager = (ICompanyManager)applicationContext.GetObject( " CompanyManager ");
            }
             catch (Exception ex)
            {
                logger.Error(ex);
                 throw ex;
            }
        }

         private ICompanyManager companyManager;

        [Test]
         public  void Delete()
        {
            companyManager.Delete( 4);
        }

        [Test]
         public  void Get()
        {
            Company company = companyManager.Get( 1);
        }

        [Test]
         public  void Save()
        {
            Company company =  new Company();
            company.CompanyName =  " 刘冬公司 ";
            companyManager.Save(company);
        }

        [Test]
         public  void Update()
        {
            Company company = companyManager.Get( 1);
            company.CompanyName =  " 刘冬冬公司 ";
            companyManager.Update(company);
        }
    }

 

　　配置文件：


<?xml version="1.0" encoding="utf-8" ?>
< configuration >
  
   < configSections >
     < sectionGroup  name ="spring" >
       < section  name ="context"  type ="Spring.Context.Support.ContextHandler, Spring.Core" />
       < section  name ="objects"  type ="Spring.Context.Support.DefaultSectionHandler, Spring.Core" />
       < section  name ="parsers"  type ="Spring.Context.Support.NamespaceParsersSectionHandler, Spring.Core" />
     </ sectionGroup >
    
     < section  name ="databaseSettings"  type ="System.Configuration.NameValueSectionHandler" />
     < section  name ="log4net"  type ="log4net.Config.Log4NetConfigurationSectionHandler,log4net"   />

   </ configSections >

   < spring >
     < parsers >
       < parser  type ="Spring.Data.Config.DatabaseNamespaceParser, Spring.Data" />
       < parser  type ="Spring.Transaction.Config.TxNamespaceParser, Spring.Data" />
     </ parsers >
     < context >
       < resource  uri ="assembly://Repository/Repository/Repository.xml" />
       < resource  uri ="assembly://Manager/Manager/Manager.xml" />
     </ context >

   </ spring >

   < log4net >
     < appender  name ="ConsoleAppender"  type ="log4net.Appender.ConsoleAppender" >
       < layout  type ="log4net.Layout.PatternLayout" >
         < conversionPattern  value ="%-5level %logger - %message%newline"   />
       </ layout >
     </ appender >

     <!--  Set default logging level to DEBUG  -->
     < root >
       < level  value ="DEBUG"   />
       < appender-ref  ref ="ConsoleAppender"   />
     </ root >

     <!--  Set logging for Spring.  Logger names in Spring correspond to the namespace  -->
     < logger  name ="Spring" >
       < level  value ="INFO"   />
     </ logger >

     < logger  name ="Spring.Data" >
       < level  value ="DEBUG"   />
     </ logger >

     < logger  name ="NHibernate" >
       < level  value ="INFO"   />
     </ logger >


   </ log4net >

   <!-- 数据库连接字符串 -->
   < databaseSettings >
     < add  key ="db.datasource"  value ="."   />
     < add  key ="db.user"  value ="sa"   />
     < add  key ="db.password"  value =""   />
     < add  key ="db.database"  value ="SpringNet_Lesson18"   />
   </ databaseSettings >

</ configuration >

 

 

　　代码下载

 

　　数据库我没有上传，因为空间的问题。我设置了自动建表的属性，可以用来自动创建数据库表结构。

 

　　返回目录

作者：刘冬.NET 博客地址：http://www.cnblogs.com/GoodHelper/ 欢迎转载，但须保留版权
my98800
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot集成hibernate
05-22
springboot集成hibernate无jpa，在dao中使用SessionFactory操作数据库
spring.data.Nhibernate.dll
05-22
spring.data.Nhibernate.dll
整合NHibernate到Spring.Net (之一)
weixin_34138139的博客
12-20 51
有这段文字的惟一原因是因为spring.net尚远远没有完成。因此，借鉴spring (java)的LocalSessionFactoryObject,我们在.net中创建一个LocalSessionFactoryObject注：在Spring.Net的开发计划中，第一个版本仅会完成aop和ioc功能，即现在在cvs上大家看到的Spring.Context,Spring.AOP,Spring.Co...
Spring.NET实用技巧2——NHibernate访问Oracle数据库
weixin_33753003的博客
05-25 106
　　针对大型系统，往往采用Oracle数据库。这是因为在大数据量的情况下Oracle的优势比较明显，而且能够部署到非Windows环境下，从而弥补.NET程序跨平台的缺点。但是使用NHibernate访问Oracle和访问SQL Server相比来说要略微复杂。 　　在使用NHibernate访问Oracle的过程中，我们需要以下几个步骤： 　　1.下载并安装Oracle客户端http://w...
Spring.NET学习笔记18——整合NHibernate例子
11-18
刘冬编写的Spring.NET整合NHibernate例子 原文：http://www.cnblogs.com/GoodHelper/archive/2009/11/18/SpringNet_NHibernate.html
Spring.NET学习笔记19——整合NHibernate和ASP.NET MVC的代码
11-19
刘冬编写的Spring.NET,NHibernate,ASP.NET MVC例子 原文：http://www.cnblogs.com/GoodHelper/archive/2009/11/19/SpringNet_Nhibernate_AspNetMvc.html
ASP.NET MVC Spring.Net NHibernate整合源码.
11-13
ASP.NET MVC、Spring.Net 和 NHibernate 是三个在开发企业级 Web 应用程序时常用的开源框架，它们分别在不同的层面上提供了强大的功能。这个压缩包文件的标题表明它包含了一个 ASP.NET MVC 应用程序，该应用使用了 ...
Spring.NET实用技巧2——NHibernate访问Oracle
05-25
首先，我们需要理解Spring.NET如何与NHibernate整合。Spring.NET提供了一个高级的NHibernate集成，包括SessionFactory的管理、事务管理以及对象的生命周期管理。这使得开发者能够充分利用NHibernate的强大功能，同时...
Spring.NET实用技巧3——NHibernate分布式事务(上)
07-29
Spring.NET实用技巧3——NHibernate分布式事务(上) 博客出处： http://www.cnblogs.com/GoodHelper/archive/2010/07/29/SpringNetDistributedTransaction1.html
Spring.Data.NHibernate12.dll下载
03-24
Spring.Data.NHibernate12.dll下载
nhibernate_template_4个模板文件
07-07
包含4个文件NHibernate.class.cst,NHibernate.cst,NHibernate.hbm.cst,NHibernate.inc
Spring Data初步--整合Hibernate
欢迎来到我的博客，一起学习Java！
11-11 545
Spring Data课程中的技术介绍 Hibernate： Hibernate 是一个开放源代码的对象关系映射框架，它对 JDBC 进行了非常轻量级的对象封装，它将 pojo 与数据库表建立映射关系，是一个全自动的 ORM（Object - Relationship - Mapping）框架，Hibernate 可以自动生成 SQL 语句，自动执行，使得 Java 程序员可以随心所欲的使用对...
Spring.NET教程（十六）——整合NHibernate(基础篇)
weixin_30482383的博客
12-30 111
NHibernate是一个基于.Net的针对关系型数据库的对象持久化(ORM)类库。NHibernate来源于非常优秀的基于Java的NHibernate关系型持久化工具。从数据库底NHibernate来持久化你的.Net 对象到关系型数据库。NHibernate为你处理这些，远胜于你不得不写SQL去从数据库存取对象。你的代码仅仅和对象关联，NHibernate自动产生SQL语句，并确保对象提交到...
Spring.NET学习笔记二（NHibernate的配置）
weixin_30784501的博客
11-25 93
文章的目的：学习如何去配置Spring.NET的NHibernate。因此，有些东西直接是使用现成的。从spring.net官网下载了最新版，里面有个Spring.Data.NHibernate.Northwind项目，我们这节的 部分代码是直接引用这个项目的。1：创建一个网站文件夹。sphbm_test。2：在解决方案中选择添加现有网站，选择刚才创建的文件夹。设置好这个网站的相关配置，...
Spring.NET学习笔记18——整合NHibernate(基础篇)
zhangxian_engineer的专栏
04-10 1580
<br />NHibernate是一个基于.Net的针对关系型数据库的对象持久化(ORM)类库。NHibernate来源于非常优秀的基于Java的NHibernate关系型持久化工具。从数据库底NHibernate来持久化你的.Net 对象到关系型数据库。NHibernate为你处理这些，远胜于你不得不写SQL去从数据库存取对象。你的代码仅仅和对象关联，NHibernate自动产生SQL语句，并确保对象提交到正确的表和字段中去。<br />Spring.NET对NHibernate提供了很好的支持与封装。S
Spring.net + Nhibernate 框架 配置
恨海孤雁&昕
03-30 971
最近公司准备用Spring.net + Nhibernate 框架开发一个web项目，在网上找了一天的框架示例代码,基本上是一个人一个写法，看了让人费解，没有一个示例代码像JAVA的spring+hibernate+struts框架。今天在官网上下了Spring.NET-20100325-0312.rar的lib包，里面的Spring.Data.NHibernate.Northwind示例代码
整合asp.net mvc4,Spring.net,nhibernate实现分层开发
爱软件-从懂得生活开始。
04-03 3157
1，在web.config配置中添加如下配置信息，同时指定Spring.net的核心配置文件services.xml和Objects.xml。 --> --> 2，services
C#.NET编程：Spring.NET & NHibernate 入门到精通指南
通过深入学习Spring.NET和NHibernate，开发者可以构建更灵活、可维护的.NET应用，并且能够更高效地处理数据库操作。本教程将逐步引导读者从安装、配置到实践应用，实现从入门到精通的过渡。提供的源代码下载地址可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值