设计模式

常用的设计模式：

　　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();
    }


}

　　3）策略模式

　　4）模板方法模式：

　　　　定义：在父类中定义一个模板方法，这就是设计模式

　　5）责任链模式:

　　　　分类：a)纯的责任链：只能也必须只有一个任务处理者去处理这个任务，不会出现没有处理者处理的情况，也不会出现有多个处理者处理同一个任务。

　　　　　　　b)不纯的责任链：可以有多个任务处理者同时处理一个任务，那么就表示这个任务是大家一起共享的。或者也可以没有任何处理者去处理它。

　　　　定义：责任链模式的关键在于每一个任务处理者都必须持有下一个任务处理者的引用。

　　6）代理模式：

　　　　分类：a)静态代理：代理类由开发人员编写和维护，在编译期就已经确定了。

　　　　　　　b)动态代理：代理类不需要额外编写，它由JVM（虚拟机）在运行时动态创建字节码（二进制的字节数组）和执行。

　　　　关注的对象：抽象类或接口。

　　7）观察者模式

　　8）适配器模式

　　9）命令模式

　　10）组合模式

 

设计的过程：

　　1)OOA：需求分析

　　2)OOD：详细设计

　　3)OOP：面向对象的开发