博客园_蜡笔小巢

通过Java SE 7自带的监控服务（WatchService API）实现类似.NET FileWatcher的功能

2011-08-04T03:00:00Z

转自：王翔《模式——工程化实现及扩展》（设计模式Java 版）

http://www.cnblogs.com/callwangxiang/

Java SE 7 Tutorial中增加了一个监控目录变更情况的示例，用于介绍其新发布的WatchService API。

但对于用惯了.NET FileWatcher的用户而言，如果用于项目我认为它有两个欠缺：

1、应该提供一个独立线程后台运行机制，让这个监控过程自己在后台转，不影响前端处理

2、 Java不像.NET有内置的源生事件机制，不过可以借助它内置的Observer/Observable对象用观察者模式实现准事件

下面是把Java SE Tutorial示例中无关内容删除，补充上述两个扩展后的实现，因为这个API比较新，也希望能和大家多多探讨：

1、参考.NET定义事件参数对象

package marvellousworks.practicalpattern.concept.unittest;

import java.nio.file.WatchEvent.Kind;

/**
* 文件系统事件类型
* @author wangxiang
*
*/
public final class FileSystemEventArgs {
    private final String fileName;
    private final Kind<?> kind;

    public FileSystemEventArgs(String fileName, Kind<?> kind){
        this.fileName = fileName;
        this.kind = kind;
    }

    /**
     * 文件的路径
     */
    public String getFileName(){return fileName;}

    /**
     * 操作类型：变更、创建、删除
     */
    @SuppressWarnings("rawtypes")
    public Kind getKind(){return kind;}
}

2、定义DirectoryWatcher，用于监控某个文件夹，至于如何扩展FileWatcher则可以在这个基础上通过限定文件名称和操作类型的方式扩展

package marvellousworks.practicalpattern.concept.unittest;

import java.io.IOException;
import java.nio.file.FileSystems;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.WatchEvent;
import java.nio.file.WatchEvent.Kind;
import java.nio.file.WatchKey;
import java.nio.file.WatchService;
import java.util.Observable;
import java.util.concurrent.Callable;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

import static java.nio.file.StandardWatchEventKinds.*;

/**
* 监控一个目录内文件的更新、创建和删除事件（不包括子目录）
*
* 对于http://download.oracle.com/javase/tutorial/essential/io/notification.html进行了改造
* 使其更接近.NET的DirectoryWatcher使用习惯
*
* 由于java没有类似.NET源生的事件机制
* 因此实现上采用了Java SE自带的Observer/Observable对象对外抛出“假”事件
*
* 适于Java SE 7
*
* @author wangxiang
*
*/
public class DirectoryWatcher extends Observable{

    private WatchService watcher;
    private Path path;
    private WatchKey key;
    private Executor executor = Executors.newSingleThreadExecutor();

    FutureTask<Integer> task = new FutureTask<Integer>(
            new Callable<Integer>(){
                public Integer call() throws InterruptedException{
                    processEvents();
                    return Integer.valueOf(0);}});

    @SuppressWarnings("unchecked")
    static <T> WatchEvent<T> cast(WatchEvent<?> event) {
        return (WatchEvent<T>) event;
    }

    public DirectoryWatcher(String dir) throws IOException {
        watcher = FileSystems.getDefault().newWatchService();
        path = Paths.get(dir);
        //    监控目录内文件的更新、创建和删除事件
        key = path.register(watcher, ENTRY_MODIFY, ENTRY_CREATE, ENTRY_DELETE);
    }

    /**
     * 启动监控过程
     */
    public void execute(){
        // 通过线程池启动一个额外的线程加载Watching过程
        executor.execute(task);
    }

    /**
     * 关闭后的对象无法重新启动
     * @throws IOException
     */
    public void shutdown() throws IOException {
        watcher.close();
        executor = null;
    }

    /**
     * 监控文件系统事件
     */
    void processEvents() {
        while (true) {
            // 等待直到获得事件信号
            WatchKey signal;
            try {
                signal = watcher.take();
            } catch (InterruptedException x) {
                return;
            }

            for (WatchEvent<?> event : signal.pollEvents()) {
                Kind<?> kind = event.kind();

                // TBD - provide example of how OVERFLOW event is handled
                if (kind == OVERFLOW) {
                    continue;
                }

                // Context for directory entry event is the file name of entry
                WatchEvent<Path> ev = cast(event);
                Path name = ev.context();
                notifiy(name.getFileName().toString(), kind);
            }
            //    为监控下一个通知做准备
            key.reset();
        }
    }

    /**
     * 通知外部各个Observer目录有新的事件更新
     */
    void notifiy(String fileName, Kind<?> kind){
        // 标注目录已经被做了更改
        setChanged();
        //     主动通知各个观察者目标对象状态的变更
        //    这里采用的是观察者模式的“推”方式
        notifyObservers(new FileSystemEventArgs(fileName, kind));
    }
}

3、单元测试

package marvellousworks.practicalpattern.concept.unittest;

import static org.junit.Assert.*;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
import java.util.Observer;

import org.junit.Test;
import static java.nio.file.StandardWatchEventKinds.*;

public class DirectoryWatcherFixture {

    private static final String DIR_PATH =System.getProperty("user.dir");
    private static final File DIR = new File(DIR_PATH);
    private static final String SUFFIX = ".txt";
    private static final String PREFIX = "test";
    private static final int ADD_TIMES = 3;

    /**
     * 观察者
     * @author wangxiang
     *
     */
    public class Logger implements Observer{
        @Override
        public void update(Observable observable, Object eventArgs) {
            FileSystemEventArgs args = (FileSystemEventArgs) eventArgs;
            System.out.printf("%s has been %s\n", args.getFileName(), args.getKind());
            assertTrue(args.getFileName().startsWith(PREFIX));
                assertEquals(ENTRY_CREATE, args.getKind());
        }
    }

    @Test
    public void testWatchFile() throws IOException, InterruptedException{
        DirectoryWatcher watcher = new DirectoryWatcher(DIR_PATH);
        Logger l1 = new Logger();
        watcher.addObserver(l1);
        watcher.execute();

        //    创建一系列临时文件
        List<String> files = new ArrayList<>();
        for(int i=0; i<ADD_TIMES; i++){
            files.add(File.createTempFile(PREFIX, SUFFIX, DIR).toString());
        }

        //    延迟等待后台任务的执行
        Thread.sleep(4000);
        watcher.shutdown();
        System.out.println("finished");
    }
}

Console窗口显示的测试内容

test5769907807190550725.txt has been ENTRY_CREATE
test4657672246246330348.txt has been ENTRY_CREATE
test1823102943601166149.txt has been ENTRY_CREATE
finished

本文链接

原型模式要克隆什么？

2011-07-02T15:06:00Z

转自：《模式——工程化实现及扩展》（设计模式C#版和Java版）

http://www.cnblogs.com/callwangxiang/

原型模式梗概：它构造的过程就是选择一个对象（被称为原型对象或“样本”），通过调用它的“克隆”方法就获得一个和它一样的对象，一般我们称这个克隆出的结果为 “副本”。

项目中，原型模式有些悲哀，因为它总是被大家忘掉。但在.NET Framework/JVM底层，克隆本身又是个By Design的内置机制，客户端、服务器端传递业务对象本身就是咫尺天涯，克隆对象必不可少。

软件系统中往往总存在某个不稳定的业务领域，其中类型的变化和扩充别频繁，不仅是继承深度上的，还有可能是来自于平级类型的宽度上的。按照前面的思路，为了尽量让客户程序构造它们的时候不必与每个具体类型产生深度或广度上的直接依赖，需要借助其他对象来封装这个new()的过程。之前我们介绍过简单工厂、工厂方法模式和抽象工厂模式，但如果对象类型的变化相对太频繁，有时候“没完没了”地为它们创建各种工厂不值得。

经典原型模式用的就是这个思路：

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

仔细解读还可以发现尽管一般设计模式书籍的示例都会克隆整个目标实例，但在经典原型模式的介绍中并没有这个要求。与生活中的克隆技术一样，有的科学家在克隆羊、克隆牛甚至在偷偷摸摸的克隆人，但还有很多科学家专注于克隆人体的一部分，比如：心脏、上肢……，实际项目中我们使用原型模式时也可以借鉴这个思路，

比如：

一个复杂对象的可能提供clone()方法克隆整个对象
也可以同时提供clonePartA()、clonePartB()等方法克隆出局部对象
进一步，甚至可以克隆出相对独立的其他类型，就好像我们克隆一个博文对象，克隆的不是整个博文、也不是其中的文字、插图，而是在1024 x 768分辨率下这篇博文的在IE 8.0下一个截图（Image类型）

另外，有的时候我们需要构造不是“若只如初见”的类型实例，而是需要构造与某个对象“当时”状态一样的实例。

本文链接

难念的经——Java命名规范

2011-06-14T02:50:00Z

最近在对书稿的Java分册代码进行统稿。

因为现在看到的《Code Conventions for the Java TM Programming Language》还是上世纪的，最近一次修订是1999年，所以就咨询了很多专门做Java的朋友。

大家很热心，各位朋友推荐推荐看了很多资料，《实现模式》、Java SDK的源码以及AspectJ、Hibernate，结果越念越糊涂。

看了几个库，就连Java SE标准库自己的源码命名风格也是百花齐放。

有的开始参考C#，用Ixxxx表示接口，有的还是沿用现有的。
对于内部类的命名就更有意思了。
而且命名Control类的时候，有的用现在分词、有的用过去分词，有的用使能动词....

难道Java自己的标准库不是ORACLE（以前是SUN）一家生产的？

我其实只想知道有关泛型、事件、反射、标注、配置文件节点的一个官方命名规范。

本文链接

C# 实现设计模式应该不拘一格

2011-06-12T04:56:00Z

如同每个人都有其个性一样，每种开发语言也有自己的个性。

项目中，我们固然可以机械地将一种语言的开发经验套用到另一种语言，但效果不一定好，因为：

· 语言有自己的短处：用短处去实现不仅费时费力，结果也不理想

· 语言有自己的长处：但为了沿用以前的经验削足适履，没有用到语言的精要，结果是暴殄天物

相信你也发现了，用一个语言写Hello world是一回事、写一个应用是一回事、写好一个应用则完全是另一回事，这就是工程化代码和“玩具”代码的区别。教科书上的知识落实到工程不能按图索骥，需要考虑开发语言和目标环境，设计模式也不例外。

也许你会觉用泛型、委托、事件、属性、配置文件等方式实现与《设计模式》介绍的内容不一致，但别忘了《设计模式》一书出版至今已近20年，其间无论是开发语言还是技术平台已经“换了人间”，GOF 23个模式的思想不仅影响着我们更影响着走在技术前沿的语言设计者、平台设计者，他们也在工作中潜移默化的把模式思想融入自己的工作成果，作为用户我们“推却”别人的盛情，所有事情都从“车轮”做起，多少有点不经济。

项目中，我们应该用最“C#”的方式将自己对于设计模式的理解铸入自己的成果，而且实现上务求简洁、直接。

本文链接

继承——若只如初见

2011-06-06T04:13:00Z

相信在开始学习C++、Java、C#等面向对象语言的时候，你总是先接触到继承概念。

老师或书籍总是通过继承让我们相信面向对象开发可以大大节省编码量，因为需要一个新特性的类型时，扩展并添加一两个方法就可以了。

但工作几年后，我们自己逐渐发现继承不总是那么好，尤其当你的设计处于继承结构的底层的时候，每次修改总是牵扯面太大,不愿意或者不敢去修改这些内容。然后，我们借鉴Delphi早期类库设计的技巧，把底层类的大部分方法都定义为虚方法，结果随着项目代码规模的扩大，开发期最灵活的设计往往到了生产环境却造成最难排查的问题。

最后，我们接受了基于接口编程的思路。设计模式也一直倡导组合优于继承的概念，尤其在C#、Java等语言彻底不支持多继承之后，我们才把目光从“堆积”类变成“捆绑”接口。

如果在一开始学习的时候就有人提示一下多好。

继承若只如初见。

本文链接

《模式——工程化实现及扩展》（设计模式C# 版）《原型模式 Prototype》——“自我检验" 参考答案

2011-06-02T07:35:00Z

转自：《模式——工程化实现及扩展》（设计模式C# 版）

http://www.cnblogs.com/callwangxiang/

http://www.cnblogs.com/callwangxiang/archive/2011/06/02/ExerciseAAPrototype.html的参考答案

参考答案

1、修改Enterprise类，提供符合申报条件的有选择的序列化

[Serializable]
class Enterprise : ISerializable
{
    const string NameItem = "NAME";
    const string ProjectsItem = "PROJECTS";
    const string StaffItem = "STAFF";
    const string ProjectManagerItem = "PM";

    private readonly Certification ProfessionalPm =
        new Certification()
            {
                Name = ProjectManagerItem,
                Qualification = QualificationOptions.Professional
            };

    public string Name { get; set; }
    public Project[] Projects { get; set; }
    public Employee[] Staff { get; set; }

    /// <summary>
    /// 构造函数
    /// </summary>
    public Enterprise()
    {
    }

    /// <summary>
    /// 构造函数
    /// 还原过程
    /// </summary>
    /// <param name="info"></param>
    /// <param name="context"></param>
    protected Enterprise(SerializationInfo info, StreamingContext context)
    {
        Name = info.GetString(NameItem);
        Projects = (Project[])info.GetValue(ProjectsItem, typeof(Project[]));
        Staff = (Employee[])info.GetValue(StaffItem, typeof(Employee[]));

    }
/// <summary>
    /// 原型方法
    /// </summary>
    /// <returns></returns>
    /// <remarks>作为示例，没有抽象独立的原型类型接口IPrototype</remarks>
    public Enterprise Clone()
    {
        var graph = SerializationHelper.SerializeObjectToString(this);
        return SerializationHelper.DeserializeStringToObject<Enterprise>(graph);

    }
/// <summary>
    /// 自定义序列化过程
    /// </summary>
    /// <param name="info"></param>
    /// <param name="context"></param>
    public void GetObjectData(SerializationInfo info, StreamingContext context)

    {
        info.AddValue(NameItem, Name);if ((Projects != null) && (Projects.Count() > 0))
        {
            var items = Projects.Where
                (
                    x =>
                    (DateTime.Now.Year - x.EndYear <= 2)
                    && x.Scale > 3000
                );
            if (items != null)
                info.AddValue(ProjectsItem, items.ToArray());
        }
        if (Staff != null)
        {
            var items =
                from employee in Staff
                where
                    (employee.Certificates != null)
                    && (employee.Certificates.Count() > 0)
                    && (employee.Certificates.Where(x =>
                        string.Equals(x.Name, ProjectManagerItem) &&
                        x.CompareTo(ProfessionalPm) >= 0).Count() > 0)

                select new Employee()
                {
                    Name = employee.Name,
                    Certificates = employee.Certificates.Where(x => x.CompareTo(ProfessionalPm) > 0).ToArray()
                };
            if ((items != null) && (items.Count() > 0))
                info.AddValue(StaffItem, items.ToArray());
        }
    }

2、准备测试数据

Enterprise enterprise;

[TestInitialize]
public void Initialize()
{
    var thisYear = DateTime.Now.Year;
    enterprise = new Enterprise()
                {
                    Name = "A",
                    Projects = new Project[]
                            {
                                //  金额不符合
                                new Project() {EndYear = thisYear, Scale = 1500},
                                //  符合
                                new Project() {EndYear = thisYear - 1, Scale = 3500},
                                //  时间不符合
                                new Project() {EndYear = thisYear - 3, Scale = 5000},
                                //  符合
                                new Project() {EndYear = thisYear - 1, Scale = 7500}
                            },
                    Staff = new Employee[]
                            {
                                // PM级别不符合
                                new Employee(){
                                    Name = "E1",
                                    Certificates = new Certification[]
                                                                {
                                                                    new Certification()
                                                                        {
                                                                            Name="PM",
                                                                            Qualification = QualificationOptions.Assisstant
                                                                        },
                                                                    new Certification()
                                                                        {
                                                                            Name="ARCH",
                                                                            Qualification = QualificationOptions.Professional
                                                                        }
                                                                }
                                },
                                // 符合
                                new Employee(){
                                    Name = "E2",
                                    Certificates = new Certification[]
                                                                {
                                                                    new Certification()
                                                                        {
                                                                            Name="PM",
                                                                            Qualification = QualificationOptions.Assisstant
                                                                        },
                                                                    new Certification()
                                                                        {
                                                                            Name="PM",
                                                                            Qualification = QualificationOptions.Senior
                                                                        }
                                                                }
                                },
                                // 证书类别不符合
                                new Employee(){
                                    Name = "E3",
                                    Certificates = new Certification[]
                                                                {
                                                                    new Certification()
                                                                        {
                                                                            Name="ARCH",
                                                                            Qualification = QualificationOptions.Assisstant
                                                                        },
                                                                    new Certification()
                                                                        {
                                                                            Name="ARCH",
                                                                            Qualification = QualificationOptions.Senior
                                                                        }
                                                                }
                                },
                                // 符合
                                new Employee(){
                                    Name = "E4",
                                    Certificates = new Certification[]
                                                                {
                                                                    new Certification()
                                                                        {
                                                                            Name="PM",
                                                                            Qualification = QualificationOptions.Assisstant
                                                                        },
                                                                    new Certification()
                                                                        {
                                                                            Name="PM",
                                                                            Qualification = QualificationOptions.Professional
                                                                        },
                                                                    new Certification()
                                                                        {
                                                                            Name="PM",
                                                                            Qualification = QualificationOptions.Assisstant
                                                                        },
                                                                    new Certification()
                                                                        {
                                                                            Name="PM",
                                                                            Qualification = QualificationOptions.Principal
                                                                        }
                                                                }
                                },

                            }
                };
}

3、执行单元测试

[TestMethod]
public void Test()
{
    Initialize();
    var clone = enterprise.Clone();
    Assert.AreEqual<string>(enterprise.Name, clone.Name);

    //  企业结项项目信息
    Assert.AreEqual<int>(2, clone.Projects.Count());

    //  企业人员信息
    Assert.AreEqual<int>(2, clone.Staff.Count());
}

Output窗口测试结果

------ Test started: Assembly: Prototype.Tests.dll ------

1 passed, 0 failed, 0 skipped, took 0.32 seconds (Ad hoc).

本文链接

《模式——工程化实现及扩展》（设计模式C# 版）《原型模式 Prototype》——“自我检验"

2011-06-02T07:28:00Z

转自：《模式——工程化实现及扩展》（设计模式C# 版）

http://www.cnblogs.com/callwangxiang/

自我检验

假设由你完成一个企业申报数据序列化的程序，企业信息实体需要按照“计算机信息系统集成资质”1级的要求将满足申报条件的信息序列化。请结合本章介绍的自定义深层复制方式，实现原型对象，并通过单元测试验证。

为了便于示例，对“计算机信息系统集成资质”1级的要求节选如下：

1、近三年内完成至少两项3000万元以上系统集成项目

2、具有计算机信息系统集成项目经理人数不少于25名，其中高级项目经理人数不少于8名

示例并不对企业整体是否满足申报要求进行审核，仅对满足申报要求的类成员进行筛选。示例涉及的数据结构如下，请改造Enterprise类为原型模式类型：

[Serializable]
class Project
{
    /// <summary>
    /// 结项年份
    /// </summary>
    public int EndYear { get; set; }

    /// <summary>
    /// 项目资金规模(万元)
    /// </summary>
    public double Scale { get; set; }
}

[Flags]
enum QualificationOptions
{
    Assisstant,      //  助理级
    Professional,    //  专家级
    Senior,          //  高级、资深级
    Principal        //  主任、主管级
}

[Serializable]
class Certification : IComparable<Certification>
{
    public string Name { get; set; }
    public QualificationOptions Qualification { get; set; }

    public int CompareTo(Certification other)
    {
        if(other == null) throw new ArgumentNullException("other");
        if(!string.Equals(other.Name, Name)) throw new NotSupportedException();
        if(Qualification == other.Qualification) return 0;
        return Qualification > other.Qualification ? 1 : -1;
    }
}

[Serializable]
class Employee
{
    public string Name { get; set; }
    public Certification[] Certificates { get; set; }
}

[Serializable]
class Enterprise : ISerializable
{
    public string Name { get; set; }
    public Project[] Projects { get; set; }
    public Employee[] Staff { get; set; }
}

本文链接

《模式——工程化实现及扩展》（设计模式C# 版）《连贯接口 Fluent Interface》——“自我检验"参考答案

2011-05-31T15:27:00Z

转自：《模式——工程化实现及扩展》（设计模式C# 版）

http://www.cnblogs.com/callwangxiang/

http://www.cnblogs.com/callwangxiang/archive/2011/05/31/ExerciseAAFluentInterface.html的参考答案

参考答案

设计要点：

采用连贯接口设计表格的创建过程
由于表格Head涉及一层嵌套、Body涉及两层嵌套，因此为了便于调整和修改，每个节点元素类型都要保留回溯到父节点的引用

1、设计具有Fluent特征的抽象节点类型

/// <summary>
/// 修改后具有Fluent特征的集合类型
/// </summary>
/// <typeparam name="T">集合元素类型</typeparam>
/// <typeparam name="TParent">父节点类型</typeparam>
class FluentCollection<TElement, TParent>
    where TElement : class 
    where TParent : class 
{
    protected List<TElement> list = new List<TElement>();
    TParent parent;

    public FluentCollection(TParent parent)
    {
        if(parent == null) throw new ArgumentNullException("parent");
        this.parent = parent;
    }

    /// <summary>
    /// 返回父节点
    /// </summary>
    public TParent Parent{get{ return parent;}}

    /// <summary>
    /// 如何获得一个TElement类型实例的委托
    /// </summary>
    public Func<TElement> GetInstance { get; set; }

    /// <summary>
    /// 具有fluent特征的追加操作
    /// </summary>
    /// <param name="t"></param>
    /// <returns></returns>
    public FluentCollection<TElement, TParent> Add(TElement t)
    {
        list.Add(t);
        return this;
    }

    /// <summary>
    /// 具有fluent特征的空置操作
    /// </summary>
    /// <returns></returns>
    public FluentCollection<TElement, TParent> Skip
    {
        get
        {
            list.Add(GetInstance());
            return this;
        }
    }

    /// <summary>
    /// 执行LINQ的foreach操作
    /// </summary>
    /// <param name="action"></param>
    public void ForEach(Action<TElement> action)
    {
        list.ForEach(action);
    }
}

/// <summary>
/// 父节点为table的元素
/// </summary>
class WithTableObject
{
    Table table;    //  父节点
    public WithTableObject(Table table)
    {
        if(table == null) throw new ArgumentNullException("table");
        this.table = table;
    }

    /// <summary>
    /// 指向父节点——table
    /// </summary>
    public Table Parent{get{ return table;}}
}

2、定义各个节点类型

class Notation
{
    public Notation(){Data = string.Empty;}
    public Notation(string data) {Data = data; }
    public string Data { get; private set; }
}

/// <summary>
/// n元素
/// </summary>
class Item : Notation
{
    public Item():base(){}
    public Item(string data) : base(data){}
}

/// <summary>
/// col 元素
/// </summary>
class Column : Notation
{
    public Column():base(){}
    public Column(string data) : base(data) { }
}

/// <summary>
/// line 元素 
/// </summary>
class Line
{
    FluentCollection<Item, Line> items;
    Body body;

    public Line(Body body)
    {
        if(body == null) throw new ArgumentNullException("body");
        this.body = body;
        items = new FluentCollection<Item, Line>(this)
                    {
                        GetInstance = () => { return new Item(); }
                    };
    }

    /// <summary>
    /// 父节点
    /// </summary>
    public Body Body { get { return body; } }
        
    public FluentCollection<Item, Line> Items { get { return items; } }

    public Line NewLine{get{return body.NewLine;}}
}


/// <summary>
/// body 元素
/// </summary>
class Body : WithTableObject
{
    List<Line> lines = new List<Line>();
    public Body(Table table) : base(table){}

    public Line NewLine
    {
        get
        {
            var line = new Line(this);
            lines.Add(line);
            return line;
        }
    }

    public List<Line> Lines { get { return lines;}}
} 

/// <summary>
/// head 元素
/// </summary>
class Head : WithTableObject
{
    FluentCollection<Column, Head> columns;

    public Head(Table table) : base(table)
    {
        columns = new FluentCollection<Column, Head>(this)
                        {
                            GetInstance = () => { return new Column(); }
                        };
    }
        
    public FluentCollection<Column, Head> Columns { get { return columns; } }
}

    
class Table
{
    string name;
    Body body;
    Head head;

    public Table()
    {
        body = new Body(this);
        head = new Head(this);
    }

    public Table Name(string name)
    {
        if(string.IsNullOrEmpty(name)) throw new ArgumentNullException("name");
        this.name = name;
        return this;
    }

    public override string ToString(){return name;}

    public Body Body{get{ return body;}}
    public Head Head{get{ return head;}}
}

3、定义生成电子表格的数据类型

class Notation
{
    public Notation(){Data = string.Empty;}
    public Notation(string data) {Data = data; }
    public string Data { get; private set; }
}

/// <summary>
/// n元素
/// </summary>
class Item : Notation
{
    public Item():base(){}
    public Item(string data) : base(data){}
}

/// <summary>
/// col 元素
/// </summary>
class Column : Notation
{
    public Column():base(){}
    public Column(string data) : base(data) { }
}

/// <summary>
/// line 元素 
/// </summary>
class Line
{
    FluentCollection<Item, Line> items;
    Body body;

    public Line(Body body)
    {
        if(body == null) throw new ArgumentNullException("body");
        this.body = body;
        items = new FluentCollection<Item, Line>(this)
                    {
                        GetInstance = () => { return new Item(); }
                    };
    }

    /// <summary>
    /// 父节点
    /// </summary>
    public Body Body { get { return body; } }
        
    public FluentCollection<Item, Line> Items { get { return items; } }

    public Line NewLine{get{return body.NewLine;}}
}


/// <summary>
/// body 元素
/// </summary>
class Body : WithTableObject
{
    List<Line> lines = new List<Line>();
    public Body(Table table) : base(table){}

    public Line NewLine
    {
        get
        {
            var line = new Line(this);
            lines.Add(line);
            return line;
        }
    }

    public List<Line> Lines { get { return lines;}}
} 

/// <summary>
/// head 元素
/// </summary>
class Head : WithTableObject
{
    FluentCollection<Column, Head> columns;

    public Head(Table table) : base(table)
    {
        columns = new FluentCollection<Column, Head>(this)
                        {
                            GetInstance = () => { return new Column(); }
                        };
    }
        
    public FluentCollection<Column, Head> Columns { get { return columns; } }
}

    
class Table
{
    string name;
    Body body;
    Head head;

    public Table()
    {
        body = new Body(this);
        head = new Head(this);
    }

    public Table Name(string name)
    {
        if(string.IsNullOrEmpty(name)) throw new ArgumentNullException("name");
        this.name = name;
        return this;
    }

    public override string ToString(){return name;}

    public Body Body{get{ return body;}}
    public Head Head{get{ return head;}}
}

4、单元测试

[TestClass]
public class FluentInterfaceFixture
{
    TableWriter writer;

    [TestInitialize]  
    public void Initialize()
    {
        writer = new TableWriter();
    }

    [TestMethod]
    public void TestFullFillTable()
    {
        writer.Output(
            new Table()
                .Name("full fill")
                .Head
                    .Columns
                        .Add(new Column("first"))
                        .Add(new Column("second"))
                        .Add(new Column("thrid"))
                    .Parent
                .Parent
                .Body
                    .NewLine.Items.Add(new Item("11")).Add(new Item("12")).Add(new Item("13")).Parent
                    .NewLine.Items.Add(new Item("21")).Add(new Item("22")).Add(new Item("23")).Parent
                .Body
            .Parent
            );
    }

    [TestMethod]
    public void TestSkipColumnTable()
    {
        writer.Output(
            new Table()
                .Name("skip columns")
                .Head
                    .Columns
                        .Add(new Column("first"))
                        .Skip
                        .Add(new Column("thrid"))
                    .Parent
                .Parent
                .Body
                    .NewLine.Items.Add(new Item("11")).Add(new Item("12")).Add(new Item("13")).Parent
                    .NewLine.Items.Add(new Item("21")).Add(new Item("22")).Add(new Item("23")).Parent
                .Body
            .Parent
            );
    }

    [TestMethod]
    public void TestSkiItemsTable()
    {
        writer.Output(
            new Table()
                .Name("skip items")
                .Head
                    .Columns
                        .Add(new Column("first"))
                        .Add(new Column("second"))
                        .Add(new Column("thrid"))
                    .Parent
                .Parent
                .Body
                    .NewLine.Items.Add(new Item("11")).Skip.Add(new Item("13")).Parent
                    .NewLine.Items.Add(new Item("21")).Add(new Item("22")).Skip.Parent
                .Body
            .Parent
            );
    }


    [TestMethod]
    public void TestSkipColumnsAndItemsTable()
    {
        writer.Output(
            new Table()
                .Name("skip columns and items")
                .Head
                    .Columns
                        .Add(new Column("first"))
                        .Skip
                        .Add(new Column("thrid"))
                    .Parent
                .Parent
                .Body
                    .NewLine.Items.Add(new Item("11")).Skip.Add(new Item("13")).Parent
                    .NewLine.Items.Add(new Item("21")).Add(new Item("22")).Skip.Parent
                .Body
            .Parent
            );
    }
}

5、测试结果

------ Test started: Assembly: Concept.Tests.dll ------

<table>
    <name>full fill</name>
    <head>
<col>first</col><col>second</col><col>thrid</col>    
    </head>
    <body>
        <line>
        <item>
<n>11</n><n>12</n><n>13</n>            
        </item>
        <item>
<n>21</n><n>22</n><n>23</n>            
        </item>
    </line>
    </body>
</table>

<table>
    <name>skip columns</name>
    <head>
<col>first</col><col></col><col>thrid</col>    
    </head>
    <body>
        <line>
        <item>
<n>11</n><n>12</n><n>13</n>            
        </item>
        <item>
<n>21</n><n>22</n><n>23</n>            
        </item>
    </line>
    </body>
</table>

<table>
    <name>skip items</name>
    <head>
<col>first</col><col>second</col><col>thrid</col>    
    </head>
    <body>
        <line>
        <item>
<n>11</n><n></n><n>13</n>            
        </item>
        <item>
<n>21</n><n>22</n><n></n>            
        </item>
    </line>
    </body>
</table>

<table>
    <name>skip columns and items</name>
    <head>
<col>first</col><col></col><col>thrid</col>    
    </head>
    <body>
        <line>
        <item>
<n>11</n><n></n><n>13</n>            
        </item>
        <item>
<n>21</n><n>22</n><n></n>            
        </item>
    </line>
    </body>
</table>

4 passed, 0 failed, 0 skipped, took 1.29 seconds (MSTest 10.0).

测试确认Fluent接口的有效性

本文链接

《模式——工程化实现及扩展》（设计模式C# 版）《连贯接口 Fluent Interface》——“自我检验"

2011-05-31T01:46:00Z

转自：《模式——工程化实现及扩展》（设计模式C# 版）

http://www.cnblogs.com/callwangxiang/

由你负责开发一个生成表格的程序，表格的格式定义如下：

要求：
1、<head>和<body>部分都是可选项
2、<head>中<col>部分是可选项、<body>中<line>部分是可选项、<line>中<n>部分是可选项
3、允许表格中某些<col>的名称和<n>的内容为空
4、表格自上向下、自左向右逐行生成
5、最终生成的表格必须是行列平衡的，空白部分用空字符填满

请参考本章介绍的连贯接口设计表格生成类，并通过单元测试验证。

本文链接

《模式——工程化实现及扩展》再版前言

2011-05-29T02:58:00Z

丛书内容

本系列在《设计模式——基于C#的工程化实现及扩展》的基础上充实完成，本系列本次版本面向C#开发者和Java开发提供如下4册图书：

· 模式——工程化实现及扩展（设计模式C# 版）

· 模式——工程化实现及扩展（架构模式C# 版）

· 模式——工程化实现及扩展（设计模式Java版）

· 模式——工程化实现及扩展（架构模式Java版）

其中Java版本采用ORACLE JDK 6的编码编码风格编写，面向Java SE & Java EE 5/6平台的专业人员；而C#版采用C# 3/4的编码风格和.NET Framework 3.5/4.0内置的类库编写，面向使用C#的专业人员。

设计模式版本仅介绍GOF 23个设计模式的内容，示例情景也主要面向进程内的类型设计；而架构模式部分则从分布式应用角度介绍部分典型的架构模式、数据访问模式、信息安全模式，尽管类型不同，但均为架构所必须的，所以统一纳入架构模式分册，其示例情景一般也存在跨进程调用，采用的也是分布式组件技术。

丛书定位

不管你拿起的是本系列的Java版本还是C#版本、是设计模式版本还是架构模式版本，它都不是面向入门者的读物。

它的内容是面向中高级开发人员安排的，而部分章节后面的“自我检验”环节，则是针对希望进一步挑战模式技术的软件架构师设计的。

内容要点

本系列的重点不是阐述设计模式GOF和架构模式本身，这些内容应该从《Design Patterns : Elements of Reusable Object-Oriented Software》获得。本系列面向的是模式的实践者。它假设你已经熟悉Java或C#语法，能熟练运用Java 5/6和C# 3.0/4.0语法特性，并能充分发掘其中的实践价值，确保工作成果在JVM和CLR&DLR平台上更简洁、明快的实现。本系列还假设你对Java和C#的编译器有所了解，对于Byte Code或MSIL有一定知识，对于一些要点内容可以从Byte Code或MSIL层面对交付成果进行评析。

注：在没有其他说明的情况下本系列各册所指《设计模式》指的是《Design Patterns : Elements of Reusable Object-Oriented Software》，即翻译为《设计模式：可复用面向对象软件的基础》的这本书。

对于那些已经融入语言或开发平台的模式，比如：GOF中的原型模式、命令模式、策略模式、观察者模式、迭代器模式、访问者模式和架构模式中的MVC模式、管道过滤器

模式等，我们将尽量采用语言自身的机制完成，你可能甚至看不到明显的“模式”痕迹，模式的经典实现仅大体介绍模式意图后简要带过。毕竟，工程中“暴殄天物”不值得提倡。

设计模式和架构模式是对特定前提下重复出现问题的一个普遍解，它是一种思想，使用得当也会对设计、实施提供帮助，从这个角度看它又是实实在在的生产率。从始至终，本系列图书都务求采用最简单、最贴近工程的方式实现每个模式，书中示例的实现方式更多照顾到客户程序，希望客户程序使用时更简便、更方便，同时也会对《设计模式》一书的实现方式进行评析，分析哪些是需要坚持的，哪些是应该放弃的。

示例特点

首先，所有示例代码实现上保持简洁风格，不过考虑到设计模式要解决“变化”问题，所以示例在保持简洁到同时，也适当照顾到“应变”的要求。代码行文时，除非为了突出表示某个抽象接口，否则一行能写完的代码务求不写成多行。这么做主要来自3项非软件领域的启发：孔子的春秋笔法、爱因斯坦的质能方程以及八大山人的墨荷图。

经孔子整理的《春秋》可谓“微言大义”，寥寥数笔就能把我们现在需要长篇大论才表述的内容就铺陈出来，而正是这样的内容却能一直影响我们这个民族2000多年。

在物理领域，爱因斯坦的质能方程已经简单到简无可简的程度，但这个公式在现代物理学中的地位和作用怎么评论也不为过，原因在于“物理上真实的东西一定是逻辑上简单的东西” ，多余的赘述只会令方法和手段更加笨拙。

而八大山人也是秉承这种简洁风格的人中翘楚。我们知道西洋画中需要各种颜色的油彩才能体现出物体的质感和生动性，但八大山人的只用水墨两色就可以活灵活现的展现出画中人物、动物、植物鲜活的生命力，如下图 F1-1中的荷叶无论是脉络、色彩都活灵活现，而荷花寥寥数笔就体现出颜色的对比以及怒放的那种动感。

图 F1-1：八大山人《墨荷图》立轴

回想我们的编写代码未尝不该这样。

很多代码（注释不算）写的长篇累牍，但实际上是在重复制造JDK、.NET Framework或者团队其他成员的工作，而且这种冗长的代码还往往容易出错。我相信，只要有人的参与没有错误的IT系统中国没有、全世界也没有、往后说100年也不可能有，而冗长的代码恰恰增加了这种出错的可能。

因此，本系列所有示例的编码上都尽量务求简单、直接、高效，不管是Java代码还是C#代码，不管是设计模式部分还是架构模式部分。

另外，在每个模式的实现方式上，针对不同的扩展主题本系列将始终沿用这样的优先级编码实现：

· Java和C#语法特性

· 官方Java SE JDK和.NET Framework的框架内容

· 个别情况考虑集成官方资助的开源框架

· 对于其他第三方提供的开源框架，不列入或引入本系列的实现示例

注：

本文中“官方”对Java指ORACLE、C#指微软

在没有其他说明的情况下本系列各册所指《.NET设计规范》指的是微软MSDN文档中发布的.NET设计规范《Design Guidelines for Developing Class Libraries》

如何阅读

本系列图书每章都会先对模式的经典介绍做简要评述，说明其主要意图和典型实现示例，然后会结合语言逐步扩充其使用情景，介绍典型的实现技巧。

为了便于读者使用，建议你按照如下方法阅读本系列各册图书：

1. 了解经典的面向对象设计原则

2. 熟悉所用编程语言的基础上，投入一定时间阅读“重新研读Java语言”或“重新研读C#语言”两章，了解工程化代码与“玩具代码”的实现差异

3. 然后，再阅读各章对模式经典内容的介绍，了解为什么需要这个模式、它主要解决什么问题、经典的实现是怎样的

4. 再次，阅读每章的扩展部分，熟悉不同示例环境下如何用更工程化的方式实现扩展要求。为了节省篇幅，书中代码只是代码片段节选，建议你直接运行示例代码，这样体会更深。

5. 分析和体会单元测试的结果。

6. 逐步结合你自己的项目修改示例代码，真正将书中的“工程化实现和扩展”融入你的实际工作。

为了便于你考察自己对于特定模式的掌握程度，本次再版时在部分章节增加了一个“自我检验”的练习环节，目的是通过一些准案例的介绍，让你灵活应用该章的知识内容，独立思考解决方案。由于解决方案会不断调整和优化，所有的参考答案会发布在我的个人博客，解决方案内容也会根据与大家交流的结果不断优化、动态更新。希望这种方式你能够喜欢。下面是我的个人博客，欢迎你常来看看：

CSDN http://blog.csdn.net/firevision/

博客园 http://www.cnblogs.com/callwangxiang/

ITEye http://callwangxiang.iteye.com/

最后，祝你有更好的阅读体验。

本文链接