创建型模式之工厂模式2.2

分类：Express 作者：编程之家用户

什么是工厂模式？

工厂模式是创建型模式的一种，工厂是用来生产的，而在Java里，是用来生产对象实例的。


和单例模式相似，工厂模式同样聚焦于在考虑整个软件构建的情况下合理创建对象，从而保证软件的扩展性和稳定性。

工厂模式分为三种：

  • 简单工厂模式
  • 工厂方法模式
  • 抽象工厂模式

简单工厂模式（实现服务端自扩展）

服务端：提供代码的人（作者）

客户端：使用代码的人（用户）

【对于程序员来说，自己是作者，用户是普通人；那么对于发明语言,框架的人来说，创建者是作者，而普通程序员是用户】

假设没有使用简单工厂模式：

定义一个Coder接口，然后定义JavaCoder和PythonCoder实现Coder接口。客户端通过new来创建对象。（耦合）

//服务端
interface Coder {

    void express();
}

class JavaCoder implements Coder
{
    @Override
    public void express()
    {
        System.out.println("I am a Java Coder");

    }
}

class PythonCoder implements Coder
{

    @Override
    public void express()
    {
        System.out.println("I am a Python Coder");

    }
}

//===============================================================================
public class ProductManager     //客户端
{
    public static void main(String[] args) {

        Coder javaCoder = new JavaCoder();
        javaCoder.express();

        
    }



}

当服务端需要扩展一个类时：需要进行1,2两步

//服务端
interface Coder {

    void express();
}

class JavaCoder implements Coder
{
    @Override
    public void express()
    {
        System.out.println("I am a Java Coder");

    }
}

class PythonCoder implements Coder
{

    @Override
    public void express()
    {
        System.out.println("I am a Python Coder");

    }
}


class GoCoder implements Coder    //1.服务端扩展
{

    @Override
    public void express()
    {
        System.out.println("I am a Go Coder");

    }
}
//===============================================================================
public class ProductManager     //客户端
{
    public static void main(String[] args) {

        Coder javaCoder = new JavaCoder();
        javaCoder.express();

        Coder goCoder = new GoCoder();   //2.客户端跟着修改
        goCoder.express();
    }



}

服务端和客户端处于高度耦合状态。（服务端的变化会引起客户端的变化）

使用简单工厂模式：（如果服务端要扩展一个GoCoder，客户端无需做修改）

//服务端
interface Coder {

    void express();
}

class JavaCoder implements Coder
{
    @Override
    public void express()
    {
        System.out.println("I am a Java Coder");

    }
}

class PythonCoder implements Coder
{

    @Override
    public void express()
    {
        System.out.println("I am a Python Coder");

    }
}


class GoCoder implements Coder    //1.服务端扩展
{

    @Override
    public void express()
    {
        System.out.println("I am a Go Coder");

    }
}

class SimpleFactory
{

    //使用静态内部类实现单例模式
    private static class StaticClassInnerInstance {
        private static final SimpleFactory INSTANCE = new SimpleFactory();
    }
    

    public static SimpleFactory getInstance() {
        return StaticClassInnerInstance.INSTANCE;
    }

    public Coder createCoder(String language)
    {
        Coder coder = null;
        if(language.equals("Java"))
        {
            coder= new JavaCoder();

        }
        else if(language.equals("Python"))
        {
            coder= new PythonCoder();
        }
        else if(language.equals("Go"))  //2.扩展条件
        {
            coder= new GoCoder();
        }
        return coder;
    }
}
//===============================================================================
public class ProductManager     //客户端
{

    public static void main(String[] args) {

        SimpleFactory factory = SimpleFactory.getInstance();
        Coder javaCoder = factory.createCoder("Java");
        javaCoder.express();


    }



}

简单工厂UML类图：

1565531609458

简单工厂的优缺点:

优点：

解决了服务端与客户端的耦合问题，实现了服务端的自扩展。

缺点：

当客户端需要进行功能扩展时，无法在SimpleFactory中添加对应修改代码。

简单工厂可以完成服务端的自扩展，但客户端只能调用，无法扩展。

工厂方法模式（实现客户端自扩展）

//服务端
interface Coder {

    void express();
}

class JavaCoder implements Coder
{
    @Override
    public void express()
    {
        System.out.println("I am a Java Coder");

    }
}

class PythonCoder implements Coder
{

    @Override
    public void express()
    {
        System.out.println("I am a Python Coder");

    }
}


class GoCoder implements Coder    //1.服务端扩展
{

    @Override
    public void express()
    {
        System.out.println("I am a Go Coder");

    }
}

interface CoderFactory   //抽象出CoderFactory
{
    public Coder createCoder(String language);
}

class ServerFactory implements CoderFactory
{

    private static class StaticClassInnerInstance {
        private static final ServerFactory INSTANCE = new ServerFactory();
    }

    public static ServerFactory getInstance() {
        return StaticClassInnerInstance.INSTANCE;
    }

    @Override
    public Coder createCoder(String language)
    {
        Coder coder = null;
        if(language.equals("Java"))
        {
            coder= new JavaCoder();

        }
        else if(language.equals("Python"))
        {
            coder= new PythonCoder();
        }
        else if(language.equals("Go"))  //2.扩展条件
        {
            coder= new GoCoder();
        }
        return coder;
    }
}
//===============================================================================

class RustCoder implements Coder
{
    @Override
    public void express()
    {
        System.out.println("I am a Rust Coder");

    }
}

class ClientFactory implements CoderFactory
{
    private static class StaticClassInnerInstance1 {
        private static final ClientFactory INSTANCE = new ClientFactory();
    }

    public static ClientFactory getInstance() {
        return ClientFactory.StaticClassInnerInstance1.INSTANCE;
    }

    @Override
    public Coder createCoder(String language)
    {

        return new RustCoder();
    }
}

public class ProductManager     //客户端
{

    public static void main(String[] args) {

       ClientFactory clientFactory = ClientFactory.getInstance();
       Coder coder = clientFactory.createCoder("Rust");
       coder.express();
    }
}

工厂方法UML类图：

1565532368140

工厂方法模式的优缺点：

优点：实现了客户端的自扩展。

缺点：无法扩展多个产品。

抽象工厂模式（实现产品簇）

适应多个产品，加入设计师。

抽象工厂中可以生产多个产品，产品之间存在内在联系。比如说JavaCoder对应JavaDesigner。

而实例化的工厂就是根据这种内在联系来划分的。

同一个工厂的产品属于一个产品簇，不同产品簇之间是不能互相组合的。比如说GoDesigner和PythonCoder是不能组合到一个工厂里的。

//服务端
interface Coder {

    void express();
}
interface Designer {

    void express();
}


class JavaCoder implements Coder
{
    @Override
    public void express()
    {
        System.out.println("I am a Java Coder");

    }
}

class PythonCoder implements Coder
{

    @Override
    public void express()
    {
        System.out.println("I am a Python Coder");

    }
}


class GoCoder implements Coder
{

    @Override
    public void express()
    {
        System.out.println("I am a Go Coder");

    }
}

class JavaDesigner implements Designer
{
    @Override
    public void express()
    {
        System.out.println("I am a Java Designer!");

    }
}
class PythonDesigner implements Designer
{
    @Override
    public void express()
    {
        System.out.println("I am a Python Designer!");

    }
}
class GoDesigner implements Designer
{
    @Override
    public void express()
    {
        System.out.println("I am a Go Designer!");

    }
}

interface ProductFactory
{
    public Coder createCoder();
    public Designer createDesigner();

}

class GoFactory implements ProductFactory
{

    private static class StaticClassInnerInstance {
        private static final GoFactory INSTANCE = new GoFactory();
    }

    public static GoFactory getInstance() {
        return StaticClassInnerInstance.INSTANCE;
    }

    @Override
    public Coder createCoder()
    {

            Coder coder= new GoCoder();

        return coder;
    }
    @Override
    public Designer createDesigner()
    {
        Designer designer= new GoDesigner();

        return designer;
    }

}

class JavaFactory implements ProductFactory
{

    private static class StaticClassInnerInstance {
        private static final JavaFactory INSTANCE = new JavaFactory();
    }

    public static JavaFactory getInstance() {
        return StaticClassInnerInstance.INSTANCE;
    }

    @Override
    public Coder createCoder()
    {

        Coder coder= new JavaCoder();

        return coder;
    }
    @Override
    public Designer createDesigner()
    {
        Designer designer= new JavaDesigner();

        return designer;
    }

}
//===============================================================================



public class ProductManager     //客户端
{

    public static void main(String[] args) {
        JavaFactory javaFactory = JavaFactory.getInstance();
        Coder coder =javaFactory.createCoder();
        Designer designer = javaFactory.createDesigner();
        coder.express();
        designer.express();




    }



}

抽象工厂UML类图：

1565533010264

工厂模式总结

简单工厂模式：适用客户端无需扩展的应用场景

工厂方法模式：适合客户端创建单个产品的应用场景

抽象工厂模式：适合创建多个产品的应用场景（但产品类别需要固定）

-------------------------------------------------------------------------------------------------------------2019.8.11

原文地址：https://www.cnblogs.com/noneplus/p/11337158.html

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

Express 入门 创建一个express文件
根据官网 入门 express
Express 路由 02
java叫接口control什么的app.get.post等等都是请求方式我们可以在游览器输入localhost端口/或者在Apifox里面写。
Express 中间件
为了前端丢进去的时候可以直接判断中间件就是经过了这个就会被使用可以做一些自己的数据处理什么的。
Express 04 文件的上传和下载
Express 文件的上传和下载
Express 05 使用Node链接sqlite
运行命令下载app.js 增加中间件。
Express 06 制作留言板项目 创建第一个项目
基本模板来的 后面用后就有什么加什么都行。
Express 06 制作留言板项目 完
此篇完成 增删 刷新文件 的基本操作
Express VUE3 博客开发
最基本的创建 以及 添加了其他的一些插件 登录接口和四个接口
Express VUE3 博客开发 用户token验证
由于每个接口都要放就很麻烦 所以做个中间件
python实现计算器功能
1importre234defstrip_operate(exp):#合并多余的操作符5exp=exp.replace("+-","-")6exp=exp.replace("--","+")7returnexp8910defcal_exp_son(exp_son):#计算两数的乘除11if&
14.6 socket跨域
 socket.html<script>//高级api不兼容socket.io//http单向的，socket是双向的，传输都靠tcpletsocket=newWebSocket('ws://localhost:3000')socket.onopen=()=>{//多个页面通信就是先发给服务器，服务器再发给另一个页面socket.send('我
简单的MVC与SQL Server Express LocalDB
M模式：类，表示数据的应用程序和使用验证逻辑以强制实施针对这些数据的业务规则。V视图：应用程序使用动态生成HTML响应的模板文件。C控制器：处理传入的浏览器请求的类中检索模型数据，然后指定将响应返回到浏览器的视图模板。简单练习： 1、添加ControllerHelloWorldControlle
Express中间件的原理及实现
在Node开发中免不了要使用框架，比如express、koa、koa2拿使用的最多的express来举例子开发中肯定会用到很多类似于下面的这种代码varexpress=require('express');varapp=express();app.listen(3000,function(){console.log('listen3000...');});app.use(middle
原生http模块与使用express框架对比
node的http创建服务与利用Express框架有何不同原生http模块与使用express框架对比：consthttp=require("http");letserver=http.createServer(function(req,res){//服务器收到浏览器web请求后，打印一句话console.log("recvreqfrombrowser");
14.7 nginx跨域
编辑nginx文件vi/usr/local/etcginxginx.confnginx配置如下，配置后需重启nginxnginx-sreloadlocation~.*\.json{roothtml;add_header"Access-Control-Allow-Origin""*";}前端index.html<script>fetch('http://localhost:12
nodejs16使用express.static快速托管静态资源
constexpress=require('express')constapp=express()//步骤的拆解constresult=express.static('./views')app.use(result)//再次托管一下样式表的资源目录app.use('/css',express.static('./css'))//托管JS文件目录app.use('/js&#
express，中间件(body-parser，req.body获取不到参数(含postman发请求的方法)
问题描述：最近在做毕设，express里边的中间件（body-parser）失效，req.body获取不到任何值，req.query能获取到值。一开始加body-parser中间件是有用的，直到昨天加了token之后，body-parser失效。试着把token去掉，无济于事，也不是这个问题，也有说版本对不上的，换了中间件的引入方法，还是没用！！！ 后
基于 Node.js 平台的web开发框架-----express
express官网：---->传送门 expressexpress框架有许多功能，比如路由配置，中间件，对于想配置服务器的前端来说，非常便捷自从node发展之后，基于nodejs的开发框架也不断涌现出来，express就是其中之一，最近简单的写了点express框架的简单的处理请求的demo首先是安装express模块npminstall
VS2015项目启动问题:ID为60076的进程当前未运行
目录问题： 操作：Win+S按键，输入“事件查看器”问题详情：模块DLLC:\ProgramFiles(x86)\IISExpress\aspnetcore.dll未能加载。返回的数据为错误信息。问题：  操作：Win+S按键，输入“事件查看器” 问题详情：模块DLLC:\ProgramFiles(x86)\IISExpress\aspnetcore.dll
快递物流查询接口(阿里云市场接口)，调用示例
//获取阿里云市场，快递物流记录https://market.aliyun.com/products/56928004/cmapi022273.html?spm=5176.2020520132.101.26.61f97218v18GBF#sku=yuncode1627300000//get_express_log(self::$config['web']['aliyun_AppCode']阿里云市场AppCode,缓存秒数如300秒,'快递公司代
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot