创建型模式【2】——工厂设计模式

深藏阁楼爱情的钟 2023-03-14 13:20 210阅读 0赞

>  *   [https://en.wikipedia.org/wiki/Design\_Patterns][https_en.wikipedia.org_wiki_Design_Patterns]
>  *  [https://en.wikipedia.org/wiki/Design\_Patterns\#Patterns\_by\_Type][https_en.wikipedia.org_wiki_Design_Patterns_Patterns_by_Type]

--------------------

# 1 不用工厂实现业务  #

public abstract class Video {
        //生产视频
        public abstract void produce();
    }
    public class JavaVideo extends Video {
        @Override
        public void produce() {
            System.out.println("录制Java课程视频");
        }
    }
    public class PythonVideo extends Video {
        @Override
        public void produce() {
            System.out.println("录制Python课程视频");
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70][]

--------------------

# 2 简单工厂 #

## 2.1 简单工厂分析 ##

>  *  **定义** : 由一个工厂对象决定创建出哪一种产品类的实例
>  *  **类型** : 创建型，但**不属于**GOF23种设计模式

> **适用场景**
> 
>  *  工厂类负责创建的对象比较少
>  *  客户端(应用层)只知道传入工厂类的参数，对于如何创建对象(逻辑)不关心

>  *  **优点** : 只需要传入一个正确的参数，就可以获取你所需要的对象，而无须知道其创建细节
>  *  **缺点** : 工厂类的职责相对过重，增加新的产品，需要修改工厂类的判断逻辑，**违背开闭原则**

## 2.2 Coding ##

public class VideoFactory {
        //可以用static修饰，调用更简单
        public Video getVideo(String type) {
            if ("java".equalsIgnoreCase(type)) {
                return new JavaVideo();
            } else if ("python".equalsIgnoreCase(type)) {
                return new PythonVideo();
            }
            //如需增加，还需要修改代码才能实现,不符合开闭原则
            return null;
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 1][]

## 2.3 升级简单工厂  ##

public class VideoFactory {
        public Video getVideo(Class c) {
            Video video = null;
            try {
                // 后面需要增加产品这里无需改动
                video = (Video) Class.forName(c.getName()).newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            return video;
        }
    }

public class VideoTest {
        @Test
        public void test() {
            VideoFactory videoFactory = new VideoFactory();
            Video video = videoFactory.getVideo(JavaVideo.class);
            if (video == null) {
                return;
            }
            video.produce(); // 录制Java课程视频
        }
    }

--------------------

# 3 工厂方法 #

>  *  **定义** : 定义一个创建对象的接口，让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行
>  *  **类型** : 创建型

> **适用场景**
> 
> 1.  创建对象需要大量重复的代码
> 2.  客户端(应用层)不依赖于产品类实例如何被创建、实现等细节
> 3.  一个类通过其子类来指定创建哪个对象

>  *  **优点** : 用户只需要关心所需产品对应的工厂，无须关心创建细节；加入新产品符合开闭原则，提高可扩展性
>  *  **缺点** : 类的个数容易过多，增加复杂度；增加了系统的抽象性和理解难度

public abstract class VideoFactory {
        public abstract Video getVideo();
    }
    public class JavaVideoFactory extends VideoFactory {
        @Override
        public Video getVideo() {
            return new JavaVideo();
        }
    }
    public class PythonVideoFactory extends VideoFactory {
        @Override
        public Video getVideo() {
            return new PythonVideo();
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 2][]

> **源码分析 **

//java.util.Collection
    public interface Collection<E> extends Iterable<E> {
        //具体实现交给子类
        Iterator<E> iterator();
    //java.util.ArrayList
    public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
        public Iterator<E> iterator() {
            return new Itr();
        }
        private class Itr implements Iterator<E> {

//<dependency>
    //    <groupId>org.slf4j</groupId>
    //    <artifactId>slf4j-api</artifactId>
    //    <version>1.7.30</version>
    //</dependency>
    //<dependency>
    //    <groupId>ch.qos.logback</groupId>
    //    <artifactId>logback-classic</artifactId>
    //    <version>1.2.3</version>
    //</dependency>
    
    //org.slf4j.LoggerFactory#getLogger(java.lang.String)
    public static Logger getLogger(String name) {
    	ILoggerFactory iLoggerFactory = getILoggerFactory();
    	return iLoggerFactory.getLogger(name);
    }
    public interface ILoggerFactory {
        //工厂方法
        public Logger getLogger(String name);
    }
    
    //ch.qos.logback.classic.LoggerContext#getLogger(java.lang.String)
    public final Logger getLogger(String name) {
    //org.slf4j.helpers.NOPLoggerFactory#getLogger
    public Logger getLogger(String name) {
    //org.slf4j.helpers.SubstituteLoggerFactory#getLogger
    synchronized public  Logger getLogger(String name) {

--------------------

# 4 抽象工厂 #

>  *  **定义** : 抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，无须指定它们具体的类
>  *  **类型** : 创建型

> **适用场景**
> 
>  *  客户端(应用层)不依赖于产品类实例如何被创建、实现等细节
>  *  强调一系列相关的产品对象(属于同一产品族)一起使用创建对象需要大量重复的代码
>  *  提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现

>  *  **优点** : 具体产品在应用层代码隔离，无须关心创建细节；将一个系列的产品族统一到一起创建
>  *  **缺点** : 规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口；增加了系统的抽象性和理解难度

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 3][]

public abstract class Article {
        public abstract void produce();
    }
    public class JavaArticle extends Article {
        @Override
        public void produce() {
            System.out.println("编写Java课程手记");
        }
    }
    public class PythonArticle extends Article {
        @Override
        public void produce() {
            System.out.println("编写Python课程手记");
        }
    }

public abstract class Video {
        public abstract void produce();
    }
    public class JavaVideo extends Video {
        @Override
        public void produce() {
            System.out.println("录制Java课程视频");
        }
    }
    public class PythonVideo extends Video {
        @Override
        public void produce() {
            System.out.println("录制Python课程视频");
        }
    }

public interface CourseFactory {
        Video getVideo();
        Article getArticle();
    }
    public class JavaCourseFactory implements CourseFactory {
        @Override
        public Video getVideo() {
            return new JavaVideo();
        }
        @Override
        public Article getArticle() {
            return new JavaArticle();
        }
    }
    public class PythonCourseFactory implements CourseFactory {
        @Override
        public Video getVideo() {
            return new PythonVideo();
        }
        @Override
        public Article getArticle() {
            return new PythonArticle();
        }
    }

public class VideoAndArticleTest {
        // 新增产品族容易（满足开闭原则）
        // 新增产品等级麻烦，需要修改原有的代码（违背了开闭原则），比如除了视频手记之外还需要增加源代码才是一个完整的课程，这个时候对原有的修改就比较大了
        // 适合于产品等级固定，产品族多变的环境
       @Test
       public void test(){
           CourseFactory courseFactory = new JavaCourseFactory();
           // 取出的一定是JAVA产品族，减少产生错误的可能
           Video video = courseFactory.getVideo();
           Article article = courseFactory.getArticle();
           video.produce(); // 录制Java课程视频
           article.produce(); // 编写Java课程手记
       }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 4][]

> **源码分析 **

//java.sql.Connection
    public interface Connection  extends Wrapper, AutoCloseable {
    
    //<dependency>
    //    <groupId>mysql</groupId>
    //    <artifactId>mysql-connector-java</artifactId>
    //    <version>8.0.20</version>
    //</dependency>
    //com.mysql.cj.jdbc.ConnectionImpl
    public class ConnectionImpl implements JdbcConnection, SessionEventListener, Serializable {

//java.sql.Statement
    public interface Statement extends Wrapper, AutoCloseable {

//<dependency>
    //    <groupId>org.mybatis</groupId>
    //    <artifactId>mybatis</artifactId>
    //    <version>3.5.4</version>
    //</dependency>
    
    //org.apache.ibatis.session.SqlSessionFactory
    public interface SqlSessionFactory {

[https_en.wikipedia.org_wiki_Design_Patterns]: https://en.wikipedia.org/wiki/Design_Patterns
[https_en.wikipedia.org_wiki_Design_Patterns_Patterns_by_Type]: https://en.wikipedia.org/wiki/Design_Patterns#Patterns_by_Type
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70]: /images/20230312/9d06889cdefc4b5dbf66da5aac045275.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 1]: /images/20230312/0088b9d16a5e462282075a77ba4273e8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 2]: /images/20230312/86ae330d0e894dc4acc94452cd014909.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 3]: /images/20230312/ec3888d396294329881682a09f0b5a28.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 4]: /images/20230312/cb440c506a9440b892d68b25e12b7dd1.png