码迷,mamicode.com
首页 > 其他好文 > 详细

(原创)我眼中的设计模式系列之简单工厂模式(一)

时间:2017-10-21 22:29:41      阅读:156      评论:0      收藏:0      [点我收藏+]

标签:结构   nbsp   rac   相关   catch   ret   一起   模块化   软件   

简单工厂模式

  在日常的软件开发中,我们一般都是按照模块来划分工作的。

场景一:

  试想我们现在有这么一个模块,为其他的模块提供服务,比如说我们调用了好几个外部接口,统一返回XML字符串,每个接口返回的XML格式都不同,有的嵌套数组,有的纯数组,有的就是普通的节点XML。但是我们项目需要的是json格式的数据,通常的做法是写几个类,直接new出对象调用,或者交给spring管理进行注入。不管如何这几个解析类都不是在同一个环境中,即使交由Spring管理,就站在这个模块的角度中来说,这几个类并并没有形成自己的模块化数据结构,而是分开和Spring的环境分散的耦合在一起了。代码的结构会非常差。

场景二:

  我们的业务模块中需要的类有可能是不相关的,毫无联系的,但是我们在一个比较大型的功能中需要同时用到这些类中的行为,这个时候我认为是可以使用工厂模式。即这些类实现同一个接口,使用工厂去维护他们,只针对我们需要的业务模块的维护,工厂类可以交给Spring管理,作为这个工厂和Spirng的接口,相当于跟Spring的环境有关系但是又不耦合。

  下面我举个小例子可以说明工厂模式的使用,直接上代码:

先创建具体行为的Animal接口

package com.bane.example1.executor;

/**
 * 
* @ClassName: Animal 
* @Description: TODO(定义动物的接口) 
* @author 于继伟
* @date 2017-10-20 下午10:06:49 
*
 */
public interface Animal {
}

创建具体动物行为的接口:

package com.bane.example1.executor;

/**
 * 
* @ClassName: CatExecutor 
* @Description: TODO(Cat的行为接口) 
* @author 于继伟
* @date 2017-10-20 下午10:02:29 
*
 */
public interface CatExecutor extends Animal {
    
    /**
     * 抓老鼠的行为
     */
    void catchMouse();
    
}
package com.bane.example1.executor;

/**
 * 
* @ClassName: DogExecutor 
* @Description: TODO(Dog的行为接口) 
* @author 于继伟
* @date 2017-10-20 下午10:00:12 
*
 */
public interface DogExecutor extends Animal {
    
    /**
     * 看家的方法
     */
    void door();
    
}
package com.bane.example1.executor;

/**
 * 
* @ClassName: SnakeExecutor 
* @Description: TODO(Snake的行为接口) 
* @author 于继伟
* @date 2017-10-20 下午10:04:46 
*
 */
public interface SnakeExecutor extends Animal {
    
    /**
     * 咬人的行为
     */
    void bite();
    
}

再创建具体的实现:

package com.bane.example1.executor.impl;

import com.bane.example1.executor.CatExecutor;

/**
 * 
* @ClassName: CatExecutorImpl 
* @Description: TODO(猫具体行为的实现) 
* @author 于继伟
* @date 2017-10-20 下午10:09:11 
*
 */
public class CatExecutorImpl implements CatExecutor {
    
    @Override
    public void catchMouse() {
        System.out.println("抓老鼠");
    }
    
}
package com.bane.example1.executor.impl;

import com.bane.example1.executor.DogExecutor;

/**
 * 
* @ClassName: DogExecutorImpl 
* @Description: TODO(狗的行为的具体实现) 
* @author 于继伟
* @date 2017-10-20 下午10:09:08 
*
 */
public class DogExecutorImpl implements DogExecutor{
    
    @Override
    public void door() {
        System.out.println("狗看家");
    }
    
}
package com.bane.example1.executor.impl;

import com.bane.example1.executor.SnakeExecutor;

/**
 * 
* @ClassName: SnakeExecutorImpl 
* @Description: TODO(蛇具体行为) 
* @author 于继伟
* @date 2017-10-20 下午10:11:19 
*
 */
public class SnakeExecutorImpl implements SnakeExecutor {
    
    @Override
    public void bite() {
        System.out.println("蛇咬人");
    }
    
}

工厂环境中的具体行为者有了,现在创建工厂的接口和实现:

package com.bane.example1.factory;

import com.bane.example1.executor.Animal;

/**
 * 
* @ClassName: AnimalFactory 
* @Description: TODO(简单工厂接口) 
* @author 于继伟
* @date 2017-10-20 下午9:57:46 
*
 */
public interface AnimalFactory {
    
    /**
     * 根据类名创建Animal对象
     * @param className
     * @return
     */
    Animal createAnimal(String className);
    
}
package com.bane.example1.factory.impl;

import com.bane.example1.executor.Animal;
import com.bane.example1.factory.AnimalFactory;

/**
 * 
* @ClassName: AnimalFactoryImpl 
* @Description: TODO(动物工厂的具体实现) 
* @author 于继伟
* @date 2017-10-20 下午10:14:03 
*
 */
public class AnimalFactoryImpl implements AnimalFactory {
    
    @Override
    public Animal createAnimal(String className) {
        
        Animal animal = null;
        try {
            animal = (Animal) Class.forName(className).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        
        return animal;
    }
    
}

 

到此为止,我们的简单工厂创建结束,将动物放入动物的工厂中,我们需要用的时候只需要从工厂中获取动物的实例和行为,就可以使用了,测试类:

package com.bane.example1;

import com.bane.example1.executor.CatExecutor;
import com.bane.example1.executor.DogExecutor;
import com.bane.example1.executor.SnakeExecutor;
import com.bane.example1.factory.AnimalFactory;
import com.bane.example1.factory.impl.AnimalFactoryImpl;

/**
 * 
* @ClassName: Main 
* @Description: TODO(主方法测试) 
* @author 于继伟
* @date 2017-10-20 下午10:21:48 
*
 */
public class Main {
    
    public static void main(String[] args) {
        
        AnimalFactory animalFactory = new AnimalFactoryImpl();
        
        CatExecutor catExecutor = (CatExecutor) animalFactory.
                createAnimal("com.bane.example1.executor.impl.CatExecutorImpl");
        catExecutor.catchMouse();
        
        DogExecutor dogExecutor = (DogExecutor) animalFactory.
        createAnimal("com.bane.example1.executor.impl.DogExecutorImpl");
        dogExecutor.door();
        
        SnakeExecutor snakeExecutor = (SnakeExecutor) animalFactory.
        createAnimal("com.bane.example1.executor.impl.SnakeExecutorImpl");
        snakeExecutor.bite();
    }
    
}

控制台输出如下:

抓老鼠
狗看家
蛇咬人

需要说明的是,我们是用类名利用反射创建的实例,这样可以省去if else的判断,代码更加优雅。至于需要用什么样的方式去创建或者什么样的条件,这个可以自己灵活使用。至此,简单工厂到此为止。

 

 静态工厂

  静态工厂,其实跟上面的简单工厂没有任何的区别,无疑是工厂类中构造方法是私有的,方法都是静态的。直接上代码:

创建颜色的接口和具体的颜色实现:

package com.bane.example2.executor;

/**
 * 
* @ClassName: Color 
* @Description: TODO(定义颜色行为接口) 
* @author 于继伟
* @date 2017-10-21 下午12:11:28 
*
 */
public interface Color {
    
    void show();
    
}

具体实现:

package com.bane.example2.executor.impl;

import com.bane.example2.executor.Color;

/**
 * 
* @ClassName: Blue 
* @Description: TODO(Blue具体实现) 
* @author 于继伟
* @date 2017-10-21 下午12:13:17 
*
 */
public class Blue implements Color{
    
    @Override
    public void show() {
        System.out.println("这是蓝色");
    }
    
}
package com.bane.example2.executor.impl;

import com.bane.example2.executor.Color;

/**
 * 
* @ClassName: Red 
* @Description: TODO(Red具体实现) 
* @author 于继伟
* @date 2017-10-21 下午12:12:43 
*
 */
public class Red implements Color{
    
    @Override
    public void show() {
        System.out.println("我是红色");
    }
    
}
package com.bane.example2.executor.impl;

import com.bane.example2.executor.Color;

/**
 * 
* @ClassName: Yellow 
* @Description: TODO(Yellow具体实现) 
* @author 于继伟
* @date 2017-10-21 下午12:13:51 
*
 */
public class Yellow implements Color{
    
    @Override
    public void show() {
        System.out.println("这是黄色");
    }
    
}

最后创建我们的静态工厂:

package com.bane.example2.factory;

import com.bane.example2.executor.Color;

/**
 * 
* @ClassName: ColorFactory 
* @Description: TODO(静态工厂实现) 
* @author 于继伟
* @date 2017-10-21 下午12:16:49 
*
 */
public class ColorFactory {
    
    private ColorFactory(){}
    
    /**
     * 静态工厂获取Color对象的方法
     * @param className
     * @return
     */
    public static Color createColor(String className){
        Color color = null;
        try {
            color = (Color) Class.forName(className).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        
        return color;
    }
    
}

最后主方法测试静态工厂:

package com.bane.example2;

import com.bane.example2.executor.Color;
import com.bane.example2.factory.ColorFactory;

/**
 * 
* @ClassName: Main 
* @Description: TODO(主方法测试静态工厂) 
* @author 于继伟
* @date 2017-10-21 下午12:19:14 
*
 */
public class Main {
    
    public static void main(String[] args) {
        
        Color blue = ColorFactory.createColor
                ("com.bane.example2.executor.impl.Blue");
        blue.show();
        
        Color red = ColorFactory.createColor
                ("com.bane.example2.executor.impl.Red");
        red.show();
        
        Color yellow = ColorFactory.createColor
                ("com.bane.example2.executor.impl.Yellow");
        yellow.show();
        
    }
    
}

控制台输出:

package com.bane.example2;

import com.bane.example2.executor.Color;
import com.bane.example2.factory.ColorFactory;

/**
 * 
* @ClassName: Main 
* @Description: TODO(主方法测试静态工厂) 
* @author 于继伟
* @date 2017-10-21 下午12:19:14 
*
 */
public class Main {
    
    public static void main(String[] args) {
        
        Color blue = ColorFactory.createColor
                ("com.bane.example2.executor.impl.Blue");
        blue.show();
        
        Color red = ColorFactory.createColor
                ("com.bane.example2.executor.impl.Red");
        red.show();
        
        Color yellow = ColorFactory.createColor
                ("com.bane.example2.executor.impl.Yellow");
        yellow.show();
        
    }
    
}

控制台输出:

这是蓝色
我是红色
这是黄色

至此,静态工厂结束。

 

抽象工厂

  抽象工厂其实就是集中了好几种的工厂,常用的例子是我们的家有厨房,卫生间,房间。这三个都可以看作工厂。厨房里有菜刀,锅等等,是具体的事物行为;卫生间有马桶,淋浴头等具体的事物行为;房间有衣柜,床等具体的行为。今天我举了一个更容易理解的例子。我们的公司有各个部门,例如行政部管的是后勤服务等等,财务部管的是财务和结算等等,开发部负责软件的开发。公司就是一个抽象工厂,而这三个部门就是抽象工厂的具体工厂,抽象工厂定义行为,具体的工厂实现行为。至于我们刚才说的具体三个部门作为工厂,其实,每个部门内部还有很多员工和级别,这又可以继续往下分和扩展,但是我们一般不会那么做。因为那样类的结构过于复杂,跟我们设计模式的初衷不相符。下面直接上代码:

创建Department接口,没有任何行为,主要是为了统一部门的表现形式

 

package com.bane.example3.executor;

/**
 * 
* @ClassName: Company 
* @Description: TODO(公司的接口) 
* @author 于继伟
* @date 2017-10-21 下午12:36:38 
*
 */
public interface Department {
}

具体部门接口:

package com.bane.example3.executor;

/**
 * 
* @ClassName: CaiWuBuExecutor 
* @Description: TODO(财务部的行为接口) 
* @author 于继伟
* @date 2017-10-21 下午12:29:14 
*
 */
public interface CaiWuBuExecutor extends Department{
    
    /**
     * 结算的方法
     */
    void jiesuan();
    
}    
package com.bane.example3.executor;

/**
 * 
* @ClassName: KaiFabuExecutor 
* @Description: TODO(开发部的行为接口) 
* @author 于继伟
* @date 2017-10-21 下午12:28:42 
*
 */
public interface KaiFabuExecutor extends Department {
    
    /**
     * 开发的方法
     */
    void kaifa();
    
}
package com.bane.example3.executor;

/**
 * 
* @ClassName: XingZhengBuExecutor 
* @Description: TODO(行政部的行为接口) 
* @author 于继伟
* @date 2017-10-21 下午12:29:33 
*
 */
public interface XingZhengBuExecutor extends Department {
    
    /**
     * 后勤的方法
     */
    void houqin();
    
}

部门的具体实现:

package com.bane.example3.executor.impl;

import com.bane.example3.executor.CaiWuBuExecutor;

/**
 * 
* @ClassName: CaiWuBuExecutorImpl 
* @Description: TODO(财务部具体实现) 
* @author 于继伟
* @date 2017-10-21 下午12:47:44 
*
 */
public class CaiWuBuExecutorImpl implements CaiWuBuExecutor {

    @Override
    public void jiesuan() {
        System.out.println("财务部负责结算");
    }
    
}
package com.bane.example3.executor.impl;

import com.bane.example3.executor.KaiFabuExecutor;

/**
 * 
* @ClassName: KaiFabuExecutorImpl 
* @Description: TODO(开发部具体实现) 
* @author 于继伟
* @date 2017-10-21 下午12:48:17 
*
 */
public class KaiFabuExecutorImpl implements KaiFabuExecutor {

    @Override
    public void kaifa() {
        System.out.println("开发部负责开发");
    }
    
    
    
}
package com.bane.example3.executor.impl;

import com.bane.example3.executor.XingZhengBuExecutor;

/**
 * 
* @ClassName: XingZhengBuExecutorImpl 
* @Description: TODO(行政部具体实现) 
* @author 于继伟
* @date 2017-10-21 下午12:48:48 
*
 */
public class XingZhengBuExecutorImpl implements XingZhengBuExecutor {

    @Override
    public void houqin() {
        System.out.println("行政部负责后勤");
    }
    
}

跟之前一样,具体的行为有了,可以定义工厂类了:

package com.bane.example3.factory;

import com.bane.example3.executor.CaiWuBuExecutor;
import com.bane.example3.executor.KaiFabuExecutor;
import com.bane.example3.executor.XingZhengBuExecutor;

/**
 * 
* @ClassName: AbstractFactory 
* @Description: TODO(抽象工厂) 
* @author 于继伟
* @date 2017-10-21 下午12:23:46 
*
 */
public abstract class AbstractCompanyFactory {
    
    /**
     * 构建财务部
     * @param className
     * @return
     */
    public CaiWuBuExecutor createCaiwuBu(String className){return null;}
    
    /**
     * 构建开发部
     * @param className
     * @return
     */
    public KaiFabuExecutor createKaiFabu(String className){return null;}
    
    /**
     * 构建行政部
     * @param className
     * @return
     */
    public XingZhengBuExecutor createXingZhengBu(String className){return null;}
    
}
package com.bane.example3.factory.sub;

import com.bane.example3.executor.CaiWuBuExecutor;
import com.bane.example3.executor.Department;
import com.bane.example3.factory.AbstractCompanyFactory;

/**
 * 
* @ClassName: CaiWuBuFactory 
* @Description: TODO(财务部的工厂) 
* @author 于继伟
* @date 2017-10-21 下午12:26:53 
*
 */
public class CaiWuBuFactory extends AbstractCompanyFactory {

    @Override
    public CaiWuBuExecutor createCaiwuBu(String className) {
        Department department = null;
        try {
            department = (Department) Class.forName(className).newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return (CaiWuBuExecutor) department;
    }

}
package com.bane.example3.factory.sub;

import com.bane.example3.executor.Department;
import com.bane.example3.executor.KaiFabuExecutor;
import com.bane.example3.factory.AbstractCompanyFactory;

/**
 * 
* @ClassName: KaiFaBuFactory 
* @Description: TODO(开发部的工厂) 
* @author 于继伟
* @date 2017-10-21 下午12:25:53 
*
 */
public class KaiFaBuFactory extends AbstractCompanyFactory {

    @Override
    public KaiFabuExecutor createKaiFabu(String className) {
        Department department = null;
        try {
            department = (Department) Class.forName(className).newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return (KaiFabuExecutor) department;
    }

}
package com.bane.example3.factory.sub;

import com.bane.example3.executor.Department;
import com.bane.example3.executor.XingZhengBuExecutor;
import com.bane.example3.factory.AbstractCompanyFactory;

/**
 * 
* @ClassName: XingZhengBuFactory 
* @Description: TODO(行政部的工厂) 
* @author 于继伟
* @date 2017-10-21 下午12:26:12 
*
 */
public class XingZhengBuFactory extends AbstractCompanyFactory{

    @Override
    public XingZhengBuExecutor createXingZhengBu(String className) {
        Department department = null;
        try {
            department = (Department) Class.forName(className).newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return (XingZhengBuExecutor) department;
    }

}

最后写主方法测试:

package com.bane.example3;

import com.bane.example3.executor.CaiWuBuExecutor;
import com.bane.example3.executor.KaiFabuExecutor;
import com.bane.example3.executor.XingZhengBuExecutor;
import com.bane.example3.factory.AbstractCompanyFactory;
import com.bane.example3.factory.sub.CaiWuBuFactory;
import com.bane.example3.factory.sub.KaiFaBuFactory;
import com.bane.example3.factory.sub.XingZhengBuFactory;

/**
 * 
* @ClassName: Main 
* @Description: TODO(抽象工厂测试) 
* @author 于继伟
* @date 2017-10-21 下午12:22:48 
*
 */
public class Main {
    
    public static void main(String[] args) {
        //1.获取具体的工厂
        //财务部的工厂
        AbstractCompanyFactory caiwuFactory = new CaiWuBuFactory();
        
        //开发部的工厂
        AbstractCompanyFactory kaifaFactory = new KaiFaBuFactory();
        
        //行政部的工厂
        AbstractCompanyFactory xingZhengFactory = new XingZhengBuFactory();
        
        //2.从工厂中获取具体的部门职能
        //财务职能
        CaiWuBuExecutor caiwu = caiwuFactory.createCaiwuBu
                ("com.bane.example3.executor.impl.CaiWuBuExecutorImpl");
        
        //开发职能
        KaiFabuExecutor kaifa = kaifaFactory.createKaiFabu
                ("com.bane.example3.executor.impl.KaiFabuExecutorImpl");
        
        //后勤职能
        XingZhengBuExecutor xingzheng = xingZhengFactory.createXingZhengBu
                ("com.bane.example3.executor.impl.XingZhengBuExecutorImpl");
        
        caiwu.jiesuan();
        kaifa.kaifa();
        xingzheng.houqin();
    }
    
}

控制台输出:

财务部负责结算
开发部负责开发
行政部负责后勤

 

   上面就是我们工厂模式常用的三种表现形式,从上面的代码我们不难看出接口的作用,面向接口编程是JAVA开发中非常重要的一个理念,或者说是思想,根据SOA的思想来说,暴露出来的一定是接口,接口实现的对象类型的控制和扩展,在面向对象程序的设计中具有非常至关重要的意义。至于面向接口编程,大家可以搜索一下相关的文章去阅读。

  其实我们的Spring就是一个非常大的工厂模式,阅读过源码的同学可以知道,Spring基于BeanFactory,创建出Bean,但是又维护着自己的数据结构,源于工厂,但是比工厂的设计复杂太多太多。工厂模式我的理解就是这样。

 

(原创)我眼中的设计模式系列之简单工厂模式(一)

标签:结构   nbsp   rac   相关   catch   ret   一起   模块化   软件   

原文地址:http://www.cnblogs.com/yujiwei/p/7705611.html

(0)
(0)
   
举报
评论 一句话评论(0
0条  
登录后才能评论!
© 2014 mamicode.com 版权所有 京ICP备13008772号-2
迷上了代码!