javascript设计模式 工厂模式

javascript设计模式 工厂模式

什么是工厂模式

我们之前创造实例常常采用new关键字和构造函数,可是这样常常会导致两个类产生依赖关系.因此,我们通过创建一个对象的公共接口，我们可以根据相关的参数,控制创造的实例对象.

展现一个简单工厂模式

下面举一个例子,一个简单的蛋糕工厂根据需求生产不同的蛋糕

    /**
     * 创建蛋糕的种类
     */
    var VanillaCake = function () {   //创建类香草蛋糕
        this.type = "vanilla cake";
    }
    var ChocolateCake = function () {  //创建类巧克力蛋糕
        this.type = "chocolate cake";
    }
    var CreamCake = function () {  //创建奶油蛋糕
        this.type = "cream cake";
    }
    /**
     * 创建制造蛋糕的工厂
     */
    var CakeFactory = function () {
    };
    CakeFactory.prototype.produceCake = function (cakeType) {
        var cake;
        switch (cakeType) {
            case 'vanilla':
                cake = new VanillaCake();
                break;
            case 'chocolate':
                cake = new ChocolateCake();
                break;
            default:
                cake = new CreamCake();
        }
        cake.display = function () {  // 为这个蛋糕组装相应的外壳(方法)
            alert(this.type);
        }
        return cake;
    }

我们如何使用,我们需要对工厂进行实例化,或者在制造工厂的时候,直接以单体的形式存在

var cakeFactory = new CakeFactory();
    var cake = cakeFactory.produceCake();
    cake.display();

进一步复杂工厂模式

如果在生产目录中增加一种cake,我们就要在produceCake修改代码,根据面对对象的思想,我们可以把创建cake(实例)的过程交给一个简单的工厂对象 (workshop)

    /**
     * 创建蛋糕的种类
     */
    var VanillaCake = function () {   //创建类香草蛋糕
        this.type = "vanilla cake";
    }
    var ChocolateCake = function () {  //创建类巧克力蛋糕
        this.type = "chocolate cake";
    }
    var CreamCake = function () {  //创建奶油蛋糕
        this.type = "cream cake";
    }
    /**
     * 创建制造蛋糕的工厂车间
     */
    var WorkShop = {
        createCake: function (cakeType) {
            var cake;
            switch (cakeType) {
                case 'vanilla':
                    cake = new VanillaCake();
                    break;
                case 'chocolate':
                    cake = new ChocolateCake();
                    break;
                default:
                    cake = new CreamCake();
            }
            return cake;
        }
    }
    /**
     * 创建制造蛋糕的工厂
     */
    var CakeFactory = function () {
    };
    CakeFactory.prototype.produceCake = function (cakeType) {
        var cake = WorkShop.createCake(cakeType);  //将生产cake的任务交与车间
        cake.display = function () {  // 为这个组装相应的零件
            alert(this.type);
        }
        return cake;
    }
    var cakeFactory = new CakeFactory();
    var cake = cakeFactory.produceCake();
    cake.display();

WorkShop 是一个单体,将createCake的方法封装在一个命名空间中,这样就可以将cake的信息集中在一个地方管理,接口的内部修改也变得更加容易

真正的工厂模式

真正的工厂模式与简单的工厂模式的区别在于,它不是用一个类和一个对象来创建,而是使用一个子类

看下面的一个例子,我们在创建蛋糕的时候,由一个具体蛋糕工厂实例化蛋糕.我们将CakeFactory设计成抽象类,让其子类来来生产蛋糕.

    /**
     *  创建继承函数 (使用类型继承)
     */
    var extend = function (subClass, superClass) {
        var F = function () {
        };
        F.prototype = superClass.prototype;
        subClass.prototype = new F();
        subClass.prototype.constructor = subClass;
    }
    /**
     * 创建蛋糕的种类
     */
    var VanillaCake = function () {   //创建类香草蛋糕
        this.type = "vanilla cake";
    }
    var ChocolateCake = function () {  //创建类巧克力蛋糕
        this.type = "chocolate cake";
    }
    var CreamCake = function () {  //创建奶油蛋糕
        this.type = "cream cake";
    }
    /**
     * 创建制造抽象蛋糕的工厂
     */
    var CakeFactory = function () {
    };
    CakeFactory.prototype.produceCake = function (cakeType) {
        var cake = this.createCake(cakeType);  //将生产cake的任务交与具体工厂
        cake.display = function () {  // 为这个组装相应的零件
            alert(this.type);
        }
        return cake;
    };
    /**
     * 创建Ak蛋糕工厂(子类)
     * @constructor
     */
    var AkCakeFactory = function () {
    };
    extend(AkCakeFactory, CakeFactory); //Ak蛋糕工厂基于抽象的蛋糕工厂
    AkCakeFactory.prototype.createCake = function (cakeType) {
        var cake;
        switch (cakeType) {
            case 'vanilla':
                cake = new VanillaCake();
                break;
            case 'chocolate':
                cake = new ChocolateCake();
                break;
            default:
                cake = new CreamCake();
        }
        return cake;
    };
    var newCakeFactory = new AkCakeFactory();
    var cake = newCakeFactory.produceCake();
    cake.display();

工厂模式的使用场合

• 对象或者组件设置涉及到高程度级别的复杂度时,节省相关的设置开销。
• 根据所在的环境生成不同对象的实体时,例如创建XHR实体。
• 用许多的小型对象组成一个大对象时。

工厂模式好处

1.有助于消除对象之间的耦合

2.将所有的实例化代码集中放置在一个位置,简化更换的类和运行过程中动态选择类的工作

3.可以用一个接口的调用取代一个具体的实现,而不是调用 new 关键词,这样有助于模块化代码的实现

工厂模式弊处

1.过度使用工厂模式,忽视普通构造函数的作用.

2.有些类希望可以公开的实例化,这样使代码清晰易读.

如何解决弊端

我们通过编写一个对象加载器,由加载器进行对象的实例化.

/**
 * @param _class 类的名称
 */
var objectManager=((function () {
    return{
        create:function(_class){
            var _object = {}
            _object.__proto__ =  _class.prototype;
            _object.__proto__.constructor = _class ;
            var args = Array.prototype.slice.call(arguments);  //提取构造器的参数
            args=args.slice(1,args.length);
            _class.apply(_object,args);  //将构造器的参数传入需要实例化类的构造函数中
            return _object;
        }
    }
})());

如何利用这个这个加载器

/**
 * 声明一个类
 */
var a = function (p, u) {
        this.p = p || 1;
        this.u = u || "u";
    }
//实例化类a
var test = objectManager.create(a, 13, 99);