解决办法：

首先你确定你是否引入了NHibernate的程序集及使用的NHibernate的版本
如果是1.0x或之前的请使用2.0
如是是1.2.0GA或之后的使用2.2

  关于自动装配，来自于Spring.NET的支持者认为让容器自动管理，会让我们无法控制组件的依赖关系，如果该为XML配置，可以让我们知道自己在做什么，我们指定了哪些依赖关系，方便进行控制和管理；而来自于Castle IOC的支持者认为如果不让容器自动管理，手工配置会变得非常之复杂，配置文件也会变得非常繁冗，如果系统中的组件非常之多的时候，管理工作会变得很困难。

  我们来看一个简单的例子，有这样一个组件MyMainComponent，它依赖于MyComponent1、MyComponent2，并且它在构造函数中还需要接收一个整型的参数。
public class MyMainComponent
{
MyComponent1 _com1;
MyComponent2 _com2;
int _i;
public MyMainComponent(MyComponent1 com1,MyComponent2 com2,int i)
{
this._com1 = com1;
this._com2 = com2;
this._i = i;
}
}
public class MyComponent1
{
public MyComponent1()
{
//
    }
}
public class MyComponent2
{
public MyComponent2()
{
//
    }
}
  如果用采用Spring.NET，它采用XML进行组件之间的连接，配置文件如下，需要在配置文件中指定每一个对象及其它们之间的依赖，同时在配置文件中区分是构造函数还是其他方法：
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<object id="myManComponent" class="CastleDemo.MyMainComponent, CastleDemo">
<constructor-arg>
<ref object="mycomponent1" />
</constructor-arg>
<constructor-arg>
<ref object="mycomponent2" />
</constructor-arg>
<constructor-arg>
<value>1</value>
</constructor-arg>
</object>
<object id="mycomponent1" class="CastleDemo.MyComponent1, CastleDemo" />
<object id="mycomponent2" class="CastleDemo.MyComponent2, CastleDemo" />
</configuration>
Castle IOC中同样需要配置文件，但相比之下，就简单了很多：
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<components>
<component id="myMainComponent">
<parameters>
<i>1</i>
</parameters>
</component>
</components>
</configuration>
  在Castle IOC中的配置并不需要指定组件之间的关联，它会自动通过Windsor来处理；我们只是配置了一个参数i，这个i是MyMainComponent中的构造函数中不存在依赖关系的那个参数。
public class App
{
public static void Main()
{
IWindsorContainer container = new WindsorContainer(new XmlInterpreter("../../BasicUsage.xml") );
container.AddComponent( "myMainComponent",
typeof(MyMainComponent));
container.AddComponent( "myComponent1",
typeof(MyComponent1));
container.AddComponent( "myComponent2",
typeof(MyComponent2));
}
}
  这样添加组件后，
  WindsorContainer会自动调用MicroKernel中的ConstructorDependenciesModelInspector来处理组件的构造函数依赖。

  通过上面的这个简单例子比较可以看出，如果我们想要增加一个组件之间的依赖关系或者增加一个组件使用Castle要比使用Spring.NET容易很多，Spring.NET复杂的配置文件会给我们开发带来很来不可预料的错误；Castle根据对象的依赖关系，采用自动装配，不需要配置组件的依赖，另外为了符合构造注入和属性注入，Castle的配置文件并没有像Spring.Net那样区分构造函数还是其他的方法，同时直接使用Parameters，而不是使用构造函数参数之类的区分。

二。 one-to-many关系
                单向关系还是双向关系？
                     parent.getChildren().add(child)对集合的触及操作会导致lazy的集合初始化，在没有对集合配置二级缓存的情况下，应避免此类操作
                   select * from child where parent_id = xxx;
          性能口诀：
                  1.  一般情况下避免使用单向关联，尽量使用双向关联
                  2.  使用双向关联，inverse=“true”
                  3.  在分层结构中通过DAO接口用session直接持久化对象，避免通过关联关系进行可达性持久化

三。many-to-one关系
         单向many-to-one表达了外键存储方
         灵活运用many-to-one可以避免一些不必要的性能问题
         many-to-one表达的含义是：0..n : 1，many可以是0，可以是1，也可以是n，也就是说many-to-one可以表达一对多，一对一，多对一关系
          因此可以配置双向many-to-one关系，例如：
                1.   一桌四人打麻将，麻将席位和打麻将的人是什么关系？是双向many-to-one的关系

四。one-to-one
            通过主键进行关联
            相当于把大表拆分为多个小表
            例如把大字段单独拆分出来，以提高数据库操作的性能
            Hibernate的one-to-one似乎无法lazy，必须通过bytecode enhancement

五。集合List/Bag/Set 
            one-to-many
               1.    List需要维护index column，不能被用于双向关联，必须inverse=“false”，被谨慎的使用在某些稀有的场合

               2.      Bag/Set语义上没有区别
               3.       我个人比较喜欢使用Bag
           many-to-many
               1.      Bag和Set语义有区别
               2。   建议使用Set

六。集合的过滤
             1.  children = session.createFilter(parent.getChildren(), “where this.age > 5 and   this.age < 10”).list()
         针对一对多关联当中的集合元素非常庞大的情况，特别适合于庞大集合的分页：
                   session.createFilter(parent.getChildren(),“”).setFirstResult(0).setMaxResults(10).list();

七。继承关系当中的隐式多态
           HQL: from Object
             1.     把所有数据库表全部查询出来
              2.     polymorphism=“implicit”(default)将当前对象，和对象所有继承子类全部一次性取出
              3.      polymorphism=“explicit”，只取出当前查询对象

八。Hibernate二级缓存
              著名的n+1问题：from Child，然后在页面上面显示每个子类的父类信息，就会导致n条对parent表的查询：
                   select * from parent where id = ?
                   .......................
                   select * from parent where id = ?
              解决方案
                        1.      eager fetch
                         2.      二级缓存

九。inverse和二级缓存的关系
            当使用集合缓存的情况下：
                 1.     inverse=“false”，通过parent.getChildren()来操作，Hibernate维护集合缓存
                  2.    inverse=“true”，直接对child进行操作，未能维护集合缓存！导致缓存脏数据
                  3.    双向关联，inverse=“true”的情况下应避免使用集合缓存

十。Hibernate二级缓存是提升web应用性能的法宝
              OLTP类型的web应用，由于应用服务器端可以进行群集水平扩展，最终的系统瓶颈总是逃不开数据库访问；

           哪个框架能够最大限度减少数据库访问，降低数据库访问压力， 哪个框架提供的性能就更高；针对数据库的缓存策略：
                    1.        对象缓存：细颗粒度，针对表的记录级别，透明化访问，在不改变程序代码的情况下可以极大提升web应用的性能。对象缓存是ORM的制胜法宝。
                    2.       对象缓存的优劣取决于框架实现的水平，Hibernate是目前已知对象缓存最强大的开源ORM
                    3.        查询缓存：粗颗粒度，针对查询结果集，应用于数据实时化要求不高的场合

十一。应用场合决定了系统架构
一、是否需要ORM
Hibernate or iBATIS？
二、采用ORM决定了数据库设计
            Hibernate：
                    倾向于细颗粒度的设计，面向对象，将大表拆分为多个关联关系的小表，消除冗余column，通过二级缓存提升性能（DBA比较忌讳关联关系的出现，但是ORM的缓存将突破关联关系的性能瓶颈）；Hibernate的性能瓶颈不在于关联关系，而在于大表的操作
            iBATIS：
                    倾向于粗颗粒度设计，面向关系，尽量把表合并，通过表column冗余，消除关联关系。无有效缓存手段。iBATIS的性能瓶颈不在于大表操作，而在于关联关系。

总结：

     性能口诀
               1、使用双向一对多关联，不使用单向一对多
               2、灵活使用单向多对一关联
               3、不用一对一，用多对一取代
               4、配置对象缓存，不使用集合缓存
               5、一对多集合使用Bag，多对多集合使用Set
               6、继承类使用显式多态
               7、表字段要少，表关联不要怕多，有二级缓存撑腰

问题已解决，系数据库连接字符串的问题
在原有的字符串基础需增加一个参数Persist Security Info=True;
完整字符串为：
        <add key="DbProvider.ConnectionString" value="Data Source=CHANGHONG-JQM\SQLEXPRESS;Initial Catalog=FastSpring20;Persist Security Info=True;User ID=fastspring;Password=fastspring;Trusted_Connection=False"/>

• WCF Integration - Configure WCF services using dependency injection. Apply AOP advice to WCF services.
• MSMQ integration - MSMQ helper classes to increase your productivity developing messaging applications.  Provides integration with Spring's transaction management features.
• Apache ActiveMQ integration - Helper classes to increase your productivity developing messaging applications with ActiveMQ/NMS
• Quartz integration - Configure Quartz jobs, schedulers, triggers using dependency injection. Convenience classes for implementing Quartz Jobs.
• AOP - New inheritance based AOP proxy generation
• NHibernate 2.0.1 support.

Other notable new features:
 

• Color code and XML listings in reference documentation.
• Introduction of stereotype attributes - for example [Repository] 
• WCF Service exporter.
• Extensible web navigation.
• Performance improvements in WebForm dependency injection.
• QuickStart applications  for WCF, Quartz, MQMQ, and Apache Active MQ integration.
• Automatic registration of custom XML namespaces

This release includes approximately 100  bug fixes and enhancements since the 1.1.2 release. 

Please refer to the changelog for additional details.


Enjoy!

[2008-11-10]