但是不管怎么变，基本模型归纳起来就是上面的三种模型，下面分别简单评价一下：

第一种模型绝大多数人都反对，因此反对理由我也不多讲了。但遗憾的是，我观察到的实际情形是，很多使用Hibernate的公司最后都是这种模型，这里面有很大的原因是很多公司的技术水平没有达到这种层次，所以导致了这种贫血模型的出现。从这一点来说，Martin Fowler的批评声音不是太响了，而是太弱了，还需要再继续呐喊。

第二种模型就是Martin Fowler一直主张的模型，实际上也是我一直在实际项目中采用这种模型。我没有看过Martin的POEAA，之所以能够自己摸索到这种模型，也是因为从02年我已经开始思考这个问题并且寻求解决方案了，但是当时没有看到Hibernate，那时候做的一个小型项目我已经按照这种模型来做了，但是由于没有O/R Mapping的支持，写到后来又不得不全部改成贫血的domain object，项目做完以后再继续找，随后就发现了Hibernate。当然，现在很多人一开始就是用Hibernate做项目，没有经历过我经历的那个阶段。

不过我觉得这种模型仍然不够完美，因为你还是需要一个业务逻辑层来封装所有的domain logic，这显得非常罗嗦，并且业务逻辑对象的接口也不够稳定。如果不考虑业务逻辑对象的重用性的话(业务逻辑对象的可重用性也不可能好)，很多人干脆就去掉了xxxManager这一层，在Web层的Action代码直接调用xxxDao，同时容器事务管理配置到Action这一层上来。Hibernate的caveatemptor就是这样架构的一个典型应用。

第三种模型是我很反对的一种模型，这种模型下面，Domain Object和DAO形成了双向依赖关系，无法脱离框架测试，并且业务逻辑层的服务也和持久层对象的状态耦合到了一起，会造成程序的高度的复杂性，很差的灵活性和糟糕的可维护性。也许将来技术进步导致的O/R Mapping管理下的domain object发展到足够的动态持久透明化的话，这种模型才会成为一个理想的选择。就像O/R Mapping的流行使得第二种模型成为了可能(O/R Mapping流行以前，我们只能用第一种模型，第二种模型那时候是不现实的)。

Item：包含了实体类信息，也包含了所有的业务逻辑
ItemDao：持久化DAO接口类
ItemDaoHibernateImpl：DAO接口的实现类

由于ItemDao和ItemDaoHibernateImpl和上面完全相同，就省略了。

在这种模型中，所有的业务逻辑全部都在Item中，事务管理也在Item中实现。

一个带有业务逻辑的实体类，即domain object是Item
一个DAO接口ItemDao
一个DAO实现ItemDaoHibernateImpl
一个业务逻辑对象ItemManager

竞标这个业务逻辑被放入到Item中来。请注意this.getBids.add(newBid); 如果没有Hibernate或者JDO这种O/R Mapping的支持，我们是无法实现这种透明的持久化行为的。但是请注意，Item里面不能去调用ItemDAO，对ItemDAO产生依赖！

ItemDao和ItemDaoHibernateImpl的代码同上，省略。

在第二种模型中，placeBid业务逻辑是放在Item中实现的，而loadItemById和findAll业务逻辑是放在ItemManager中实现的。不过值得注意的是，即使placeBid业务逻辑放在Item中，你仍然需要在ItemManager中简单的封装一层，以保证对placeBid业务逻辑进行事务的管理和持久化的触发。

这种模型是Martin Fowler所指的真正的domain model。在这种模型中，有三个业务逻辑方法：placeBid，loadItemById和findAll，现在的问题是哪个逻辑应该放在Item中，哪个逻辑应该放在ItemManager中。在我们这个例子中，placeBid放在Item中(但是ItemManager也需要对它进行简单的封装)，loadItemById和findAll是放在ItemManager中的。

切分的原则是什么呢？ Rod Johnson提出原则是“case by case”，可重用度高的，和domain object状态密切关联的放在Item中，可重用度低的，和domain object状态没有密切关联的放在ItemManager中。

我提出的原则是：看业务方法是否显式的依赖持久化。

Item的placeBid这个业务逻辑方法没有显式的对持久化ItemDao接口产生依赖，所以要放在Item中。请注意，如果脱离了Hibernate这个持久化框架，Item这个domain object是可以进行单元测试的，他不依赖于Hibernate的持久化机制。它是一个独立的，可移植的，完整的，自包含的域对象。

而loadItemById和findAll这两个业务逻辑方法是必须显式的对持久化ItemDao接口产生依赖，否则这个业务逻辑就无法完成。如果你要把这两个方法放在Item中，那么Item就无法脱离Hibernate框架，无法在Hibernate框架之外独立存在。

一个实体类叫做Item，指的是一个拍卖项目
一个DAO接口类叫做ItemDao
一个DAO接口实现类叫做ItemDaoHibernateImpl
一个业务逻辑类叫做ItemManager(或者叫做ItemService)

ItemDao定义持久化操作的接口，用于隔离持久化代码。

事务的管理是在ItemManger这一层完成的，ItemManager实现具体的业务逻辑。除了常见的和CRUD有关的简单逻辑之外，这里还有一个placeBid的逻辑，即项目的竞标。

以上是一个完整的第一种模型的示例代码。在这个示例中，placeBid，loadItemById，findAll等等业务逻辑统统放在ItemManager中实现，而Item只有getter/setter方法。

Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.

The classes and/or objects participating in the Composite pattern are: Component   (DrawingElement) declares the interface for objects in the composition. implements default behavior for the interface common to all classes, as appropriate. declares an interface for accessing and managing its child components. (optional) defines an interface for accessing a component's parent in the recursive structure, and implements it if that's appropriate. Leaf   (PrimitiveElement) represents leaf objects in the composition. A leaf has no children. defines behavior for primitive objects in the composition. Composite   (CompositeElement) defines behavior for components having children. stores child components. implements child-related operations in the Component interface. Client  (CompositeApp) manipulates objects in the composition through the Component interface.

This real-world code demonstrates the Composite pattern used in building a graphical tree structure made up of primitive nodes (lines, circles, etc) and composite nodes (groups of drawing elements that make up more complex elements).


using System;
using System.Collections;

// "Component"

abstract class DrawingElement
{
  // Fields
  protected string name;

  // Constructors
  public DrawingElement( string name )
  {
    this.name = name;
  }
 
  // Methods
  abstract public void Add( DrawingElement d );
  abstract public void Remove( DrawingElement d );
  abstract public void Display( int indent );
}

// "Leaf"

class PrimitiveElement : DrawingElement
{
  // Constructors
  public PrimitiveElement( string name ) : base( name ) {}

  // Methods
  public override void Add( DrawingElement c )
  {
    Console.WriteLine("Cannot Add");
  }

  public override void Remove( DrawingElement c )
  {
    Console.WriteLine("Cannot Remove");
  }

  public override void Display( int indent )
  {
    Console.WriteLine( new String( '-', indent ) + 
                                 " draw a {0}", name );
  }
}

// "Composite"

class CompositeElement : DrawingElement
{
  // Fields
  private ArrayList elements = new ArrayList();
 
  // Constructors
  public CompositeElement( string name )
                                    : base( name ) {}

  // Methods
  public override void Add( DrawingElement d )
  {
    elements.Add( d );
  }

  public override void Remove( DrawingElement d )
  {
    elements.Remove( d );
  }

  public override void Display( int indent )
  {
    Console.WriteLine( new String( '-', indent ) +
                                "+ " + name );

    // Display each child element on this node
    foreach( DrawingElement c in elements )
      c.Display( indent + 2 );
  }
}
 
/// <summary>
///  CompositeApp test
/// </summary>
public class CompositeApp
{
  public static void Main( string[] args )
  {
    // Create a tree structure
    CompositeElement root = new  
                   CompositeElement( "Picture" );
    root.Add( new PrimitiveElement( "Red Line" ));
    root.Add( new PrimitiveElement( "Blue Circle" ));
    root.Add( new PrimitiveElement( "Green Box" ));

    CompositeElement comp = new  
                   CompositeElement( "Two Circles" );
    comp.Add( new PrimitiveElement( "Black Circle" ) );
    comp.Add( new PrimitiveElement( "White Circle" ) );
    root.Add( comp );

    // Add and remove a PrimitiveElement
    PrimitiveElement l = new  
                   PrimitiveElement( "Yellow Line" );
    root.Add( l );
    root.Remove( l );

    // Recursively display nodes
    root.Display( 1 );
  }
}

Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.

The classes and/or objects participating in the Decorator pattern are: Component   (LibraryItem) defines the interface for objects that can have responsibilities added to them dynamically. ConcreteComponent   (Book, Video) defines an object to which additional responsibilities can be attached. Decorator   (Decorator) maintains a reference to a Component object and defines an interface that conforms to Component's interface. ConcreteDecorator   (Borrowable) adds responsibilities to the component.

This real-world code demonstrates the Decorator pattern in which 'borrowable' functionality is added to existing library items (books and videos).

// Decorator pattern -- Real World example

using System; using System.Collections; // "Component" abstract class LibraryItem {   // Fields   private int numCopies;   // Properties   public int NumCopies   {     get{ return numCopies; }     set{ numCopies = value; }   }   // Methods   public abstract void Display(); } // "ConcreteComponent" class Book : LibraryItem {   // Fields   private string author;   private string title;   // Constructors   public Book(string author,string title,int numCopies)   {     this.author = author;     this.title = title;     this.NumCopies = numCopies;   }   // Methods   public override void Display()   {     Console.WriteLine( "\nBook ------ " );     Console.WriteLine( " Author: {0}", author );     Console.WriteLine( " Title: {0}", title );     Console.WriteLine( " # Copies: {0}", NumCopies );   } } // "ConcreteComponent" class Video : LibraryItem {   // Fields   private string director;   private string title;   private int playTime;   // Constructor   public Video( string director, string title,                       int numCopies, int playTime )   {     this.director = director;     this.title = title;     this.NumCopies = numCopies;     this.playTime = playTime;   }   // Methods   public override void Display()   {     Console.WriteLine( "\nVideo ----- " );     Console.WriteLine( " Director: {0}", director );     Console.WriteLine( " Title: {0}", title );     Console.WriteLine( " # Copies: {0}", NumCopies );     Console.WriteLine( " Playtime: {0}", playTime );   } } // "Decorator" abstract class Decorator : LibraryItem {   // Fields   protected LibraryItem libraryItem;   // Constructors   public Decorator ( LibraryItem libraryItem )   {     this.libraryItem = libraryItem;   }   // Methods   public override void Display()   {     libraryItem.Display();   } } // "ConcreteDecorator" class Borrowable : Decorator {   // Fields   protected ArrayList borrowers = new ArrayList();   // Constructors   public Borrowable( LibraryItem libraryItem )                             : base( libraryItem ) {}   // Methods   public void BorrowItem( string name )   {     borrowers.Add( name );     libraryItem.NumCopies--;   }   public void ReturnItem( string name )   {     borrowers.Remove( name );      libraryItem.NumCopies++;   }   public override void Display()   {     base.Display();     foreach( string borrower in borrowers )       Console.WriteLine( " borrower: {0}", borrower );   } }   /// <summary> ///  DecoratorApp test /// </summary> public class DecoratorApp {   public static void Main( string[] args )   {     // Create book and video and display     Book book = new Book( "Schnell", "My Home", 10 );     Video video = new Video( "Spielberg",                           "Schindler's list", 23, 60 );     book.Display();     video.Display();     // Make video borrowable, then borrow and display     Console.WriteLine( "\nVideo made borrowable:" );     Borrowable borrowvideo = new Borrowable( video );     borrowvideo.BorrowItem( "Cindy Lopez" );     borrowvideo.BorrowItem( "Samuel King" );     borrowvideo.Display();   } }

Convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.

UML class diagram

Participants

The classes and/or objects participating in the Adapter pattern are: Target   (ChemicalCompound) defines the domain-specific interface that Client uses. Adapter   (Compound) adapts the interface Adaptee to the Target interface. Adaptee   (ChemicalDatabank) defines an existing interface that needs adapting. Client   (AdapterApp) collaborates with objects conforming to the Target interface.

This structural code demonstrates the Adapter pattern which maps the interface of one class onto another so that they can work together. These incompatible classes may come from different libraries or frameworks.

using System;

// "Target"

class Target
{
  // Methods
  virtual public void Request()
  {
    // Normal implementation goes here
  }
}

// "Adapter"

class Adapter : Target
{
  // Fields
  private Adaptee adaptee = new Adaptee();

  // Methods
  override public void Request()
  {
    // Possibly do some data manipulation
    // and then call SpecificRequest
    adaptee.SpecificRequest();
  }
}

// "Adaptee"

class Adaptee
{
  // Methods
  public void SpecificRequest()
  {
    Console.WriteLine("Called SpecificRequest()" );
  }
}

/// <summary>
/// Client test
/// </summary>
public class Client
{
  public static void Main(string[] args)
  {
    // Create adapter and place a request
    Target t = new Adapter();
    t.Request();

  }
}

This real-world code demonstrates the use of a legacy chemical databank. Chemical compound objects access the databank through an Adapter interface.


using System;

// "Target"

class ChemicalCompound
{
  // Fields
  protected string name;
  protected float boilingPoint;
  protected float meltingPoint;
  protected double molecularWeight;
  protected string molecularFormula;

  // Constructors
  public ChemicalCompound( string name )
  {
    this.name = name;
  }

  // Properties
  public float BoilingPoint
  {
    get{ return boilingPoint; }
  }

  public float MeltingPoint
  {
    get{ return meltingPoint; }
  }

  public double MolecularWeight
  {
    get{ return molecularWeight; }
  }

  public string MolecularFormula
  {
    get{ return molecularFormula; }
  }
}

// "Adapter"

class Compound : ChemicalCompound
{
  // Fields
  private ChemicalDatabank bank;

  // Constructors
  public Compound( string name ) : base( name )
  {
    // Adaptee
    bank = new ChemicalDatabank();
    // Adaptee request methods
    boilingPoint = bank.GetCriticalPoint( name, "B" );
    meltingPoint = bank.GetCriticalPoint( name, "M" );
    molecularWeight = bank.GetMolecularWeight( name );
    molecularFormula = bank.GetMolecularStructure( name );
  }

  // Methods
  public void Display()
  {
    Console.WriteLine("\nCompound: {0} ------ ",name );
    Console.WriteLine(" Formula: {0}",MolecularFormula);
    Console.WriteLine(" Weight : {0}",MolecularWeight );
    Console.WriteLine(" Melting Pt: {0}",MeltingPoint );
    Console.WriteLine(" Boiling Pt: {0}",BoilingPoint );
  }
}

// "Adaptee"

class ChemicalDatabank
{
  // Methods -- the Databank 'legacy API'
  public float GetCriticalPoint( string compound, string point )
  {
    float temperature = 0.0F;
    // Melting Point
    if( point == "M" )
    {
      switch( compound.ToLower() )
      {
        case "water": temperature = 0.0F; break;
        case "benzene" : temperature = 5.5F; break;
        case "alcohol": temperature = -114.1F; break;
      }
    }
    // Boiling Point
    else
    {
      switch( compound.ToLower() )
      {
        case "water": temperature = 100.0F;break;
        case "benzene" : temperature = 80.1F; break;
        case "alcohol": temperature = 78.3F; break;
      }
    }
    return temperature;
  }

  public string GetMolecularStructure( string compound )
  {
    string structure = "";
    switch( compound.ToLower() )
    {
      case "water": structure = "H20"; break;
      case "benzene" : structure = "C6H6"; break;
      case "alcohol": structure = "C2H6O2"; break;
    }
    return structure;
  }

  public double GetMolecularWeight( string compound )
  {
    double weight = 0.0;
    switch( compound.ToLower() )
    {
      case "water": weight = 18.015; break;
      case "benzene" : weight = 78.1134; break;
      case "alcohol": weight = 46.0688; break;
    }
    return weight;
  }
}

/// <summary>
/// AdapterApp test application
/// </summary>
public class AdapterApp
{
  public static void Main(string[] args)
  {
    // Retrieve and display water characteristics
    Compound water = new Compound( "Water" );
    water.Display();

    // Retrieve and display benzene characteristics
    Compound benzene = new Compound( "Benzene" );
    benzene.Display();

    // Retrieve and display alcohol characteristics
    Compound alcohol = new Compound( "Alcohol" );
    alcohol.Display();

  }
}

Provide a surrogate or placeholder for another object to control access to it.

The classes and/or objects participating in the Proxy pattern are: Proxy   (MathProxy) maintains a reference that lets the proxy access the real subject. Proxy may refer to a Subject if the RealSubject and Subject interfaces are the same. provides an interface identical to Subject's so that a proxy can be substituted for for the real subject. controls access to the real subject and may be responsible for creating and deleting it. other responsibilites depend on the kind of proxy: remote proxies are responsible for encoding a request and its arguments and for sending the encoded request to the real subject in a different address space. virtual proxies may cache additional information about the real subject so that they can postpone accessing it. For example, the ImageProxy from the Motivation caches the real images's extent. protection proxies check that the caller has the access permissions required to perform a request. Subject   (IMath) defines the common interface for RealSubject and Proxy so that a Proxy can be used anywhere a RealSubject is expected. RealSubject   (Math) defines the real object that the proxy represents.

This real-world code demonstrates the Remote Proxy pattern which provides a representative object that controls access to another object in a different AppDomain. 

   

// Proxy pattern -- Real World example

using System; using System.Runtime.Remoting; // "Subject" public interface IMath {   // Methods   double Add( double x, double y );   double Sub( double x, double y );   double Mul( double x, double y );   double Div( double x, double y ); } // "RealSubject" class Math : MarshalByRefObject, IMath {   // Methods   public double Add( double x, double y ){ return x + y; }   public double Sub( double x, double y ){ return x - y; }   public double Mul( double x, double y ){ return x * y; }   public double Div( double x, double y ){ return x / y; } } // Remote "Proxy Object" class MathProxy : IMath {   // Fields   Math math;   // Constructors   public MathProxy()   {     // Create Math instance in a different AppDomain     AppDomain ad = System.AppDomain.CreateDomain(                                  "MathDomain",null, null );     ObjectHandle o =        ad.CreateInstance("Proxy_RealWorld", "Math", false,       System.Reflection.BindingFlags.CreateInstance,        null, null, null,null,null );     math = (Math) o.Unwrap();   }   // Methods   public double Add( double x, double y )   {     return math.Add(x,y);   }   public double Sub( double x, double y )   {     return math.Sub(x,y);   }   public double Mul( double x, double y )   {     return math.Mul(x,y);   }   public double Div( double x, double y )   {     return math.Div(x,y);   } } /// <summary> /// ProxyApp test /// </summary> public class ProxyApp {   public static void Main( string[] args )   {     // Create math proxy     MathProxy p = new MathProxy();     // Do the math     Console.WriteLine( "4 + 2 = {0}", p.Add( 4, 2 ) );     Console.WriteLine( "4 - 2 = {0}", p.Sub( 4, 2 ) );     Console.WriteLine( "4 * 2 = {0}", p.Mul( 4, 2 ) );     Console.WriteLine( "4 / 2 = {0}", p.Div( 4, 2 ) );   } }