亚洲第一视频网站,亚洲a视频在线观看,亚洲一欧洲中文字幕在线

Sun, 14 Mar 2010 18:00:00 GMT

      Builder模式是一步一步创��Z��个复杂的对象�Q�它允许用户可以只通过指定复杂对象的类型和内容��可以构建它们。用户不需要知道内部的具体构徏�l�节。因��Z��个复杂的对象�Q?span lang="EN-US">不但有很多大量组成部分，如汽车，有很多部�?车轮、方向盘、发动机�q�有各种��零件等�{�，部�g很多�Q�但�q�不止这些，如何��这些部件装配成一辆汽车呢�Q�这个装配过�E�也很复�?需要很好的�l�装技�?�Q�Builder模式��是��Z��部件和�l�装�q�程分开。是��Z��构建复杂对象的�q�程和它�?strong>部�g解耦。注�?�Q�是解�?strong>�q�程�?strong>部�g�?br />         ��拿造房子来��_��比如某一天你的领导找��C��你，“��A啊，工作不错�Q�你的能力和态度都是我比较欣赏的�Q�好好干前途一片大�?#8221;�Q�然后你摸摸脑袋�Q�呵呵傻�W�，“我最�q�想盖一栋别墅，你帮我搞定吧�Q�有你在�Q�我攑ֿ�”�Q�然后你屁颠屁颠跑去找了N个各个领域的师傅�Q�砌墙的、安装电�U�的、装地板的、修马桶的�ؕ78遭一堆�h�Q�好了，现在可以动工了吧。但你手下的那些师傅却是你瞧我，我瞧你的�Q?#8220;老板�Q�怎么应该做成什么样的别墅，先从哪搞��P��”�q�时侯，你也��M��吧，忽略了最重要的一�?设计�Q�没办法锅自�׃��不会�Q�去找个设计师设计兼指挥吧。设计师列出了N个方案，�q��择了其中之一��动工了。一个月后，你的上司找你要了房子交付后，�q�个�q�程也就完结了。builder模式��是�q�么个过�E�，把你的装配过�E�（设计师指挥各个师傅装配房子的��序�q�程�Q�和�q�个builder�Q�带领各个专职师傅所作的事情�Q�也��是部�g职责分离。光说不�l�，没用�Q�那接下来咱��p��下代码更加�Ş象化下，如下�Q?br />          UML�c�d��Q?br />
        UML��序囄��略如下：


           首先假设一个复杂对象是由多个部件组成的�Q�Builder模式是把复杂对象的创建和部�g的创建分别开来，分别用Builder�c�d��Director�c�L��表示�?br />

public interface Builder {

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

    // 比如装电�U?/span>
    public void buildPartB();

    // 比如装马�?/span>
    public void buildPartC();

    //�q�回最后组装成品结�?nbsp;(�q�回最后装配好的汽�?
    //成品的组装过�E�不在这里进行，而是转移��C��面的Director�c�M��q�行�?br />     //从而实��C��解耦【过�E�】和【部件�?/span>
    public Product getResult();
}

�?span lang="EN-US">Director构徏最后的复杂对象�Q�而在上面Builder接口中封装的是如何创��Z��个个部�g(复杂对象是由�q�些部�g�l�成�?�Q�也��是说Director的内�Ҏ��如何��部件最后组装成成品�Q?br />

public class Director {

    private Builder builder;

    /**
     * 产品的组装过�E�，�q�里可以改变装配��序�Q�从而得��C��同的�Ҏ��
     */
    public void build() {
        builder.buildPartA();// 先砌�?/span>
        builder.buildPartB();// 再装�늺�
        builder.buildPartC();// 而后装马�?/span>
    }
}

Builder的具体实现ConcreteBuilder�Q�通过具体完成接口Builder来构建或装配产品的部�Ӟ��定义�q�明��它所要创建的是什么具体东西；提供一个可以重新获取��品的接口�?br />

public class ConcreteBuilder implements Builder {

    public void buildPartA() {
        // 具体如何砌墙的过�E?/span>
    }

    public void buildPartB() {
        // 具体如何装电�U�的�q�程
    }

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

    public Product getResult() {
        // �q�回最后的�l�装的��品（房子�Q?/span>
        return new Product();
    }

}

复杂对象�Q?span lang="EN-US">产品Product

public interface Product { }

复杂对象的部�Ӟ��部�gPart

public interface Part { }

接下��d��是我们的老板来找我们要房子了�Q?br />

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

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

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

永远的火焰舞�?/a> 2010-03-15 02:00 发表评论

JForum安装

Wed, 10 Mar 2010 16:49:00 GMT

JForum是一个功能强大，易于��理�Q�采用BSD授权的免费论坛。由于是BSD授权�Q�所以对于需要商用，需要修改其源代码但又不惛_��开自己产品部分源代码的朋友JForum是个不错的选择。同�Ӟ��JForum采用Java语言�Q��ƈ遵守MVC构架�Q�在�l�护性，扩展性上��h��比较强的优势�?br /> 工具版本�Q?/strong>
1、JForum版本为jforum-2.1.8.zip�Q�下载地址�?a >http://jforum.net/download.jsp�?br /> 2、mysql版本为mysql-5.0.18-win32.zip�?br /> 3、tomcat版本为apache-tomcat-5.5.26.zip�?br /> 安装步骤�Q?br /> 1、创建数据库jforum�Q�执行jforum\WEB-INF\config\database\mysql\mysql_db_struct.sql创徏所需的表�?br /> 2、把JForum工程考到tomcat下的webapp下，�q�行tomcat\bin下的startup.bat启动tomcat�?br /> 3、打开http://localhost:8080/jforum/install.jsp �q�行配置�Q?br />
其中数据库密码要�Ҏ��mysql安装时候设�|�的username和password输入�Q�安装成功后自动跌��{到论坛主��c�?br />

一开始安装最后出现jdbcconnection��L��认host、username、password之类的，很好扄��错误�Q�马上就发现是创建的数据库名和配�|�的时候输入的数据库名不对应，修改下立马解冟�?

永远的火焰舞�?/a> 2010-03-11 00:49 发表评论

Spring IoC的简单实�?

Thu, 26 Mar 2009 06:41:00 GMT
     摘要: 先定义一个BeanDefinition public class BeanDefinition {     private String id;     private String className;   &nbs...  阅读全文

永远的火焰舞�?/a> 2009-03-26 14:41 发表评论

Prototype(原型)

Tue, 03 Mar 2009 00:19:00 GMT
用原型实例指定创建对象的�U�类,�q�且通过拯��q�些原型创徏新的对象.
通过��一个原型对象传�l�那个要发动创徏的对象，�q�个要发动创建的对象通过��h��原型对象拯��它们自己来实施创建，所以Prototype模式允许一个对象再创徏另外一个可定制的对象，�Ҏ��无需知道��M��如何创徏的细节�?br /> 以细胞�ؓ例：�l�胞a克隆出细胞b�Q�细胞a、b��h��相同的属�?br /> 如果以一般的做法我们会这��P��

public class Cell {

    // �l�胞�?/span>
    private String cellWall = null;

    // �l�胞�?/span>
    private String membrane = null;

    // �l�胞�?/span>
    private String nucleus = null;

    /**
     * 省略get、set�Ҏ��
     */

客户端调用：
        // 产生�l�胞A
        Cell cellA = new Cell("�l�胞�?/span>", "�l�胞�?/span>", "�l�胞�?/span>");

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

�q�种�J�琐而重复性高的复制能不能只写一遍呢�Q�答案是“�?#8221;

public class Cell implements Cloneable {

    // �l�胞�?/span>
    private String cellWall = null;

    // �l�胞�?/span>
    private String membrane = null;

    // �l�胞�?/span>
    private String nucleus = null;

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

客户端调用：
public class PrototypeClient {

    public static void main(String[] args) throws CloneNotSupportedException {
        // 产生�l�胞A
        Cell cellA = new Cell("�l�胞�?/span>", "�l�胞�?/span>", "�l�胞�?/span>");

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

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

}
上述�E�序�q�行的结果�ؓfalse�Q�说明clone()在内存区开辟了另一块引用。以上的clone�Ҏ��也被�U�Cؓ“��度拯��”�Q�关于深度拷贝这里就不做详说了�?br />
在一个复杂的�c�d��ơ当中，当系�l�必��M��其中的许多类型创建新对象�Ӟ��可以考虑原型�?br />

永远的火焰舞�?/a> 2009-03-03 08:19 发表评论

抽象工厂模式

Sun, 01 Mar 2009 00:35:00 GMT

在上��文章中我们用肉��样一个场景描�q�C��单工厂模式，肉铺老板卖的不同品种的猪肉，设想随着旉��的消逝，肉铺的生意日��红火，客户要求增加鸭、鸡、牛�{�之�cȝ��肉，�q�样我们��p��分别引进亚洲鸭、非�z�鸭�Q�亚�z�鸡、非�z�鸡�{�等�Q�很明显原先的��Y件设计就昄��很无力了�Q�根本适应不了��C��的状态。所以就引进了抽象工厂模式�?/p>
抽象工厂模式是所有�Ş态的工厂模式中最为抽象和最具一般性的一�U��Ş态�?/p>
��Z��方便引进抽象工厂模式�Q�引�q�一个新概念�Q?font color="#000080">产品族（Product Family�Q?/font>。所谓��品族�Q�是指位于不同��品等�U�结构，功能相关�?/span>的��?/span>�l�成的家族。如图：

图中一共有四个产品族，分布于三个不同的产品�{��l�构中。只要指明一个��品所处的产品族以及它所属的�{��l�构�Q�就可以唯一的确定这个��品�?/p>
所谓的抽象工厂是指一个工厂等�U�结构可以创建出分属于不同��品等�U�结构的一个��品族中的所有对象。如果用图来描述的话�Q�如下图�Q?/p>

AbstractFactory模式的结构如下：

图中AfricanPig和AsiaPig构成一个等�U�结构，AfiricanPorkFactory生��出来的包括AfricanPig和AfricanDuck构成一个��品族�?/p>
抽象工厂�Q�Abstract Factory�Q�角�Ԍ��担�Q�q�个角色的是工厂�Ҏ��模式的核心，它是与应用系�l�商业逻辑无关的�?

具体工厂�Q�Concrete Factory�Q�角�Ԍ��q�个角色直接在客��L��的调用下创徏产品的实例。这个角色含有选择合适的产品对象的逻辑�Q�而这个逻辑是与应用�pȝ��的商业逻辑紧密相关的�?/p>
抽象产品�Q�Abstract Product�Q�角�Ԍ��担�Q�q�个角色的类是工厂方法模式所创徏的对象的父类�Q�或它们共同拥有的接口�?/p> 具体产品�Q�Concrete Product�Q�角�Ԍ��抽象工厂模式所创徏的�Q何��品对象都是某一个具体��品类的实例。这是客��L��最�l�需要的东西�Q�其内部一定充满了应用�pȝ��的商业逻辑�?br />
上图的程序如下：

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();
    }
}
上述的场景可能不是很好的阐述了抽象工厂的应用�Q�但我们如果换个场景呢？把text和button作�ؓ产品�Q�而UnixText和UnixButton构成Unix产品族，WinText和WinButton作�ؓWindow产品族。还有汽车的雉��件等�{�场景都能让你更加了解抽象工厂的应用�?br />
抽象工厂模式与工厂方法模式的区别
工厂�Ҏ��模式是一�U�极端情�늚�抽象工厂模式�Q�而抽象工厂模式可以看成是工厂�Ҏ��模式的一�U�推�qѝ�?
(1)、工厂方法模式是用来创徏一个��品的�{��l�构的，而抽象工厂模式是用来创徏多个产品的等�U�结构的。工厂方法创��Z��般只有一个方法，创徏一�U��品。抽象工厂一般有多个�Ҏ��Q�创��Z��p�d��产品�?
(2)、工厂方法模式只有一个抽象��品类�Q�而抽象工厂模式有多个。工厂方法模式的具体工厂�c�d��能创��Z��个具体��品类的实例，而抽象工厂模式可以创建多个�?

永远的火焰舞�?/a> 2009-03-01 08:35 发表评论

工厂�Ҏ��模式

Fri, 27 Feb 2009 23:38:00 GMT
工厂模式相当于创建实例对象的new�Q�我们经常要�Ҏ��c�Class生成实例对象�Q�如A a=new A() 。工厂模式也是用来创建实例对象的�Q�所以new时就要多个心��|��是否可以考虑实用工厂模式�Q�虽然这样做�Q�可能多做一些工作，但会�l�你�pȝ��带来更大的可扩展性和��量��的修改量。设想一个场景：一个肉��板卖肉�Q�因为刚开张生意冷清，也就先卖下猪肉吧�?br /> �c�d��如下�Q?br />
原先我们可能会在客户端直接调用比如Pig asiaPig = new AsiaPig()之类的代码，但现在我们只需调用PigFactory.createPig(***)来达到对Pig实现�cȝ��创徏�Q�这样客��L��E�序中超�cȝ��代码和子�c�d��象的创徏代码解藕了�?br />
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");
    }
}

�q�样做的另一个问题又出来了，随着if else的增多代码块变的��趋庞大�Q�这时就可利用java的发��来�q�行改善了，调整如下�Q?br />
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");
    }
}

共厂�Ҏ��模式定义了一个创建对象的接口�Q�但由子�c�d��定要实例化的�c�L��哪一个，让类把实例化推迟到子�c?/strong>�?br />

永远的火焰舞�?/a> 2009-02-28 07:38 发表评论

单例模式

Fri, 27 Feb 2009 15:47:00 GMT
设计模式学过差不多也有一�q�了可到现在只记得零星的几个看来是有必要复习一遍了�?br /> 有些大的对象其实我们只需要一个，比如��_��U�程池、缓存、日志对�Q�充当打印机、显卡等讑֤�的驱动程序的对象�{�，�q�类对象只能有一个实例，如果刉��出多个��׃��产生许多问题�?br /> 单�g模式��保一个类只能有一个实例，�q�且提供一个全局的访问点�?br />

public class Singleton {

    private static Singleton instance = null;

    private Singleton () { }

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

        return instance;
    }

}

初看��h��q�段代码没有一炚w��题，但如果发生多�U�程的情况呢�Q�因为多�U�程的不��定性，��很有可能��生很多个Singleton实例了。再来改善下让它能够适应多线�E�，如下�Q?br />

public class Singleton {

    private static Singleton instance = null;

    private Singleton () {}

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

        return instance;
    }

}

�q�样做多�U�程的问题是消除了，但却产生另外的问题：以后每次讉K��都需要执行同步方法，产生了严重的性能问题。再来改善下多线�E�，如下�Q?br />
1、��用急切创徏实例�Q�而不使用延迟加蝲

public class Singleton {

    private static Singleton instance = new Singleton();

    private Singleton () {}

    public static  Singleton getInstance() {
        return instance;
    }

}
现在我们依赖JVM在加载这个类旉��上创建此�cȝ��单�g实例�Q�JVM保证在�Q何线�E�访问instance静态变量之前先创徏此实例�?br />
2、��用双重检查加锁，在getInstance中减��用同�?br />
public class Singleton {

    // volatile 有效的确保当instance被初始化成实例时�Q�多�U�程正确的处理instance变量�?/span>
    private volatile static  Singleton instance = null;

    private Singleton () {}

    public static  Singleton getInstance() {

        // 如果实例不存在就�q�入实例块，只有�W�一�ơ才��d��执行�q�里的代码�?/span>
        if (instance == null) {
            // �q�里有效的阻止了多线�E�问题的产生
            synchronized (Singleton.class) {
                // �q�入区块后，再检查一�ơ，只有实例为空才创建实例�?/span>
                if (instance == null) {
                    instance= new Singleton();
                }
            }
        }

        return instance;
    }

}

永远的火焰舞�?/a> 2009-02-27 23:47 发表评论

Inject Bean By Annotation

Tue, 16 Dec 2008 17:17:00 GMT
     摘要: Spring IoC容器允许BeanFactoryPostProcessor在容器实际实例化��M��其它的bean之前��d��配置元数据，�q�有可能修改它。本文就是以annotation的方式对bean�q�行依赖注入�? 代码如下�Q?Annotation import java.lang.annotation.Inherited; import java.lang.annotat...  阅读全文

永远的火焰舞�?/a> 2008-12-17 01:17 发表评论

Thu, 11 Dec 2008 18:26:00 GMT
�q�几天一直在看spring的源码，也多亏了JE上jiwenke大哥的ioc解析�Q�让我有�U�播开乌云见天日的感觉。就像武侠剧里的楞头��年青，捡了本不世秘�W�，功力��浅�Q�差点走火入��。spring真的是博大精��q��家伙�Q�它把一些深层次的东襉K��隐藏了，让�h只看到表面的东东。本文就是针对于此，通过��编码的方式�Q�更加的了解spring ioc的实现机制�?br />
Spring IoC 容器和上下文的初始化包括Bean定义信息的资源定位，载入和注册过�E�，�q�里采用了硬�~�码忽略掉定义信息的资源定位�q�一环节�?br />
DefaultSingletonBeanRegistry
   ---AbstractBeanFactory
      ---AbstractAutowireCapableBeanFactory
         ---DefaultListableBeanFactory
            ---XmlBeanFactory

XmlBeanFactory把DefaultListableBeanFactory作�ؓioc容器的实�?br />

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

下面先介�l�下几个概念�Q?br /> BeanDefinition Bean定义信息
BeanFactory Bean工厂
BeanDefinitionRegistry 注册器的接口
MutablePropertyValues 属性集合类
RootBeanDefinition BeanDefinition的实�?br />

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) {
        // 注册�?/span>
        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注册到工�?nbsp;*/
        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();
    }
}

打印�l�果如下�Q?br /> DaoA.operationA(param1)
DaoB.operationB()
********service begin ***********
DaoA.operationA(param1)
DaoB.operationB()
********service end *************

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

永远的火焰舞�?/a> 2008-12-12 02:26 发表评论