语源科技BlogJava-Never give up!

Builder模式的理解

永远的火焰舞者 — Sun, 14 Mar 2010 18:00:00 GMT

      Builder模式是一步一步创建一个复杂的对象，它允许用户可以只通过指定复杂对象的类型和内容就可以构建它们。用户不需要知道内部的具体构建细节。因为一个复杂的对象，不但有很多大量组成部分，如汽车，有很多部件:车轮、方向盘、发动机还有各种小零件等等，部件很多，但远不止这些，如何将这些部件装配成一辆汽车呢？这个装配过程也很复杂(需要很好的组装技术)，Builder模式就是为了将部件和组装过程分开。是为了将构建复杂对象的过程和它的部件解耦。注意:：是解耦过程和部件。
        就拿造房子来说，比如某一天你的领导找到了你，“小A啊，工作不错，你的能力和态度都是我比较欣赏的，好好干前途一片大好”，然后你摸摸脑袋，呵呵傻笑，“我最近想盖一栋别墅，你帮我搞定吧，有你在，我放心”，然后你屁颠屁颠跑去找了N个各个领域的师傅，砌墙的、安装电线的、装地板的、修马桶的乱78遭一堆人，好了，现在可以动工了吧。但你手下的那些师傅却是你瞧我，我瞧你的，“老板，怎么应该做成什么样的别墅，先从哪搞起？”这时侯，你也傻了吧，忽略了最重要的一环-设计，没办法锅自己也不会，去找个设计师设计兼指挥吧。设计师列出了N个方案，并选择了其中之一就动工了。一个月后，你的上司找你要了房子交付后，这个过程也就完结了。builder模式就是这么个过程，把你的装配过程（设计师指挥各个师傅装配房子的顺序过程）和这个builder（带领各个专职师傅所作的事情）也就是部件职责分离。光说不练，没用，那接下来咱就贴下代码更加形象化下，如下：
         UML类图：

        UML顺序图粗略如下：


           首先假设一个复杂对象是由多个部件组成的，Builder模式是把复杂对象的创建和部件的创建分别开来，分别用Builder类和Director类来表示。

public interface Builder {

    // 比如砌墙
    public void buildPartA();

    // 比如装电线
    public void buildPartB();

    // 比如装马桶
    public void buildPartC();

    //返回最后组装成品结果 (返回最后装配好的汽车)
    //成品的组装过程不在这里进行，而是转移到下面的Director类中进行。
    //从而实现了解耦【过程】和【部件】
    public Product getResult();
}

用Director构建最后的复杂对象，而在上面Builder接口中封装的是如何创建一个个部件(复杂对象是由这些部件组成的)，也就是说Director的内容是如何将部件最后组装成成品：

public class Director {

    private Builder builder;

    /**
     * 产品的组装过程，这里可以改变装配顺序，从而得到不同的方案
     */
    public void build() {
        builder.buildPartA();// 先砌墙
        builder.buildPartB();// 再装电线
        builder.buildPartC();// 而后装马桶
    }
}

Builder的具体实现ConcreteBuilder，通过具体完成接口Builder来构建或装配产品的部件，定义并明确它所要创建的是什么具体东西；提供一个可以重新获取产品的接口。

public class ConcreteBuilder implements Builder {

    public void buildPartA() {
        // 具体如何砌墙的过程
    }

    public void buildPartB() {
        // 具体如何装电线的过程
    }

    public void buildPartC() {
        // 具体如何装马桶的过程
    }

    public Product getResult() {
        // 返回最后的组装的产品（房子）
        return new Product();
    }

}

复杂对象：产品Product

public interface Product { }

复杂对象的部件：部件Part

public interface Part { }

接下去就是我们的老板来找我们要房子了：

ConcreteBuilder builder = new ConcreteBuilder();
Director director = new Director( builder );

director.build();
Product product = builder.getResult();

整个builder模式就这样完结了，当然有人会有疑问“为什么getResult不放在Director里？”至于这个问题我是这么想的，你的老板当然是找你要房子了，难不成还找设计师要？我们是builder嘛，那些部件（Part）可都是我们管理的，而设计师只负责设计组装，这样过程和部件不是职责分离的很清楚吗？如果哪一天，老板又想造另外一栋格式不一样的别墅，我们就直接找设计师解决下。至于builder模式和abstract factory模式的差异，我是这么理解的，builder模式注重于一个过程，而abstract factory则侧重于产品的管理。

永远的火焰舞者 2010-03-15 02:00 发表评论

JForum安装

永远的火焰舞者 — Wed, 10 Mar 2010 16:49:00 GMT

JForum是一个功能强大，易于管理，采用BSD授权的免费论坛。由于是BSD授权，所以对于需要商用，需要修改其源代码但又不想公开自己产品部分源代码的朋友JForum是个不错的选择。同时，JForum采用Java语言，并遵守MVC构架，在维护性，扩展性上具有比较强的优势。
工具版本：
1、JForum版本为jforum-2.1.8.zip，下载地址为http://jforum.net/download.jsp。
2、mysql版本为mysql-5.0.18-win32.zip。
3、tomcat版本为apache-tomcat-5.5.26.zip。
安装步骤：
1、创建数据库jforum，执行jforum\WEB-INF\config\database\mysql\mysql_db_struct.sql创建所需的表。
2、把JForum工程考到tomcat下的webapp下，运行tomcat\bin下的startup.bat启动tomcat。
3、打开http://localhost:8080/jforum/install.jsp 进行配置，

其中数据库密码要根据mysql安装时候设置的username和password输入，安装成功后自动跳转到论坛主页。

一开始安装最后出现jdbcconnection请确认host、username、password之类的，很好找的错误，马上就发现是创建的数据库名和配置的时候输入的数据库名不对应，修改下立马解决。

永远的火焰舞者 2010-03-11 00:49 发表评论

Spring IoC的简单实现1

永远的火焰舞者 — Thu, 26 Mar 2009 06:41:00 GMT

摘要: 先定义一个BeanDefinition public class BeanDefinition { private String id; private String className; &nbs... 阅读全文

永远的火焰舞者 2009-03-26 14:41 发表评论

Prototype(原型)

永远的火焰舞者 — Tue, 03 Mar 2009 00:19:00 GMT

用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象.
通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，所以Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节。
以细胞为例：细胞a克隆出细胞b，细胞a、b具有相同的属性
如果以一般的做法我们会这样：

public class Cell {

    // 细胞壁
    private String cellWall = null;

    // 细胞膜
    private String membrane = null;

    // 细胞核
    private String nucleus = null;

    /**
     * 省略get、set方法
     */

客户端调用：
        // 产生细胞A
        Cell cellA = new Cell("细胞壁", "细胞膜", "细胞核");

        /* 产生与A同样的细胞B  */
        Cell cellB = new Cell();
        cellB.setCellWall(cellA.getCellWall());
        cellB.setMembrane(cellA.getMembrane());
        cellB.setNucleus(cellB.getNucleus());

这种繁琐而重复性高的复制能不能只写一遍呢？答案是“有”

public class Cell implements Cloneable {

    // 细胞壁
    private String cellWall = null;

    // 细胞膜
    private String membrane = null;

    // 细胞核
    private String nucleus = null;

    public Cell clone() throws CloneNotSupportedException {
        return (Cell)super.clone();
    }

客户端调用：
public class PrototypeClient {

    public static void main(String[] args) throws CloneNotSupportedException {
        // 产生细胞A
        Cell cellA = new Cell("细胞壁", "细胞膜", "细胞核");

        /* 产生与A同样的细胞B  */
        Cell cellB = cellA.clone();

        System.out.println(cellA == cellB);
    }

}

上述程序运行的结果为false，说明clone()在内存区开辟了另一块引用。以上的clone方法也被称为“浅度拷贝”，关于深度拷贝这里就不做详说了。

在一个复杂的类层次当中，当系统必须从其中的许多类型创建新对象时，可以考虑原型。

永远的火焰舞者 2009-03-03 08:19 发表评论

抽象工厂模式

永远的火焰舞者 — Sun, 01 Mar 2009 00:35:00 GMT

在上篇文章中我们用肉铺这样一个场景描述了简单工厂模式，肉铺老板卖的不同品种的猪肉，设想随着时间的消逝，肉铺的生意日趋红火，客户要求增加鸭、鸡、牛等之类的肉，这样我们就要分别引进亚洲鸭、非洲鸭，亚洲鸡、非洲鸡等等，很明显原先的软件设计就显的很无力了，根本适应不了现今的状态。所以就引进了抽象工厂模式。

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。

为了方便引进抽象工厂模式，引进一个新概念：产品族（Product Family）。所谓产品族，是指位于不同产品等级结构，功能相关联的产品组成的家族。如图：

图中一共有四个产品族，分布于三个不同的产品等级结构中。只要指明一个产品所处的产品族以及它所属的等级结构，就可以唯一的确定这个产品。

所谓的抽象工厂是指一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象。如果用图来描述的话，如下图：

AbstractFactory模式的结构如下：

图中AfricanPig和AsiaPig构成一个等级结构，AfiricanPorkFactory生产出来的包括AfricanPig和AfricanDuck构成一个产品族。

抽象工厂（Abstract Factory）角色：担任这个角色的是工厂方法模式的核心，它是与应用系统商业逻辑无关的。

具体工厂（Concrete Factory）角色：这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统的商业逻辑紧密相关的。

抽象产品（Abstract Product）角色：担任这个角色的类是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。

具体产品（Concrete Product）角色：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。这是客户端最终需要的东西，其内部一定充满了应用系统的商业逻辑。

上图的程序如下：

public interface Duck {

    public void send();
}

public class AsiaDuck implements Duck {

    public void send() {
        System.out.println("send Asia duck");
    }
}

public class AfricanDuck implements Duck {

    public void send() {
        System.out.println("send African duck");
    }
}

public interface Pig {

    public void send();
}

public class AsiaPig implements Pig {

    public void send() {
        System.out.println("send Asia pig");
    }
}

public class AfricanPig implements Pig {

    public void send() {
        System.out.println("send African pig");
    }
}

public abstract class AbstractFactory {

    public abstract Pig createPig();

    public abstract Duck createDuck();
}

public class AfricanPorkFactory extends AbstractFactory {

    @Override
    public Duck createDuck() {
        return new AfricanDuck();
    }

    @Override
    public Pig createPig() {
        return new AfricanPig();
    }
}

public class AsiaPorkFactory extends AbstractFactory {

    @Override
    public Duck createDuck() {
        return new AsiaDuck();
    }

    @Override
    public Pig createPig() {
        return new AsiaPig();
    }
}

public class PorkStoreClient {

    private Pig pig = null;
    private Duck duck = null;

    public PorkStoreClient(AbstractFactory factory) {
        pig = factory.createPig();
        duck = factory.createDuck();
    }

    public void send() {
        pig.send();
        duck.send();
    }

    public static void main(String[] args) {
        AbstractFactory africanFactory = new AfricanPorkFactory();
        PorkStoreClient africanPorkStore = new PorkStoreClient(africanFactory);
        africanPorkStore.send();

        AbstractFactory asiaFactory = new AsiaPorkFactory();
        PorkStoreClient asiaPorkStore = new PorkStoreClient(asiaFactory);
        asiaPorkStore.send();
    }
}

上述的场景可能不是很好的阐述了抽象工厂的应用，但我们如果换个场景呢？把text和button作为产品，而UnixText和UnixButton构成Unix产品族，WinText和WinButton作为Window产品族。还有汽车的零部件等等场景都能让你更加了解抽象工厂的应用。

抽象工厂模式与工厂方法模式的区别
工厂方法模式是一种极端情况的抽象工厂模式，而抽象工厂模式可以看成是工厂方法模式的一种推广。
(1)、工厂方法模式是用来创建一个产品的等级结构的，而抽象工厂模式是用来创建多个产品的等级结构的。工厂方法创建一般只有一个方法，创建一种产品。抽象工厂一般有多个方法，创建一系列产品。
(2)、工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

永远的火焰舞者 2009-03-01 08:35 发表评论

工厂方法模式

永远的火焰舞者 — Fri, 27 Feb 2009 23:38:00 GMT

工厂模式相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 。工厂模式也是用来创建实例对象的，所以new时就要多个心眼，是否可以考虑实用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。设想一个场景：一个肉铺老板卖肉，因为刚开张生意冷清，也就先卖下猪肉吧。
类图如下：

原先我们可能会在客户端直接调用比如Pig asiaPig = new AsiaPig()之类的代码，但现在我们只需调用PigFactory.createPig(***)来达到对Pig实现类的创建，这样客户端程序中超类的代码和子类对象的创建代码解藕了。

public class PigFactory {

    @SuppressWarnings("unchecked")
    public static Pig createPig(String pigName) {
        if ("AsiaPig".equals(pigName)) {
            return new AsiaPig();
        } else if ("AfricanPig".equals(pigName)) {
            return new AfricanPig();
        } else {
            return null;
        }
    }
}

public class PorkStore {

    private static void sendPork(String pigName) {
        Pig africanPig = PigFactory.createPig(pigName);
        africanPig.send();

    }

     public static void main(String[] args) {
         sendPork("AsiaPig");
         sendPork("AfricanPig");
    }
}

这样做的另一个问题又出来了，随着if else的增多代码块变的越趋庞大，这时就可利用java的发射来进行改善了，调整如下：

package factoryMethod;

public class PigFactory {

    @SuppressWarnings("unchecked")
    public static Pig createPig(String pigNme) {
        try {
            Class animalClass = Class.forName(pigNme);

            return (Pig)animalClass.newInstance();
        } catch (ClassNotFoundException e) {
            throw new RuntimeException("caught exception while found the class", e);
        } catch (InstantiationException e) {
            throw new RuntimeException("caught exception while instantiation", e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

public class PorkStore {

    private static void sendPork(String pigName) {
        Pig africanPig = PigFactory.createPig(pigName);
        africanPig.send();

    }

     public static void main(String[] args) {
         sendPork("factoryMethod.AsiaPig");
         sendPork("factoryMethod.AfricanPig");
    }
}

共厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个，让类把实例化推迟到子类。

永远的火焰舞者 2009-02-28 07:38 发表评论

单例模式

永远的火焰舞者 — Fri, 27 Feb 2009 15:47:00 GMT

设计模式学过差不多也有一年了可到现在只记得零星的几个看来是有必要复习一遍了。
有些大的对象其实我们只需要一个，比如说：线程池、缓存、日志对，充当打印机、显卡等设备的驱动程序的对象等，这类对象只能有一个实例，如果制造出多个就会产生许多问题。
单件模式确保一个类只能有一个实例，并且提供一个全局的访问点。

public class Singleton {

    private static Singleton instance = null;

    private Singleton () { }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }

        return instance;
    }

}

初看起来这段代码没有一点问题，但如果发生多线程的情况呢？因为多线程的不确定性，就很有可能产生很多个Singleton实例了。再来改善下让它能够适应多线程，如下：

public class Singleton {

    private static Singleton instance = null;

    private Singleton () {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }

        return instance;
    }

}

这样做多线程的问题是消除了，但却产生另外的问题：以后每次访问都需要执行同步方法，产生了严重的性能问题。再来改善下多线程，如下：

1、使用急切创建实例，而不使用延迟加载

public class Singleton {

    private static Singleton instance = new Singleton();

    private Singleton () {}

    public static  Singleton getInstance() {
        return instance;
    }

}

现在我们依赖JVM在加载这个类时马上创建此类的单件实例，JVM保证在任何线程访问instance静态变量之前先创建此实例。

2、使用双重检查加锁，在getInstance中减少使用同步

public class Singleton {

    // volatile 有效的确保当instance被初始化成实例时，多线程正确的处理instance变量。
    private volatile static  Singleton instance = null;

    private Singleton () {}

    public static  Singleton getInstance() {

        // 如果实例不存在就进入实例块，只有第一次才彻底执行这里的代码。
        if (instance == null) {
            // 这里有效的阻止了多线程问题的产生
            synchronized (Singleton.class) {
                // 进入区块后，再检查一次，只有实例为空才创建实例。
                if (instance == null) {
                    instance= new Singleton();
                }
            }
        }

        return instance;
    }

}

永远的火焰舞者 2009-02-27 23:47 发表评论

Inject Bean By Annotation

永远的火焰舞者 — Tue, 16 Dec 2008 17:17:00 GMT

摘要: Spring IoC容器允许BeanFactoryPostProcessor在容器实际实例化任何其它的bean之前读取配置元数据，并有可能修改它。本文就是以annotation的方式对bean进行依赖注入。代码如下： Annotation import java.lang.annotation.Inherited; import java.lang.annotat... 阅读全文

永远的火焰舞者 2008-12-17 01:17 发表评论

Spring IoC 硬编码

永远的火焰舞者 — Thu, 11 Dec 2008 18:26:00 GMT

这几天一直在看spring的源码，也多亏了JE上jiwenke大哥的ioc解析，让我有种播开乌云见天日的感觉。就像武侠剧里的楞头小年青，捡了本不世秘笈，功力尚浅，差点走火入魔。spring真的是博大精深的家伙，它把一些深层次的东西都隐藏了，让人只看到表面的东东。本文就是针对于此，通过硬编码的方式，更加的了解spring ioc的实现机制。

Spring IoC 容器和上下文的初始化包括Bean定义信息的资源定位，载入和注册过程，这里采用了硬编码忽略掉定义信息的资源定位这一环节。

DefaultSingletonBeanRegistry
   ---AbstractBeanFactory
      ---AbstractAutowireCapableBeanFactory
         ---DefaultListableBeanFactory
            ---XmlBeanFactory

XmlBeanFactory把DefaultListableBeanFactory作为ioc容器的实现

public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory)
        throws BeansException
    {
        super(parentBeanFactory);
        reader = new XmlBeanDefinitionReader(this);
        reader.loadBeanDefinitions(resource);
    }

下面先介绍下几个概念：
BeanDefinition Bean定义信息
BeanFactory Bean工厂
BeanDefinitionRegistry 注册器的接口
MutablePropertyValues 属性集合类
RootBeanDefinition BeanDefinition的实现

public class DaoA implements IDaoA {

    private String param;

    public void operationA() {
        System.out.println("DaoA.operationA(" + param + ")");
    }

    public String getParam() {
        return param;
    }

    public void setParam(String param) {
        this.param = param;
    }
}

public class DaoB implements IDaoB {

    public void operationB() {
        System.out.println("DaoB.operationB()");
    }
}
public class Service implements IService {

    private IDaoA daoA = null;

    private IDaoB daoB = null;

    public void service() {
        System.out.println("********service begin ***********");
        daoA.operationA();
        daoB.operationB();
        System.out.println("********service end *************");
    }

    public IDaoA getDaoA() {
        return daoA;
    }

    public void setDaoA(IDaoA daoA) {
        this.daoA = daoA;
    }

    public IDaoB getDaoB() {
        return daoB;
    }

    public void setDaoB(IDaoB daoB) {
        this.daoB = daoB;
    }
}

import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.config.RuntimeBeanReference;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.RootBeanDefinition;

public class HardCodeIoc {

    public static void main(String[] args) {
        // 注册器
        BeanDefinitionRegistry register = new DefaultListableBeanFactory();

        /* DaoA的属性集(DaoB没有属性这里就不做表示) */
        MutablePropertyValues daoAProperties = new MutablePropertyValues();
        daoAProperties.addPropertyValue("param", "param1");

        /* Service的属性集 */
        MutablePropertyValues serviceProperties = new MutablePropertyValues();
        serviceProperties.addPropertyValue("daoA", new RuntimeBeanReference("daoA"));
        serviceProperties.addPropertyValue("daoB", new RuntimeBeanReference("daoB"));

        /* 分别构造DaoA,DaoB,Service的Bean定义信息 */
        RootBeanDefinition daoADefinition = new RootBeanDefinition(DaoA.class, daoAProperties);
        RootBeanDefinition daoBDefinition = new RootBeanDefinition(DaoB.class, null);
        RootBeanDefinition serviceDefinition = new RootBeanDefinition(Service.class, serviceProperties);

        /* 把DaoA,DaoB,Service注册到工厂 */
        register.registerBeanDefinition("daoA", daoADefinition);
        register.registerBeanDefinition("daoB", daoBDefinition);
        register.registerBeanDefinition("service", serviceDefinition);

        // 转化为Bean工厂容器
        BeanFactory beanFactory = (BeanFactory) register;

        IDaoA daoA = (IDaoA) beanFactory.getBean("daoA");
        IDaoB daoB = (IDaoB) beanFactory.getBean("daoB");
        IService service = (IService) beanFactory.getBean("service");

        daoA.operationA();
        daoB.operationB();
        service.service();
    }
}

打印结果如下：
DaoA.operationA(param1)
DaoB.operationB()
********service begin ***********
DaoA.operationA(param1)
DaoB.operationB()
********service end *************

了解了这几个概念后就可以利用BeanFactory的后配置处理配合annotation进行自动注入了，省却了xml配置的麻烦。

永远的火焰舞者 2008-12-12 02:26 发表评论