浅谈设计模式 - 工厂模式（六）

浅谈设计模式 - 工厂模式（六）

前言：

在第一篇里面已经介绍过简单工厂了，但是工厂模式里面不仅仅是简单工厂，还存在工厂方法和抽象工厂，并且从严格意义来讲简单工厂不能算是一种设计模式，本次的文章针对工厂的进化来展开讲一讲工厂模式的三种常见形式：简单工厂、工厂方法、抽象工厂。

文章目的

  1. 了解简单工厂这种代码编写形式的优点，回顾工厂模式
  2. 了解如何从简单工厂扩展到工厂方法以及抽象工厂
  3. 对比工厂方法和抽象工厂的异同。
  4. 总结简单工厂，工厂方法和抽象工厂，对比优缺点和特点

如何辨别工厂模式

工厂模式一般从类的命名就可以直接看到含义，所以一般情况下很容易看出工厂模式的应用。

  • 工厂模式主要是负责对象的创建
  • 无论是创建者还是使用者，都是针对一个抽象对象的实现。
  • 工厂模式最关注的是对象是如何创建的而不是对象的使用。它针对的是创建这一个过程。

工厂模式的具体介绍

简单工厂模式

简单工厂模式的介绍：https://juejin.cn/post/692206...

之前文章已经介绍过简单工厂模式，我们直接看一下简单工厂是如何设计的，从严格的意义上来说，简单工厂是一种良好的“编程习惯”，他很好的解耦了创建对象和使用对象这两个不同的过程。做到“单一职责”的原则

浅谈设计模式 - 工厂模式（六）_第1张图片

从上面的图当中我们构建基本的工厂类和对应的实现子类以及对应的产品抽象类。

下面回顾一下简单工厂的优缺点

优点：

  1. 使用创建工厂的方法，我们实现了获取具体对象和生产对象的解耦，由生产对象的工厂通过我们传入的参数生产对应的对象，调用方只需要传递需要生产的对象来实现具体的效果。
  2. 解耦了创建和被创建的过程。
  3. 根据不同的逻辑判断生成不同的具体对象。

缺点：

  1. 每增加一个工厂对象具体的实现类，就需要增加if/else不利于维护
  2. 大量的子类会造成工厂类的代码迅速膨胀和臃肿
  3. 简单工厂的方法一般处理简单的业务逻辑，如果创建逻辑复杂不建议使用。

从上面的优缺点分析可以知道，简单工厂并不能完全解决对象的创建解耦，对于对象的创建细节容易造成耦合，同时如果创建的对象过多容易出现臃肿的工厂代码。

工厂方法模式

工厂方法模式：定义了创建对象的接口方法，但是具体的创建过程由子类来决定。工厂方法将创建的过程延迟到子类，工厂方法是对简单工厂的扩展和升级，为了解决简单工厂破坏了“开放-关闭原则”的问题而做的改进。我们将具体的产品进行了抽象的同时，将创建对象的过程延迟到子类进行实现。

工厂方法的结构图

下面为工厂方法的结构图，我们由简单工厂转变为工厂方法之后，工厂类定义增加了抽象的对象创建方法，由子类通过继承的方式实现工厂的抽象方法并且实现自己的构建过程。

浅谈设计模式 - 工厂模式（六）_第2张图片

+ Product 产品类，定义产品的公用方法和抽象类
+ ConcreteProduct 产品的具体实现子类，包含具体产品的实现
+ Factory 工厂类，定义工厂的创建方法以及需要子类继承实现的方法
+ ConcreteFactory 工厂的实现类，由子工厂来决定生成的具体产品和定义生产的具体过程。

工厂方法的特点

下面是工厂方法的具体特点

  • 创建的过程解耦到子类，由子类决定创建的过程和结果
  • 具体的产品和工厂之间存在必要关联，同时可以使用任意子类产品进行替换
  • 需要依靠继承的形式由子工厂来决定生产的过程，子类决定产品创建的结果
提醒：子类决定创建的结果并不是字面上的创建，而是由调用者决定的。子类决定的是具体针对哪一个实例进行生产，但是生成的具体结果还是控制在创建者的身上

简单工厂和工厂方法有什么区别

  1. 简单工厂是对产品的创建过程进行“封装”，同时创建新的产品必须改动工厂代码。
  2. 工厂方法是对简单工厂的升级，工厂方法可以控制具体对象的创建以及由子类来决定具体需要创建哪一个对象。
  3. 简单工厂只是单纯的解耦创建者和使用者，但是简单工厂无法改变创建的结果。

抽象工厂模式

抽象工厂模式：提供接口，通过定义抽象方法的形式，通过实现具体工厂方法实现创建具体对象家族，同时不需要指定特殊的类。

抽象工厂的内部往往使用工厂方法进行实现，两者经常被弄混，从结构上来看，他们最大的区别在于工厂方法往往使用继承实现，而抽象工厂往往使用内部继承工厂方法的接口实现。区分工厂方法和抽象工厂也是工厂模式的学习关键。

抽象工厂的结构图

由于抽象工厂更像是对工厂方法的改进，我们定义抽象工厂的结构图，抽象工厂的结构相比工厂方法要复杂一些：

可以参考抽象工厂和工厂方法的结构图，看看两者的异同

浅谈设计模式 - 工厂模式（六）_第3张图片

+ FactoryInterface     抽象工厂接口，定义一批抽象对象的生产接口
 + ConcreteFactoryA    抽象工厂实现类A，实现抽象工厂接口。
 + ConcreteFactoryB    抽象工厂实现类B，实现抽象工厂接口。
+ ProductA            抽象产品A，定义公共的抽象方法或者公用属性
 + ConcreteProductA    具体实现产品A
 + ConcreteProductA    具体实现产品A
+ ProductB            抽象产品B，定义公共的抽象方法或者公用属性
 + ConcreteProductB    具体实现产品B
 + ConcreteProductB    具体实现产品B

抽象工厂的特点：

  1. 所有的具体工厂都实现同一个抽象工厂接口。
  2. 生产的结果实现类可以自由实现具体类或者其扩展类的实例。
  3. 抽象工厂的痛点在于扩展一个新的产品生产会造成所有的具体工厂的改动，也包含了产品类的变动。
  4. 抽象工厂往往包含了一系列的工厂方法

抽象工厂和工厂方法的区别

  1. 抽象工厂定义抽象接口依靠子类实现创建的过程，而工厂方法针对子类实现具体的对象创建细节
  2. 工厂方法需要使用继承的手段实现工厂方法“埋藏”工厂创建具体对象的细节
  3. 工厂方法对于处理“独立”产品的创建非常有效，而抽象工厂往往用于处理生产多个存在关联的产品对象。

实际案例

依旧参考坦克大战的案例，介绍如何改造坦克大战的具体代码。

模拟场景

依然以经典的任天堂游戏坦克大战为例，在进入游戏的关卡的时候，会出现我方的坦克和敌人的坦克，我方坦克和地方坦克不仅形状不同，而且很脆，但是敌人的坦克根据颜色需要打好几枪才会毁灭，那么如果用代码来模拟是什么样的呢？

简单工厂实现：

使用简单工厂实现的代码如下:

使用简单工厂类来管理坦克的创建过程，简单工厂顾名思义，就是简单的将创建对象的过程进行管理。

增加工厂类 TankFactory.java

用工厂来管理具体的坦克创建过程:

/**
 * 坦克工厂，专门负责生产坦克
 *
 * @author zxd
 * @version 1.0
 * @date 2021/1/25 22:27
 */
public class TankFactory {

    /**
     * 创建坦克
     * @return
     */
    public Tank createTank(String check){
        Tank tank = null;
        if(Objects.equals(check, "my")){
            tank = new MyTank();
        }else if(Objects.equals(check, "mouse")){
            tank = new MouseTank();
        }else if (Objects.equals(check, "big")){
            tank = new BigTank();
        }else {
            throw new UnsupportedOperationException("当前坦克不支持生产");
        }
        return tank;
    }
}

下面是对应的坦克以及坦克的子类实现

/**
 * 坦克的父类，定义坦克的行为
 *
 * @author zxd
 * @version 1.0
 * @date 2021/1/25 0:14
 */
public abstract class Tank {


    /**
     * 坦克hp
     */
    protected int hp;

    /**
     * 坦克子弹
     */
    protected List bullet;

    /**
     * 移动的方法s
     */
    abstract void move();

    /**
     * 攻击
     */
    abstract void attack();

    /**
     * 停止
     */
    abstract void stop();
} 
 
我方的坦克继承坦克的父类：
 
 
/**
 * 我方坦克
 *
 * @author zxd
 * @version 1.0
 * @date 2021/1/25 21:58
 */
public class MyTank extends Tank {

    public MyTank() {
        // 我方坦克假设只有一条命
        hp = 1;
        bullet = new ArrayList<>();
        // 初始化添加三发子弹
        bullet.add(new Object());
        bullet.add(new Object());
        bullet.add(new Object());
    }

    @Override
    void move() {
        System.err.println("移动");
    }

    @Override
    void attack() {
        System.err.println("攻击地方坦克");
        // ..弹出子弹
        if(bullet.size() == 0){
            System.err.println("没有子弹了");
            return;
        }
        bullet.remove(bullet.get(bullet.size() -1));
    }

    @Override
    void stop() {
        System.err.println("停止");
    }
}
 
 
敌人的坦克如下：
 
 
/**
 * 老鼠坦克
 *
 * @author zxd
 * @version 1.0
 * @date 2021/1/25 22:02
 */
public class MouseTank extends Tank implements Runnable {

    public void display() {
        System.err.println("长得尖尖的，很像老鼠");
    }

    public MouseTank() {
        // 坦克假设只有一条命
        hp = 1;
        new Thread(this).start();
        bullet = new ArrayList<>();
        // 初始化添加六发子弹
        bullet.add(new Object());
        bullet.add(new Object());
        bullet.add(new Object());
        bullet.add(new Object());
        bullet.add(new Object());
    }

    @Override
    void move() {
        System.err.println("老鼠坦克移动");
    }

    @Override
    void attack() {
        System.err.println("老鼠坦克开枪");
        // ..弹出子弹
        if (bullet.size() <= 0) {
            System.err.println("老鼠坦克没有子弹了");
            return;
        }
        // 老鼠坦克一次性开两枪
        bullet.remove(bullet.get(bullet.size() - 1));
    }

    @Override
    void stop() {
        System.err.println("停止");
    }

    @Override
    public void run() {
        while (true) {
            // 一旦创建就开始移动
            move();
            // 漫无目的开枪
            attack();
            attack();
            // 做完一轮操作歇一秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 随机停止
            if (new Random(100).nextInt() % 2 == 0) {
                stop();
            }
        }
    }
}
 
 
最后编写单元测试如下，我们使用简单工厂生产出不同的坦克，但是客户端不需要纠结生产的细节：
 
 
/**
 * 单元测试
 *
 * @author zxd
 * @version 1.0
 * @date 2021/1/25 22:15
 */
public class Main {

    /**
     * 我们将生产坦克的过程全部交给了工厂来处理
     * 可能还是奇怪，这和刚才没有什么区别呀？
     * 我们来看下区别：
     * 1. 创建的过程没有了，虽然是一个简单的new，但是new的过程交给了工厂
     * 2. 我们后续如果要在坦克加入别的东西，只需要去改工厂类和具体的实现类，不需要该此处代码
     * 3. 如果不支持的操作，工厂还可以通知我们这样做不对
     * @param args
     */
    public static void main(String[] args) {

        TankFactory tankFactory = new TankFactory();

        Tank my = tankFactory.createTank("my");
        Tank mouse = tankFactory.createTank("mouse");
        Tank big = tankFactory.createTank("big");
        // 我要一个没有的设计过的坦克
        Tank mybig = tankFactory.createTank("mybig");


    }/*//
    运行结果：
    Exception in thread "main" 老鼠坦克移动
    巨型坦克移动
    老鼠坦克开枪
    巨型坦克开枪
    老鼠坦克开枪
    java.lang.UnsupportedOperationException: 当前坦克不支持生产
    at com.headfirst.factory.use.TankFactory.createTank(TankFactory.java:27)
    at com.headfirst.factory.use.Main.main(Main.java:33)
    */



}
 
 
从上面的代码可以看到，对于坦克的创建和使用过程虽然进行解耦了，但是可以看到创建的过程耦合在了简单工厂的内部，工厂创建的方法耦合了过多的细节，同时如果需要创建新的产品需要改动工厂代码，这违背了开放-关闭原则。
 
 
针对上面的问题，我们显然需要使用工厂方法进行改良，我们让工厂的创建细节延迟到子类去实现，子类只需要关注创建的细节，不需要了解客户端的调用，下面我们针对上面的代码使用工厂方法进行改进。
 
 

   这种改动也符合开放-关闭原则 
 
 
 
工厂方法实现：
 
 
从简单工厂可以看出，如果每次修改产品都需要牵动工厂的代码改动，同时针对创建的过程都被“耦合”在单独的工厂创建方法内部，我们根据工厂方法的结构图看一下如何改进坦克大战的代码：
 
 
浅谈设计模式 - 工厂模式（六）_第4张图片
 
 
首先，我们需要依照工厂方法的定义，将原本的简单工厂类改造为具备工厂方法的工厂，在下面的代码当中，工厂类具备两个方法，一个用于创建具体的对象，由客户端调用，并且提供一个抽象的方法，由工厂子类实现并且定义具体的工厂生产过程。
 
 
/**
 * 坦克工厂
 * 工厂增加抽象方法由子类进行构建
 *
 * @author zxd
 * @version 1.0
 * @date 2021/2/16 17:33
 */
public abstract class TankFactory {

    /**
     * 创建坦克
     * @return
     */
    public Tank createTank(String check){
        return createConcreteTankMethod(check);
    }

    /**
     * 构建具体产品过程的方法
     * @return
     */
    protected abstract Tank createConcreteTankMethod(String check);


}
 
 
子类不需要关心createTank()方法是如何运行的，只需要实现自己的工厂方法同时定义生产的细节提供支持即可。
 
 
下面的代码为我方坦克的生产工厂
 
 
/**
 * 我方坦克的创建工厂
 *
 * @author zxd
 * @version 1.0
 * @date 2021/2/16 14:28
 */
public class OurTankFactory extends TankFactory {

    @Override
    public Tank createConcreteTankMethod(String check) {
        Tank tank = null;
        if(Objects.equals(check, "my")){
            tank = new MyTank();
        }
        return tank;
    }
}
 
 
下面的代码为敌人的坦克的生产工厂实现子类。
 
 
/**
 * 敌人坦克的构建工厂
 * 老鼠坦克
 * @author zxd
 * @version 1.0
 * @date 2021/2/16 14:28
 */
public class MouseTankFactory extends TankFactory {

    @Override
    public Tank createConcreteTankMethod(String check) {
        Tank tank = null;
        if(Objects.equals(check, "mouse")){
            tank = new MouseTank();
        }
        return tank;
    }
}
 
 
通过这样的调整之后，我们每次增加新的产品，只需要继承具备工厂方法的工厂并且实现对应的方法完成自己的坦克创建细节，就将原本耦合的创建规则从父类从剥离，延迟到子类完成，下面来看下单元测试的代码，可以看到工厂的生产具体具体化到子类工厂的内部，而对外依旧是坦克的生成工厂，这样既符合依赖倒转的原则，也方便后续的扩展和更多实现工厂的添加：
 
 
/**
 * 工厂方法的单元测试
 *
 * @author zxd
 * @version 1.0
 * @date 2021/2/16 17:50
 */
public class Main {

    public static void main(String[] args) {
        TankFactory tankFactory = new MouseTankFactory();
        TankFactory ourTankFactory = new OurTankFactory();
        Tank my = tankFactory.createTank("mouse");
        Tank mouse = ourTankFactory.createTank("my");
        System.err.println(my);
        System.err.println(mouse);
    }/*运行结果：
    com.headfirst.factory.use.MouseTank@677327b6
    老鼠坦克移动
    com.headfirst.factory.use.MyTank@14ae5a5
    老鼠坦克开枪
    老鼠坦克开枪
    */
}
 
 
工厂方法的问题：虽然工厂方法很好的为我们解决了创建过程由子类进行构建的问题，但是如果我们需要往坦克的产品里面提供配对的零件，此时会发现一些问题，我们的工厂方法只能提供一种产品的生产，如果我们需要生产很多的产品，工厂方法此时就遇到的瓶颈，因为需要调整继承结构，同时扩展非常不便。
 
 

   注意点：工厂方法的另一个问题在于他需要依赖继承来实现对象创建过程定义，此时如果改动整个顶层的抽象方法会导致依赖磁铁导致所有的子类都需要改变。假如需要加入多个产品的生产，此时对于所有的子类改动来看都是十分麻烦的事情. 
 
 
 
总结：工厂方法在构建一类产品的时候非常有效，但是需要构建很多种产品的时候会产生大量的继承具体化问题
 
 
抽象工厂的实现：
 
 
我们之前讲过抽象工厂实际上是对工厂方法的进一步提取，抽象工厂需要的是一系列产品的接口，由子工厂负责一系列产品的接口生产，同时更多的需要依赖组合的形式为具体的产品进行扩展。
 
 
在具体的案例代码介绍之前，我们需要对于案例进行改动，由于之前只存在坦克父类和具体的实现子类，为了详细介绍抽象工厂，我们针对坦克类增加一个大炮类，大炮类提供展示外观的方法，和坦克类的产品完全不同，我们需要定义坦克的大炮产品父类和具体的不同实现子类，在抽象工厂提供大炮的生产接口抽象同时，我们需要在大炮的类内部组合大炮的对象，为坦克增加不同的大炮外观，下面我们根据抽象工厂的结构图，构建如下的结构图：
 
 
浅谈设计模式 - 工厂模式（六）_第5张图片
 
 
我们参考结构图，定义类似的坦克结构，下面是加入新需求之后的结构图：
 
 
浅谈设计模式 - 工厂模式（六）_第6张图片
 
 
根据上面的结构图，我们先将工厂有具体类改造为工厂接口，不再持有具体的创建过程，将一系列创建的细节分布到子类进行，同时定义接口的方式可以创建多个产品。（这里简化为2个不同的产品）
 
 
/**
 * 坦克工厂，专门负责生产坦克
 *
 * @author zxd
 * @version 1.0
 * @date 2021/1/25 22:27
 */
public interface TankFactory {

    /**
     * 坦克创建方法抽象
     * @return
     */
    Tank createTank();

    /**
     * 大炮的创建方法
     * @return
     */
    Cannon createCannon();
}
 
 
接下来我们根据抽象工厂接口创建具体的生产工厂，我们在子类可以返回具体的产品子类也可以返回抽象的父类，下面定义我方坦克的工厂类，同时定义一个特定敌人坦克的工厂类。
 
 
/**
 * 我方坦克的创建工厂
 *
 * @author zxd
 * @version 1.0
 * @date 2021/2/16 14:28
 */
public class OurTankFactory implements TankFactory {

    /**
     * 创建自带大炮的坦克
     * @return
     */
    public Tank createTanAndCannon() {
        Tank myTank = createTank();
        myTank.setCannon(createCannon());
        return myTank;
    }

    @Override
    public Tank createTank() {
        return new MyTank();
    }

    @Override
    public Cannon createCannon() {
        return new Artillery();
    }
}
 
 
敌人坦克的工厂实现子类:敌人的坦克工厂实现子类，可以生产不同抽象产品的不同具体实现子类
 
 
/**
 * 敌人坦克的构建工厂
 * 老鼠坦克
 * @author zxd
 * @version 1.0
 * @date 2021/2/16 14:28
 */
public class MouseTankFactory implements TankFactory {
    @Override
    public MouseTank createTank() {
        return new MouseTank();
    }

    @Override
    public Cannon createCannon() {
        return new RocketLauncher();
    }
}
 
 
接着我们定义另一个独立的产品，定义顶层的抽象类
 
 
/**
 * 大炮抽象类
 * 子类具备不同的大炮形式
 *
 * @author zxd
 * @version 1.0
 * @date 2021/2/16 18:15
 */
public abstract class Cannon {

    /**
     * 外观
     */
    public abstract void display();


}
 
 
根据对应上面的抽象父类，定义对应点具体实现子类，这里为了简单将两个具体实现子类放到一块：
 
 
/**
 * 火炮
 *
 * @author zxd
 * @version 1.0
 * @date 2021/2/16 19:06
 */
public class Artillery extends Cannon{


    @Override
    public void display() {
        System.out.println("火箭炮");
    }
}
/**
 * 火箭炮
 *
 * @author zxd
 * @version 1.0
 * @date 2021/2/16 19:06
 */
public class RocketLauncher extends Cannon{
    @Override
    public void display() {
        System.out.println("火箭炮");
    }
}
 
 
这里扩展了一下坦克类，为坦克类组合了大炮的对象：
 
 
/**
 * 坦克的父类，定义坦克的行为
 *
 * @author zxd
 * @version 1.0
 * @date 2021/1/25 0:14
 */
public abstract class Tank {
    /**
     * 坦克hp
     */
    protected int hp;

    /**
     * 坦克子弹
     */
    protected List bullet;

    private Cannon cannon;

    /**
     * 移动的方法s
     */
    public abstract void move();

    /**
     * 攻击
     */
    public abstract void attack();

    /**
     * 停止
     */
    public abstract void stop();

    public Cannon getCannon() {
        return cannon;
    }

    public void setCannon(Cannon cannon) {
        this.cannon = cannon;
    }

    @Override
    public String toString() {
        return "Tank{" +
                "hp=" + hp +
                ", bullet=" + bullet +
                ", cannon=" + cannon +
                '}';
    }
} 
 
下面是单元测试代码，我们在坦克的对象里面设置或者组合其他的对象，并且由工厂提供生产：
 
 
/**
 * 单元测试
 * 抽象工厂
 * @author zxd
 * @version 1.0
 * @date 2021/2/16 16:32
 */
public class Main {

    public static void main(String[] args) {
        TankFactory ourTankFactory = new OurTankFactory();
        TankFactory mouseTankFactory = new MouseTankFactory();
        Tank ourTankFactoryTank = ourTankFactory.createTank();
        Cannon cannon = ourTankFactory.createCannon();
        Tank mouseTankFactoryTank = mouseTankFactory.createTank();
        Cannon cannon1 = mouseTankFactory.createCannon();
        ourTankFactoryTank.setCannon(cannon);
        mouseTankFactoryTank.setCannon(cannon1);
        System.err.println("our = " + ourTankFactoryTank);
        System.err.println("mouse = " + mouseTankFactoryTank);
    }/*
        our = Tank{hp=1, bullet=[java.lang.Object@677327b6, java.lang.Object@14ae5a5, java.lang.Object@7f31245a],
        cannon=com.headfirst.factory.abstractfac.Artillery@6d6f6e28}
        老鼠坦克移动
        mouse = Tank{hp=1, bullet=[java.lang.Object@135fbaa4, java.lang.Object@45ee12a7, java.lang.Object@330bedb4, java.lang.Object@2503dbd3, java.lang.Object@4b67cf4d],
        cannon=com.headfirst.factory.abstractfac.RocketLauncher@7ea987ac}
        老鼠坦克开枪

     */
}
 
 
工厂模式的变化：
 
 
从上面的案例和具体实现我们分析了工厂模式的三种变化：简单工厂、工厂方法、抽象工厂。他们的递进次序也是简单工厂 -> 工厂方法 -> 抽象工厂这种顺序。
 
 
我们可以发现简单工厂是一种非常简单的设计思路，他仅仅定义了的创建和使用过程的接口，同时产品具备最基本的抽象和继承设计，这类设计往往用于简单的对象构建。而一旦出现大量的具体对象，简单工厂的代码将会不断的膨胀，同时产生很多的if/else代码。
 
 
此时就需要使用工厂方法对于简单工厂的结构进行升级，工厂方法通过继承的方式（定义抽象的方法），推迟具体对象的创建到子类，工厂父类既可以控制子类的创建结果，同时又不需要关心具体对象的创建过程，这种设计非常巧妙，很好的解决了工厂的对象创建方法代码臃肿的问题。
 
 
但是我们也发现了问题，工厂方法扩展会导致所有的子类进行强制实现，不利于后期的维护，同时如果需要一系列相关产品的生成，使用工厂方法进行继承实现会造成高度的继承耦合，不利于工厂的产品生产扩展，此时就可以运用抽象工厂进行改进，我们用抽象工厂扩展工厂方法，使用接口的形式定义一批接口，由子类工厂进行实现和后续的所有生产细节，同时还可以自定义生产的具体产品。
 
 
上面是根据案例对于本次的设计模式进行一个模式的总结，可以看到工厂模式的应用还是非常多的，在WEB领域最常用的Spring框架就是的Bean工厂就是一个非常良好的工厂模式的实践案例。
 
 
工厂模式的总结：
 
 
下面用一张表格总结工厂模式的三种形态，优缺点以及相关总结：
 
 
 
   
   
 
    模式名称 
    简单工厂 
    工厂方法 
    抽象方法 
   
 
   
   
   
 
    特点 
    根据产品按照客户端的需求生产不同的具体对象，将生产和使用的过程进行解耦 
    将工厂的创建细节延迟到工厂的子类实现。 
    定义一系列工厂方法，由子工厂负责具体的多类产品的生产 
   
 
   
 
    派生方式 
    需要修改简单工厂的代码 
    顶层工厂增加方法需要所有的子类强制实现。生产多个产品需要改动继承结构 
    扩展产品和生产具体产品非常方便。但是扩展新对象需要改动抽象工厂接口 
   
 
   
 
    优点 
    1. 简单工厂将创建对象的过程和使用对象的过程进行解耦
2. 工厂可以创建生产对象的不同实现子类，扩展子类实现非常方便		 
    1. 工厂方法将工厂生产对象的创建细节延迟到子类
2. 克服了简单工厂部分缺点，比如符合开放-关闭原则
3. 同样可以对客户端和创建对象工厂进行解耦		 
    1. 有利于多个产品的对象创建扩展
2. 将抽象类转变为接口，可以定义更高级的抽象。方便向上扩展
3. 类似制定工厂的生产规则，而具体的细节交由实现接口的子类完成		 
   
 
   
 
    缺点 
    1. 工厂扩展新的对象需要改动代码，不符合开放-关闭原则
2. 简单工厂对应简单的创建过程，所以创建过程复杂会造成工厂的臃肿		 
    1. 不利于维护，加入工厂方法需要扩展所有的子类都需要实现工厂方法
2. 当需要多个产品类的时候，更改会相当的麻烦		 
    1. 面对新的产品，需要所有的工厂实现类进行实现。
2. 最大的缺点是难以扩展新的产品，或者说扩展新产品的代价很大		 
   
 
   
 
    总结 
    是一种良好的编码和思考方式，但是严格意义上不能算是设计模式 
    将具体对象的创建过程延迟到子类，符合开放-关闭原则 
    抽象工厂是对工厂方法的升级，分离了多个产品的生产同时，子工厂可以对多个产品的生产细节进行自由控制。 
   
 
   
 
 
 
总结：
 
 
本次设计模式的文章内容比较长，由于本次设计模式虽然是一个设计模式，但是他存在三种“变体”，所以在什么使用哪一种设计还是需要依靠具体的需求环境来决定。可以看到该设计模式最容易混淆的是工厂方法和抽象工厂。希望通过本文的总结和案例可以让读者更好的了解工厂模式下这两者的使用场景和区别。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(设计模式工厂模式)

        

            

                
    
                    
  • 【iOS】MVC设计模式
                        Magnetic_h
iosmvc设计模式objective-c学习ui
                        
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    
                    
    • 
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】）
                        ok!ko
设计模式设计模式建造者模式java
                        
    文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
    
                    
    • 
                    
  • 设计模式 23 访问者模式
                        WineMonk
#设计模式设计模式访问者模式
                        
    设计模式23创建型模式（5）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式结构型模式（7）：适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式行为型模式（11）：责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式文章目录设计模式23访问者模式（VisitorPattern）1定义2结构3
    
                    
    • 
                    
  • 设计模式】Listener模式和Visitor模式的区别
                        不爱洗脚的小滕
设计模式访问者模式javagolang
                        
    文章目录前言一、介绍Listener模式Visitor模式二、代码实现2.1Listener模式的Java实现2.2Listener模式的Go实现2.3Visitor模式的Java实现2.4Visitor模式的Go实现三、总结前言在软件设计中，设计模式是解决特定问题的通用解决方案。Listener模式和Visitor模式是两种常见的行为设计模式，它们在不同的场景下提供了解决问题的有效方法。本文将详
    
                    
    • 
                    
  • 开发游戏的学习规划
                        杰克逊的日记
游戏学习
                        
    第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
    
                    
    • 
                    
  • 从单体到微服务：FastAPI ‘挂载’子应用程序的转变
                        黑金IT
fastapi微服务fastapi架构
                        
    在现代Web应用开发中，模块化架构是一种常见的设计模式，它有助于将大型应用程序分解为更小、更易于管理的部分。FastAPI，作为一个高性能的PythonWeb框架，提供了强大的支持来实现这种模块化设计。通过“挂载”子应用程序，我们可以为不同的功能区域（如前端接口、管理员接口和用户中心）创建独立的应用程序，并将它们整合到一个主应用程序中。本文将详细介绍如何在FastAPI中使用“挂载”子应用程序的方
    
                    
    • 
                    
  • [面试高频问题]关于多线程的单例模式
                        朱玥玥要每天学习
java单例模式开发语言
                        
    单例模式什么是设计模式?设计模式可以看做为框架或者是围棋中的”棋谱”,红方当头炮,黑方马来跳.根据一些固定的套路下,能保证局势不会吃亏.在日常的程序设计中,往往有许多业务场景,根据这些场景,大佬们总结出了一些固定的套路.按照这个套路来实现代码,也不会吃亏.什么是单例模式,保证某类在程序中只有一个实例,而不会创建多份实例.单例模式具体的实现方式:可分为”懒汉模式”,”饿汉模式”.饿汉模式类加载的同时
    
                    
    • 
                    
  • 从简单到复杂：三种工厂模式的对比与应用
                        技术拾光者
设计模式java设计模式简单工厂模式抽象工厂模式工厂方法模式
                        
    在软件设计中，创建型设计模式用于处理对象创建的复杂性。本文将对比三种常见的创建型设计模式：简单工厂模式、工厂方法模式和抽象工厂模式。一，简单工厂模式定义：简单工厂模式（SimpleFactoryPattern）定义了一个工厂类，该类可以根据传入的参数决定创建哪一种产品实例。结构：产品（Product）：定义产品的接口。具体产品（ConcreteProduct）：实现具体产品。工厂（Factory）
    
                    
    • 
                    
  • 当前最流行的架构设计模式
                        turingbooks

                        
    《微服务设计（第2版）》最可贵的地方在于，不光具备理论性与系统性，更为注重实践性与可操作性。全书勾勒出一幅从宏观到细节，再到组织落地的微服务架构整体实施蓝图。无论是对关注微服务领域的工程师与架构师，还是对寻求架构升级的管理者与决策者来说，本书都可以作为指导手册。——沈剑，快狗打车CTO《微服务设计（第2版）》萨姆·纽曼|著钟健鑫张沙沙智伟|译软件开发大神MartinFowler如此推荐本书：“微服
    
                    
    • 
                    
  • 互联网 Java 工程师面试题（Java 面试题四）
                        苹果酱0567
面试题汇总与解析java中间件开发语言springboot后端
                        
    下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
    
                    
    • 
                    
  • 《Android进阶之光》— Android 书籍
                        王睿丶
Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
                        
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
    
                    
    • 
                    
  • MyBatis 方法重载的陷阱及解决方案
                        molashaonian
mybatis方法重载异常方法名相同
                        
    在使用MyBatis进行开发时，尤其是使用注解模式（如@Select、@Insert等）时，开发者常常会遇到这样一个问题：为什么我的方法重载不能正常工作？即使在Java中允许方法名相同但参数不同的重载，MyBatis在处理注解的SQL方法时却并不支持这种方式。这篇文章将深入探讨MyBatis的这个特性及如何规避相关的坑。问题背景在标准的Java开发中，方法重载是一种常见的设计模式。方法重载允许我们
    
                    
    • 
                    
  • 【设计模式】结构型模式：组合模式
                        KunQAQrz

                        
    意图使用组合模式可以将对象组合成树状结构，并且能像使用独立对象一样使用它们。组合模式结构在这里插入图片描述组件（Component）接口描述了树中简单项目和复杂项目所共有的操作。叶节点（Leaf）是树的基本结构，它不包含子项目。一般情况下，叶节点最终会完成大部分的实际工作，因为它们无法将工作指派给其他部分。容器（Container）又名“组合（Composite）”是包含叶节点或其他容器等子项目的
    
                    
    • 
                    
  • Java高并发编程详解系列-Balking设计模式
                        nihui123
高并发设计模式java编程语言
                        
    导语  在实际操作中当某个线程因为发现其他线程正在进行相同的工作而放弃即将开始的任务，这种情况就被称为是Balking模式，Balking英文的意思是犹豫。在多个线程监控某个共享变量，A线程监控到共享变量发生变化后立即触发某个动作，但是这个这个时候发现了B线程也对该变量开始了行动，这个时候A变量就放弃了准备工作。下面就来详细的讲解一下关于Balking模式什么是Balking模式  在餐厅吃饭的时
    
                    
    • 
                    
  • Java高并发编程详解系列-Future设计模式
                        nihui123
高并发Java高并发Future高并发
                        
    导语  假设，在一个使用场景中有一个任务需要执行比较长的时间，通常需要等待任务执行结束之后或者是中途出错之后才能返回结果。在这个期间调用者只能等待，对于这个结果Future设计模式提供了一种凭据式的解决方案。在日常生活中，这种方案也是存在的。例如去洗衣店洗衣服，当你把衣服放到洗衣店，等他洗完需要一段时间，这个时候洗衣店就会给你一凭证，你可以通过这个凭证到时候去取洗好的衣服。这个例子就是生活中的Fu
    
                    
    • 
                    
  • 字节跳动面试官亲述：Android开发学会了这些技术，你离大厂不远了
                        m0_65322636
程序员架构移动开发android
                        
    HTTPSHTTP是超文本传输协议，明文传输；HTTPS使用SSL协议对HTTP传输数据进行了加密HTTP默认80端口；HTTPS默认443端口优点：安全缺点：费时、SSL证书收费，加密能力还是有限的，但是比HTTP强多了2、Java基础&容器&同步&设计模式StringBuilder、StringBuffer、+、String.concat链接字符串：StringBuffer线程安全，Strin
    
                    
    • 
                    
  • Android面试从新手到架构师，一篇解析就够(1)，跳槽字节跳动
                        m0_60607609
程序员androidjava面试后端
                        
    5.抽象工厂模式：结构型（7）：描述如何将类或对象按某种规则组成更大的结构1.桥接模式：对于两个或以上纬度独立变化的场景，将抽象与具体实现分离，实例：用不同颜色画不同形状2.外观模式：对外有一个统一接口，外部不用关心内部子系统的具体实现，这是"迪米特原则"的典型应用3.适配器模式：改变类的接口，使原本由于接口不匹配而无法一起工作的两个类能够在一工作，实例：RecycleView的Adapter不管
    
                    
    • 
                    
  • 生产者消费者模式_Labview基础之生产者消费者设计模式（事件）
                        weixin_39532699
生产者消费者模式
                        
    1绪论近期，开了一个QQ群，刚开始的目的也是想多拉写软件相关的大神，有问题的时候也可以交流交流。记得当时有个软件在写的时候遇到了一个棘手的问题，outlook邮箱配置账户密码的问题，到现在也没解决，算了，也不是很迫切。2000人群就留在那里爬虫发单吧！建群以后才发现，原来这一块的小白还挺多，总结起来就一个原因：做这个软件的大多数都不是软件出生，都是因为临时要搭建一个上位机平台，匆匆入门......
    
                    
    • 
                    
  • 案例分析：如何用设计模式优化性能7
                        是小旭啊
fastapi
                        
    设计模式就是对常用开发技巧进行的总结，它使得程序员之间交流问题，有了更专业、便捷的方式。比如，我们在《02|理论分析：性能优化有章可循，谈谈常用的切入点》中提到，I/O模块使用的是装饰器模式，你就能很容易想到I/O模块的代码组织方式。事实上，大多数设计模式并不能增加程序的性能，它只是代码的一种组织方式。本课时，我们将一一举例讲解和性能相关的几个设计模式，包括代理模式、单例模式、享元模式、原型模式等
    
                    
    • 
                    
  • 重修设计模式-结构型-代理模式
                        丶白泽
重修设计模式设计模式代理模式系统安全
                        
    重修设计模式-结构型-代理模式在不改变原始类代码的情况下，通过引入代理类来给原始类附加功能。代理模式通过创建一个代理对象，使得客户端对目标对象的访问都通过代理对象间接进行，从而可以在不修改目标对象的前提下，增加额外的功能操作，如权限控制、日志记录、事务处理等。代理模式又分为静态代理和动态代理。静态代理（StaticProxy）：在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前
    
                    
    • 
                    
  • 如何利用命令模式实现一个手游后端架构?
                        隔窗听雨眠
命令模式
                        
    命令模式的原理解读命令模式的英文翻译是CommandDesignPattern。在GoF的《设计模式》一书中，它是这么定义的：Thecommandpatternencapsulatesarequestasanobject,therebylettingusparameterizeotherobjectswithdifferentrequests,queueorlogrequests,andsuppo
    
                    
    • 
                    
  • 单例模式以及反射对单例模式的破坏及防御
                        CodeDunkster
单例模式javajavascript
                        
    单例模式（SingletonPattern）是一种确保类在应用程序生命周期内只存在一个实例的设计模式。它不仅提供了全局访问点，还能节省内存、控制实例的生命周期。但常见的单例模式实现方式如饿汉式、懒汉式、双重校验锁、静态内部类等，虽然设计良好，但都容易被Java的反射机制所破坏。本文将介绍这些单例实现方式的优缺点、反射如何破坏它们的唯一性，以及如何防御这种破坏。1.单例模式的常见实现方式1.1饿汉式
    
                    
    • 
                    
  • Koa2 的洋葱模型是什么？它是如何实现的？
                        极客李华
Koakoa
                        
    Koa2的洋葱模型是什么？它是如何实现的？Koa2的洋葱模型是一种中间件执行流程的设计模式，它允许开发者在请求的处理过程中，按照特定的顺序依次执行一系列中间件函数。洋葱模型的实现基于Koa2框架的特性和原理。下面我将通过一个具体的案例来解释洋葱模型的概念和实现。假设我们有一个简单的Koa2应用，用于处理用户的HTTP请求。首先，我们需要创建一个Koa应用实例：constKoa=require('k
    
                    
    • 
                    
  • 设计模式-单例模式
                        SAO&asuna
设计模式学习设计模式单例模式开发语言
                        
    文章目录1.为什么要学习单例模式2.单例模式的类型2.1饿汉式单例2.2懒汉式单例2.2.1一般实现2.2.2sync.once实现2.2.3sync.Mutex实现2.2.4原子引用2.2.5极致性能优化3单例模式的优缺点1.为什么要学习单例模式单例模式，就是在整个进程的过程中，只会存在一个实例。这样做的好处主要是两个：访问控制：访问控制也就是只有这一个口子可以得到该实例，一般是通过全局变量达到
    
                    
    • 
                    
  • 深入解析C++单例模式：从基础到线程安全的高效实现
                        shuai_258
c++全套攻略c++c++多线程开发语言c++qt
                        
    引言在C++开发中，单例模式（SingletonPattern）是一种常见且重要的设计模式。它确保类的实例在整个程序生命周期中唯一，并提供一个全局访问点。这在日志管理、配置管理等场景中尤为常见。本篇博客将带你深入了解单例模式的实现原理，并介绍如何在多线程环境下实现线程安全的单例模式。什么是单例模式？单例模式是一种设计模式，其核心思想是确保某个类只能有一个实例，并提供一个全局的访问点。其应用场景包括
    
                    
    • 
                    
  • 漫谈设计模式 [17]：状态模式
                        AI让世界更懂你
设计模式状态模式python
                        
    引导性开场菜鸟：老鸟，我最近在写一个项目，遇到一个问题。我们有一个订单系统，不同的订单状态需要执行不同的操作。现在代码里充满了各种if-else语句，维护起来好痛苦。有没有什么好的解决办法？老鸟：你这个问题很常见，很多人都会遇到类似的痛点。你有没有听说过状态模式？菜鸟：状态模式？好像听过，但不太了解。老鸟：没关系，我们可以一步步来。先讲讲你现在的实现方式吧。渐进式介绍概念菜鸟：好的，我现在是这样写
    
                    
    • 
                    
  • Java基础 --- 多线程&JUC，以及一些常用的设计模式总结
                        lzhlizihang
java设计模式
                        
    文章目录一、多线程1、线程和进程的区别2、创建多线程的四种方式3、集合中的线程安全二、设计模式1、单例模式2、装饰者模式（IO流缓冲流）3、适配器模式4、模板模式一、多线程1、线程和进程的区别进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位，一个进程可以运行多个线程多进程：操作系统中同时运行的多个程序多线程：在同一个进程中同时运行的多个任务2、创建多线程的四种方式Runna
    
                    
    • 
                    
  • 【系统架构设计师】解释器模式
                        Evaporator Core
解释器模式python开发语言
                        
    解释器模式（InterpreterPattern）是一种行为型设计模式，它定义了文法的表示，并定义了一个解释器，该解释器使用该表示来解释语言中的句子。在解释器模式中，通常包括一个抽象语法树（AbstractSyntaxTree,AST），用于表示输入的语言文法，以及一系列的解释器类，每个类对应文法中的一个符号或符号的组合。解释器模式主要适用于那些需要将一个语言中的句子解释成程序可以理解的另一种形式
    
                    
    • 
                                
  • mongodb3.03开启认证
                                    21jhf
mongodb
                                    
    下载了最新mongodb3.03版本，当使用--auth 参数命令行开启mongodb用户认证时遇到很多问题，现总结如下： 
（百度上搜到的基本都是老版本的，看到db.addUser的就是，请忽略） 
Windows下我做了一个bat文件，用来启动mongodb，命令行如下： 
mongod --dbpath db\data --port 27017 --directoryperdb --logp
    
                                
    • 
                                
  • 【Spark103】Task not serializable
                                    bit1129
Serializable
                                    
    Task not serializable是Spark开发过程最令人头疼的问题之一，这里记录下出现这个问题的两个实例，一个是自己遇到的，另一个是stackoverflow上看到。等有时间了再仔细探究出现Task not serialiazable的各种原因以及出现问题后如何快速定位问题的所在，至少目前阶段碰到此类问题，没有什么章法 
1. 
  
package spark.exampl
    
                                
    • 
                                
  • 你所熟知的 LRU(最近最少使用)
                                    dalan_123
java
                                    
    关于LRU这个名词在很多地方或听说，或使用，接下来看下lru缓存回收的实现 
1、大体的想法 
    a、查询出最近最晚使用的项 
    b、给最近的使用的项做标记 
通过使用链表就可以完成这两个操作，关于最近最少使用的项只需要返回链表的尾部；标记最近使用的项，只需要将该项移除并放置到头部，那么难点就出现 你如何能够快速在链表定位对应的该项？ 
这时候多
    
                                
    • 
                                
  • Javascript 跨域
                                    周凡杨
JavaScriptjsonp跨域cross-domain
                                    
      
                                 
    
                                
    • 
                                
  • linux下安装apache服务器
                                    g21121
apache
                                    
    安装apache  
下载windows版本apache，下载地址：http://httpd.apache.org/download.cgi 
   1.windows下安装apache   
Windows下安装apache比较简单，注意选择路径和端口即可，这里就不再赘述了。  2.linux下安装apache：  
下载之后上传到linux的相关目录，这里指定为/home/apach
    
                                
    • 
                                
  • FineReport的JS编辑框和URL地址栏语法简介
                                    老A不折腾
finereportweb报表报表软件语法总结
                                    
      JS编辑框： 
1.FineReport的js。 
作为一款BS产品，browser端的JavaScript是必不可少的。 
FineReport中的js是已经调用了finereport.js的。 
大家知道，预览报表时，报表servlet会将cpt模板转为html，在这个html的head头部中会引入FineReport的js，这个finereport.js中包含了许多内置的fun
    
                                
    • 
                                
  • 根据STATUS信息对MySQL进行优化
                                    墙头上一根草
status
                                    
    mysql  查看当前正在执行的操作，即正在执行的sql语句的方法为: 
     show processlist 命令 
  
mysql> show global status;可以列出MySQL服务器运行各种状态值，我个人较喜欢的用法是show status like '查询值%';一、慢查询mysql> show variab
    
                                
    • 
                                
  • 我的spring学习笔记7-Spring的Bean配置文件给Bean定义别名
                                    aijuans
Spring 3
                                    
    本文介绍如何给Spring的Bean配置文件的Bean定义别名？ 
 
原始的 
 
 
<bean id="business" class="onlyfun.caterpillar.device.Business">
    <property name="writer">
        <ref b
    
                                
    • 
                                
  • 高性能mysql 之 性能剖析
                                    annan211
性能mysqlmysql 性能剖析剖析
                                    
    

1 定义性能优化
  mysql服务器性能，此处定义为 响应时间。
  在解释性能优化之前，先来消除一个误解，很多人认为，性能优化就是降低cpu的利用率或者减少对资源的使用。
  这是一个陷阱。
  资源时用来消耗并用来工作的，所以有时候消耗更多的资源能够加快查询速度，保持cpu忙绿，这是必要的。很多时候发现
  编译进了新版本的InnoDB之后，cpu利用率上升的很厉害，这并不
    
                                
    • 
                                
  • 主外键和索引唯一性约束
                                    百合不是茶
索引唯一性约束主外键约束联机删除
                                    
    目标;第一步;创建两张表 用户表和文章表 
        第二步;发表文章 
  
  
  1,建表; 
    ---用户表 BlogUsers
    --userID唯一的
    --userName
    --pwd
    --sex
        

    create 
    
                                
    • 
                                
  • 线程的调度
                                    bijian1013
java多线程thread线程的调度java多线程
                                    
    1.       Java提供一个线程调度程序来监控程序中启动后进入可运行状态的所有线程。线程调度程序按照线程的优先级决定应调度哪些线程来执行。 
  
2.       多数线程的调度是抢占式的（即我想中断程序运行就中断，不需要和将被中断的程序协商） 
a) 
    
                                
    • 
                                
  • 查看日志常用命令
                                    bijian1013
linux命令unix
                                    
    一.日志查找方法，可以用通配符查某台主机上的所有服务器grep "关键字" /wls/applogs/custom-*/error.log 
  
二.查看日志常用命令1.grep '关键字' error.log：在error.log中搜索'关键字'2.grep -C10 '关键字' error.log：显示关键字前后10行记录3.grep '关键字' error.l
    
                                
    • 
                                
  • 【持久化框架MyBatis3一】MyBatis版HelloWorld
                                    bit1129
helloworld
                                    
    MyBatis这个系列的文章，主要参考《Java Persistence with MyBatis 3》。 
  样例数据 
本文以MySQL数据库为例，建立一个STUDENTS表，插入两条数据，然后进行单表的增删改查 
  
  
CREATE TABLE STUDENTS
(
stud_id int(11) NOT NULL AUTO_INCREMENT,

    
                                
    • 
                                
  • 【Hadoop十五】Hadoop Counter
                                    bit1129
hadoop
                                    
      
 1. 只有Map任务的Map Reduce Job  
	File System Counters
		FILE: Number of bytes read=3629530
		FILE: Number of bytes written=98312
		FILE: Number of read operations=0
		FILE: Number of lar
    
                                
    • 
                                
  • 解决Tomcat数据连接池无法释放
                                    ronin47
tomcat 连接池　优化
                                    
     
 近段时间，公司的检测中心报表系统(SMC)的开发人员时不时找到我，说用户老是出现无法登录的情况。前些日子因为手头上 有Jboss集群的测试工作，发现用户不能登录时，都是在Tomcat中将这个项目Reload一下就好了，不过只是治标而已，因为大概几个小时之后又会 再次出现无法登录的情况。 
  
今天上午，开发人员小毛又找到我，要我协助将这个问题根治一下，拖太久用户难保不投诉。 
简单分析了一
    
                                
    • 
                                
  • java-75-二叉树两结点的最低共同父结点
                                    bylijinnan
java
                                    
    
import java.util.LinkedList;
import java.util.List;

import ljn.help.*;
public class BTreeLowestParentOfTwoNodes {

	public static void main(String[] args) {
		/*
		 * node data is stored in
    
                                
    • 
                                
  • 行业垂直搜索引擎网页抓取项目
                                    carlwu
LuceneNutchHeritrixSolr
                                    
    公司有一个搜索引擎项目，希望各路高人有空来帮忙指导，谢谢！ 
这是详细需求： 
（1） 通过提供的网站地址(大概100-200个网站)，网页抓取程序能不断抓取网页和其它类型的文件（如Excel、PDF、Word、ppt及zip类型），并且程序能够根据事先提供的规则，过滤掉不相干的下载内容。 
（2） 程序能够搜索这些抓取的内容，并能对这些抓取文件按照油田名进行分类，然后放到服务器不同的目录中。 

    
                                
    • 
                                
  • [通讯与服务]在总带宽资源没有大幅增加之前,不适宜大幅度降低资费
                                    comsci
资源
                                    
     
 
      降低通讯服务资费，就意味着有更多的用户进入，就意味着通讯服务提供商要接待和服务更多的用户，在总体运维成本没有由于技术升级而大幅下降的情况下，这种降低资费的行为将导致每个用户的平均带宽不断下降，而享受到的服务质量也在下降，这对用户和服务商都是不利的。。。。。。。。 
 
 
    &nbs
    
                                
    • 
                                
  • Java时区转换及时间格式
                                    Cwind
java
                                    
    本文介绍Java API 中 Date, Calendar, TimeZone和DateFormat的使用，以及不同时区时间相互转化的方法和原理。 
  
问题描述： 
向处于不同时区的服务器发请求时需要考虑时区转换的问题。譬如，服务器位于东八区（北京时间，GMT+8:00），而身处东四区的用户想要查询当天的销售记录。则需把东四区的“今天”这个时间范围转换为服务器所在时区的时间范围。 

    
                                
    • 
                                
  • readonly,只读，不可用
                                    dashuaifu
jsjspdisablereadOnlyreadOnly
                                    
    readOnly 和 readonly 不同，在做js开发时一定要注意函数大小写和jsp黄线的警告！！！我就经历过这么一件事： 
使用readOnly在某些浏览器或同一浏览器不同版本有的可以实现“只读”功能，有的就不行，而且函数readOnly有黄线警告！！！就这样被折磨了不短时间！！！（期间使用过disable函数，但是发现disable函数之后后台接收不到前台的的数据！！！） 
  
    
                                
    • 
                                
  • LABjs、RequireJS、SeaJS 介绍
                                    dcj3sjt126com
jsWeb
                                    
    LABjs 的核心是 LAB（Loading and Blocking）：Loading 指异步并行加载，Blocking 是指同步等待执行。LABjs 通过优雅的语法（script 和 wait）实现了这两大特性，核心价值是性能优化。LABjs 是一个文件加载器。RequireJS 和 SeaJS 则是模块加载器，倡导的是一种模块化开发理念，核心价值是让 JavaScript 的模块化开发变得更
    
                                
    • 
                                
  • [应用结构]入口脚本
                                    dcj3sjt126com
PHPyii2
                                    
    入口脚本 
入口脚本是应用启动流程中的第一环，一个应用（不管是网页应用还是控制台应用）只有一个入口脚本。终端用户的请求通过入口脚本实例化应用并将将请求转发到应用。 
Web 应用的入口脚本必须放在终端用户能够访问的目录下，通常命名为 index.php，也可以使用 Web 服务器能定位到的其他名称。 
控制台应用的入口脚本一般在应用根目录下命名为 yii（后缀为.php），该文
    
                                
    • 
                                
  • haoop shell命令
                                    eksliang
hadoophadoop shell
                                    
     
 cat 
 chgrp 
 chmod 
 chown 
 copyFromLocal 
 copyToLocal 
 cp 
 du 
 dus 
 expunge 
 get 
 getmerge 
 ls 
 lsr 
 mkdir 
 movefromLocal 
 mv 
 put 
 rm 
 rmr 
 setrep 
 stat 
 tail 
 test 
 text 
 
    
                                
    • 
                                
  • MultiStateView不同的状态下显示不同的界面
                                    gundumw100
android
                                    
    只要将指定的view放在该控件里面，可以该view在不同的状态下显示不同的界面，这对ListView很有用，比如加载界面，空白界面，错误界面。而且这些见面由你指定布局，非常灵活。 
 
PS：ListView虽然可以设置一个EmptyView，但使用起来不方便，不灵活，有点累赘。 
 
 

<com.kennyc.view.MultiStateView xmlns:android=&qu
    
                                
    • 
                                
  • jQuery实现页面内锚点平滑跳转
                                    ini
JavaScripthtmljqueryhtml5css
                                    
    平时我们做导航滚动到内容都是通过锚点来做，刷的一下就直接跳到内容了，没有一丝的滚动效果，而且 url 链接最后会有“小尾巴”，就像#keleyi，今天我就介绍一款 jquery 做的滚动的特效，既可以设置滚动速度，又可以在 url 链接上没有“小尾巴”。 
  
效果体验：http://keleyi.com/keleyi/phtml/jqtexiao/37.htmHTML文件代码： 
&
    
                                
    • 
                                
  • kafka offset迁移
                                    kane_xie
kafka
                                    
    在早前的kafka版本中（0.8.0），offset是被存储在zookeeper中的。 
  
到当前版本（0.8.2）为止，kafka同时支持offset存储在zookeeper和offset manager（broker）中。 
  
从官方的说明来看，未来offset的zookeeper存储将会被弃用。因此现有的基于kafka的项目如果今后计划保持更新的话，可以考虑在合适
    
                                
    • 
                                
  • android > 搭建 cordova 环境
                                    mft8899
android
                                    
      
1 , 安装 node.js   
     http://nodejs.org 
     
node -v   查看版本 
  
2, 安装 npm 
  
可以先从  https://github.com/isaacs/npm/tags  下载 源码 解压到
    
                                
    • 
                                
  • java封装的比较器，比较是否全相同，获取不同字段名字
                                    qifeifei

                                    
     非常实用的java比较器，贴上代码： 
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;

i
    
                                
    • 
                                
  • 记录一些函数用法
                                    .Aky.
位运算PHP数据库函数IP
                                    
    高手们照旧忽略。 
想弄个全天朝IP段数据库，找了个今天最新更新的国内所有运营商IP段，copy到文件，用文件函数，字符串函数把玩下。分割出startIp和endIp这样格式写入.txt文件，直接用phpmyadmin导入.csv文件的形式导入。（生命在于折腾，也许你们觉得我傻X，直接下载人家弄好的导入不就可以，做自己的菜鸟，让别人去说吧） 
 
当然用到了ip2long()函数把字符串转为整型数
    
                                
    • 
                                
  • sublime text 3 rust
                                    wudixiaotie
Sublime Text
                                    
    1.sublime text 3 => install package => Rust 
2.cd ~/.config/sublime-text-3/Packages 
3.mkdir rust 
4.git clone https://github.com/sp0/rust-style 
5.cd rust-style 
6.cargo build --release 
7.ctrl
    
                                
    •