设计模式（二）

最新推荐文章于 2020-06-06 23:56:10 发布

weixin_33826609

最新推荐文章于 2020-06-06 23:56:10 发布

阅读量94

点赞数

文章标签：设计模式 python 开发工具

原文链接：https://my.oschina.net/haloooooo/blog/1553595

版权

2019独角兽企业重金招聘Python工程师标准>>>

三、创建型设计模式、

1）抽象工厂

抽象工厂对外提供接口，而不是具体的类。

它分离了具体的类。客户端通过接口操作实例。易于交换产品，产品声明同一接口可以自由调换。有利于产品一致。比如说产品A有新产品，只需要在增加一个工厂类并实现相应的生产类的方法即可。但是对于新种类的产品支持性并不好。比如来了一个抽象产品C 那么就要在抽象工厂接口中添加createProductC 方法。这样就会改变大量子类。这就违反类开放关闭原则。

一个抽象工厂可以通过工厂方法实现，也可以使用原型实现，一般每个具体的抽象工厂只需要一个，所以一般应该是单例的。

具体代码

package Design;

/**
 * Created with IntelliJ IDEA.
 * Date: 17/10/19
 * Time: 下午10:14
 *
 * @author: Halo
 * @version: 1.0.0
 * @Description: 抽象工厂
 */
public interface AbstarctFactory
{
    AbstractProductA CreateProductA();
    AbstractProductB CreateProductB();
}
class FactoryA implements AbstarctFactory
{

    @Override
    public AbstractProductA CreateProductA() {
        return new ProductA1();
    }

    @Override
    public AbstractProductB CreateProductB() {
        return new ProductB1();
    }
}
class FactoryB implements AbstarctFactory{

    @Override
    public AbstractProductA CreateProductA() {
        return new ProductA2();
    }

    @Override
    public AbstractProductB CreateProductB() {
        return new ProductB2();
    }
}
class Client{
    public static void main(String[] args) {
        AbstractProductA a ;
        AbstractProductB b ;
        AbstarctFactory factory;
        factory = new FactoryA();
        a = factory.CreateProductA();
        b = factory.CreateProductB();
        factory = new FactoryB();
        a = factory.CreateProductA();
        b = factory.CreateProductB();
    }
}

abstract class AbstractProductA{
}
abstract class AbstractProductB{
}
class ProductA1 extends AbstractProductA{}
class ProductA2 extends AbstractProductA{}
class ProductB1 extends AbstractProductB{}
class ProductB2 extends AbstractProductB{}

FactoryA B 就是工厂方法。

抽象工厂主要是声明接口，分离具体类的作用。

2）工厂方法

当一个类只知道要创建的接口时可以使用工厂方法。或者通过子类创建对象时。

工厂方法有两种实现： 1、creator 是一个抽象类并且不提供工厂方法的实现

2、creator 是具体的类提供默认抽象方法。

第一种方法避免了不得不实例化不可预见的类。第二种情况，用一个独立的操作创建对象。

还有一种参数化工厂方法不怎么推荐。

使用反射的方式可以避免创建子类工厂（也是需要传参的也类似于参数化工厂）。

经常与抽象工厂一起使用。与原型的区别是原型不需要产品有一个接口。原型对产品initialize操作比较多，creator对产品initialize来初始化对象。工厂方法并不是这样。

3）builder

生成器模式可以用来创建复杂对象。当构造对象允许在构造过程中有不同的表现形式（不同属性有不同的值）时可以使用Builder模式。

生成器模式对你创建的对象有更细粒度的控制。可以控制生成的组件来最后获得一个产品。由生成器生成的类差别很大所以没有对产品提供接口或抽象类。

现在很多对Builder的应用是用来创建一个List 比如Jedis 的相应代码

Builder 接口

public abstract class Builder<T> {
    public Builder() {
    }

    public abstract T build(Object var1);
}

实现类

private class MultiResponseBuilder extends Builder<List<Object>> {
    private List<Response<?>> responses;

    private MultiResponseBuilder() {
        this.responses = new ArrayList();
    }

    public List<Object> build(Object data) {
        List<Object> list = (List)data;
        List<Object> values = new ArrayList();

            for(int i = 0; i < list.size(); ++i) {
                Response<?> response = (Response)this.responses.get(i);
                response.set(list.get(i));

                Object builtResponse;
                try {
                    builtResponse = response.get();
                } catch (JedisDataException var8) {
                    builtResponse = var8;
                }

                values.add(builtResponse);
            

            return values;
        }
    }

    public void setResponseDependency(Response<?> dependency) {
        Iterator var2 = this.responses.iterator();

        while(var2.hasNext()) {
            Response<?> response = (Response)var2.next();
            response.setDependency(dependency);
        }

    }

    public void addResponse(Response<?> response) {
        this.responses.add(response);
    }
}

Composite通常由Builder生成。Builder与Abstract Factory 相似，区别在于Builder 产品类不抽象，Builder生成一个类需要一些步骤(BuilderPart -> getResult) 是最后返回的。Abstract Factory是直接返回的。

4）原型（Prototype）

制定创建的类，并且通过复制创建类。克隆自身来复制类。

原型模式涉及到深拷贝和浅拷贝的问题。

public class Prototype implements Cloneable, Serializable {

    private static final long serialVersionUID = 1L;
    private String string;

    private SerializableObject obj;

    /* 浅复制 */
    public Object clone() throws CloneNotSupportedException {
        Prototype proto = (Prototype) super.clone();
        return proto;
    }

    /* 深复制 */
    public Object deepClone() throws IOException, ClassNotFoundException {  
  
        /* 写入当前对象的二进制流 */
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);  
  
        /* 读出二进制流产生的新对象 */
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }

    public String getString() {
        return string;
    }

    public void setString(String string) {
        this.string = string;
    }

    public SerializableObject getObj() {
        return obj;
    }

    public void setObj(SerializableObject obj) {
        this.obj = obj;
    }

}

class SerializableObject implements Serializable {
    private static final long serialVersionUID = 1L;
}

如果项目中原型使用的比较多应该使用一个原型管理器来将原型注册进去，之后想要生成原型时从表中取出注册的原型来复制。

原型可以运行时增减产品，对现有的产品进行简单更改来产生类，或动态配置产品类。

5）单例

保证一个类仅有一个实例，并提供一个全局访问点。

Spring中结合抽象工厂和工厂方法的单例

public interface FactoryBean<T> {
    T getObject() throws Exception;

    Class<?> getObjectType();

    boolean isSingleton();
}

public abstract class AbstractFactoryBean<T> implements FactoryBean<T>, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean {
    protected final Log logger = LogFactory.getLog(this.getClass());
    private boolean singleton = true;
    private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();
    private BeanFactory beanFactory;
    private boolean initialized = false;
    private T singletonInstance;
    private T earlySingletonInstance;

    public AbstractFactoryBean() {
    }

    public void setSingleton(boolean singleton) {
        this.singleton = singleton;
    }

    public boolean isSingleton() {
        return this.singleton;
    }

    public void setBeanClassLoader(ClassLoader classLoader) {
        this.beanClassLoader = classLoader;
    }

    public void setBeanFactory(BeanFactory beanFactory) {
        this.beanFactory = beanFactory;
    }

    protected BeanFactory getBeanFactory() {
        return this.beanFactory;
    }

    protected TypeConverter getBeanTypeConverter() {
        BeanFactory beanFactory = this.getBeanFactory();
        return (TypeConverter)(beanFactory instanceof ConfigurableBeanFactory ? ((ConfigurableBeanFactory)beanFactory).getTypeConverter() : new SimpleTypeConverter());
    }

    // 启动时调用 默认为饿汉式
    public void afterPropertiesSet() throws Exception {
        if (this.isSingleton()) {
            this.initialized = true;
            this.singletonInstance = this.createInstance();
            this.earlySingletonInstance = null;
        }

    }

    public final T getObject() throws Exception {
        if (this.isSingleton()) {
            return this.initialized ? this.singletonInstance : this.getEarlySingletonInstance();
        } else {
            return this.createInstance();
        }
    }
    
    private T getEarlySingletonInstance() throws Exception {
        Class<?>[] ifcs = this.getEarlySingletonInterfaces();
        if (ifcs == null) {
            throw new FactoryBeanNotInitializedException(this.getClass().getName() + " does not support circular references");
        } else {
            if (this.earlySingletonInstance == null) {
                this.earlySingletonInstance = Proxy.newProxyInstance(this.beanClassLoader, ifcs, new AbstractFactoryBean.EarlySingletonInvocationHandler());
            }

            return this.earlySingletonInstance;
        }
    }
    
    private T getSingletonInstance() throws IllegalStateException {
        if (!this.initialized) {
            throw new IllegalStateException("Singleton instance not initialized yet");
        } else {
            return this.singletonInstance;
        }
    }

    public void destroy() throws Exception {
        if (this.isSingleton()) {
            this.destroyInstance(this.singletonInstance);
        }

    }

    public abstract Class<?> getObjectType();
    
    // 模板方法 创建在子类实现。 工厂方法。
    protected abstract T createInstance() throws Exception;

    protected Class<?>[] getEarlySingletonInterfaces() {
        Class<?> type = this.getObjectType();
        return type != null && type.isInterface() ? new Class[]{type} : null;
    }

    protected void destroyInstance(T instance) throws Exception {
    }

    private class EarlySingletonInvocationHandler implements InvocationHandler {
        private EarlySingletonInvocationHandler() {
        }

        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            if (ReflectionUtils.isEqualsMethod(method)) {
                return proxy == args[0];
            } else if (ReflectionUtils.isHashCodeMethod(method)) {
                return System.identityHashCode(proxy);
            } else if (!AbstractFactoryBean.this.initialized && ReflectionUtils.isToStringMethod(method)) {
                return "Early singleton proxy for interfaces " + ObjectUtils.nullSafeToString(AbstractFactoryBean.this.getEarlySingletonInterfaces());
            } else {
                try {
                    return method.invoke(AbstractFactoryBean.this.getSingletonInstance(), args);
                } catch (InvocationTargetException var5) {
                    throw var5.getTargetException();
                }
            }
        }
    }
}