设计模式

Posted 2020-10-23 gfh0917

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了设计模式相关的知识，希望对你有一定的参考价值。

常用的设计模式：

　　1）单例模式

　　　　a)饿汉式：加载时创建

　　　　b)懒汉式：会存在线程安全的隐患，因此在方法上加上同步锁（synchronized）

　　　　　　例子如下：

　　　　　　技术分享图片

　　2）工厂模式：类似于创建对象。

　　　　a)简单工厂：建立一个工厂（一个函数或一个类方法）来制造新的对象。

　　技术分享图片

　　　　b)工厂方法：定义一个用户创建对象的接口，让子类决定实例化哪一个类。Factory Method是一个类的实例化延迟到其子类。

　　　　　　优点：允许系统在不修改具体工厂角色的情况下创建新产品。

　　　　　　技术分享图片

　　　　c)抽象工厂：为创建一组相关或相互依赖的对象提供一个抽象类或接口，而且无需指定他们的具体类。

　　　　e)容器工厂：

　　　　　　代码实现如下：

　　　　　　封装配置文件中的bean配置信息：

package factory.containerfactory;

/**
 * 这里类是Bean的描述定义，封装了配置文件中的bean配置信息
 * 比如：有id属性，class属性，scope属性
 */
public class Definition {
    //bean的唯一标识
    private String id ;
    //bean的完整类名
    private String className;
    //bean的创建方式
    private String scope = "singleton";

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public String getScope() {
        return scope;
    }

    public void setScope(String scope) {
        this.scope = scope;
    }
}

　　　　核心代码块：

package factory.containerfactory;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/**
 * 容器工厂：拥有单例容器和原型容器
 */
public class ContainerFactory {
    //单例的容器（Singleton）
    private static Map<String,Object> singleton = new HashMap<String,Object>();
    //原型的容器（prototype）
    private static Map<String,Definition> prototype = new HashMap<String,Definition>();

    public ContainerFactory(String resourcePath){
        //先初始化原型容器
        initPrototype(resourcePath);
        //初始化单例容器
        initSingleton();
    }

    /**
     * 初始化原型容器
     */
    private void initPrototype(String resourcePath){
        //创建SAX解析器
        SAXReader reader = new SAXReader();

        try {
            //解析，并创建Document对象
            Document doc  = reader.read(Thread.currentThread().getContextClassLoader().getResourceAsStream(resourcePath));
            //获取doc的根节点
            Element root = doc.getRootElement();
            //获取所有的子节点
            List<Element> childs = root.elements();
            //解析子元素
            for(Element e : childs){
                //获取id属性的值
                String id = e.attributeValue("id");
                //获取class属性的值
                String className = e.attributeValue("class");
                //获取scope属性的值
                String scope = e.attributeValue("scope");
                //构建bean的描述定义
                Definition def = new Definition();
                def.setId(id);
                def.setClassName(className);
                if(scope!=null) {
                    def.setScope(scope);
                }
                //将def放入prototype容器中
                prototype.put(id,def);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 初始化单例的容器
     */
    private void initSingleton(){
        for (String key: prototype.keySet()) {
            Definition def = prototype.get(key);
            if("singleton".equals(def.getScope())){
                try {
                    singleton.put(key,Class.forName(def.getClassName()).newInstance());
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }


    public Object getBean(String name){
        return getContainerBean(name);
    }

    public <T> T getBean(String name,Class<T> clazz){
        return (T) getContainerBean(name);
   }

    private Object getContainerBean(String name){
        //获取作用域属性
        String scope = prototype.get(name).getScope();
        try {
            return ("singleton".equals(scope)) ? singleton.get(name) : Class.forName(prototype.get(name).getClassName()).newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

}

　　　　配置代码块：beans.xml文件

<?xml version="1.0" encoding="UTF-8" ?>

<beans>
    <!--
        bean可以是任意的对象，id是为这个对象在容器中的唯一标识class属性指定对象的完整类名；
        scope表示对象的创建形式，单例还是原型，默认是单例
    -->
    <bean id="miPhone" class="factory.absfactory.MiPhone" scope="singleton"/>
    <bean id="oppoPhone" class="factory.absfactory.OppoPhone" scope="prototype"/>
    <bean id="miPad" class="factory.absfactory.MiPad" scope="prototype"/>
    <bean id="oppoPad" class="factory.absfactory.OppoPad"/>
</beans>

　　　　测试代码块：

package factory.containerfactory;

import factory.absfactory.Phone;

public class Main {
    public static void main(String[] args) {
        ContainerFactory factory = new ContainerFactory("beans.xml");
        Phone phone = factory.getBean("oppoPhone", Phone.class);//Phone.class是抽象类类名

        Phone phone1 = factory.getBean("oppoPhone",Phone.class);//Phone.class是抽象类类名
        //System.out.println(phone==phone1);
　　　　　　


        phone.call();
    }


}