常用设计模式

摘要：工厂设计模式工厂设计模式，主要用于进行实例化对象时的解耦操作，避免使用关键字实例化对象，通过反射，根据类名称动态创建对象示例静态工厂模式构造方法私有化获取指定类名称的对象动态代理模式动态代理模式，主要用于对同一接口子类的相同逻辑进行代理操作

工厂设计模式，主要用于进行实例化对象时的解耦操作，避免使用new关键字实例化对象，通过反射，根据类名称动态创建对象

示例：

package design;
/**
   *静态工厂模式
   */
public class Factory {
/**
   *构造方法私有化
   */
private Factory (){

 }
/**
   * 获取指定类名称的对象
   * @param className    * @param 
   * @return T
   */
public static  T getInstance(String className){
        T object =null;
        try {
            object = (T) Class.forName(className).newInstance();
        }catch (Exception e){
            e.printStackTrace();
        }
        return object;
    }
}

动态代理模式，主要用于对同一接口子类的相同逻辑进行代理操作

示例：

package design;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
   * 动态代理模式
   */
public class DynamicProxy implements InvocationHandler {
    private Object target;
    /**
     * 代理的目标对象
     * @param target
     * @return
     */
    public Object proxy(Object target){
        this.target=target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }
    /**
     * 目标方法执行前执行
     * @param object
     */
    public void before(Object object){
        System.out.println("目标方法执行前执行");
    }
    /**
     * 目标方法执行后执行
     * @param object
     */
    public void after(Object object){
        System.out.println("目标方法执行后执行");
    }
    /**
     * Processes a method invocation on a proxy instance and returns
     * the result.  This method will be invoked on an invocation handler
     * when a method is invoked on a proxy instance that it is
     * associated with.
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        this.before(proxy);
        Object result =method.invoke(proxy,args);
        this.after(result);
        return result;
    }
}

单例模式一：采用static final 修饰在类内部实例化的对象，保证对象的唯一性，此种方式，实在类加载的过程中实例化对象，无论是否使用，都会实例化。

示例

package design;
/**
   * 单例模式一
   */
public class SingletonOne {
    /**
     * 实例化对象唯一
     */
    private static final SingletonOne INSTANCE =new SingletonOne();
    /**
     * 构造方法私有化
     */
    private SingletonOne(){

    }
    /**
     * 获取单例对象
     * @return
     */
    public static SingletonOne getInstance(){
        return INSTANCE;
    }
}

单例模式二：采用volatile关键字修饰实例化对象，并通过同步锁（锁Class）的形式，保证实例化对象的唯一性，此方式在第一次使用时进行实例化

volatile关键字修饰的变量与普通变量的读取方式不同

 volatile定义的变量,将直接使用原始数据进行处理,更改后立即生效

示例

package design;
/**
   * 单例模式二
   */
public class SingletonTwo {
    /**
     * 使用volatile关键字修饰单例对象
     * volatile定义的变量,将直接使用原始数据进行处理,更改后立即生效
     */
    public static volatile SingletonTwo instance;
    /**
     * 构造方法私有化
     */
    private SingletonTwo(){

    }
    /**
     * 获取单例对象
     * @return
     */
    public static SingletonTwo getInstance(){
        if(instance ==null){
            //通过同步锁住当前类,来保证线程安全,并提高性能,若直接同步该方法,会大大降低性能
            synchronized (SingletonTwo.class){
                if (instance ==null){
                    instance =new SingletonTwo();
                }
            }
        }
        return instance;
    }
}

单例模式三：基于Jvm类加载机制实现单例

示例

/**
 * 单例模式三
 */
public class ClassSingletonDemo {

    /**
     * 构造方法私有化
     */
    private ClassSingletonDemo(){};

    /**
     * 静态方法获取实例
     */
    public static ClassSingletonDemo getInstance(){
        return SingletonHandler.singleton;
    }

    /**
     * 内部静态类保证只初始化一次
     */
    private static class SingletonHandler {
        private static ClassSingletonDemo singleton = new ClassSingletonDemo();
        static {
            System.out.println("This"s innerClass"s static code block");
        }
    }
}

单例模式四：基于Enum类型的加载机制实现单例

示例

/**
 * 单例模式四
 */
public class EnumSingletonDemo {

    /**
     * 构造方法私有化
     */
    private EnumSingletonDemo(){}

    /**
     * 静态方法获取实例
     */
    public static EnumSingletonDemo getInstance(){
        return Singleton.INSTANCE.getInstance();
    }

    /**
     * 私有枚举,只被JVM加载一次,只实例化一次
     */
    private enum Singleton{

        INSTANCE;

        private EnumSingletonDemo singleton;

        Singleton(){
            singleton = new EnumSingletonDemo();
        }

        public EnumSingletonDemo getInstance(){
            return singleton;
        }
    }

}

(转载自喻红叶《Java与模式-中介者模式》）

中介者模式的定义：用一个中介对象来封装一些列的对象交互，中介者使得各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式解决问题的思路很简单，就是通过引入一个中介对象，让其他对象只与中介对象交互，而中介对象知道如何和其他所有对象的交互，这样对象之间的交互关系就没有了，从而实现了对象之间的解耦。由此，我们也可以看出一个问题，那就是中介对象控制着整个系统的逻辑，它会过于复杂，这是一个缺点。中介者模式的本质是封装交互：

（1）对象在自身状态发生改变时报告给中介对象；

（2）中介对象控制着整个系统的逻辑，它知道如何与所有对象交互；

（3）对象需要对中介对象发出的请求作出回应。

中介者模式中的角色：

Mediator：中介者接口，定义各个同事之间交互所需要的方法；

ConcreteMediator：具体的中介者，它需要了解并维护各个同事对象，并负责具体的协调各同事对象的交互关系；

Colleague：所有同事对象的父类，一般实现成抽象类，主要负责约束同事对象的类型，并负责实现一些公共功能；

ConcreteMediator：具体的同事类，实现自己的业务，当需要与其他同事对象通信时，就与持有的中介者通信，中介者会负责与其他同事的交互。在标准的中介者模式中，将使用中介者来交互的那些对象叫做同事类，它们继承自相同的父类，所以叫做同事。正是由于它们之间的交互很复杂，所以才产生了把这些交互关系分离出去，让中介者来处理。

示例：

以电脑来看电影为例子，首先光驱从光盘中读取数据，然后通知CPU将数据分离成音频和视频，CPU处理完毕后再分别将数据传送给声卡和显卡进行播放。从上面的描述的中发现，光驱盒CPU是耦合的，CPU又和声卡显卡是耦合的，怎么解耦的呢？如果使用中介者模式，通过引入主板作为中介者，所有的对象都与主板交互，那么播放电影的流程就变成了这样：

（1）光驱从光盘读取到数据，通知主板，数据准备好了；

（2）主板收到光驱的请求后，将原始数据传给CPU，让它将数据分离成音频和视频；

（3）CPU将数据分离后，通知主板，数据分离完毕；

（4）主板收到CPU通知后，分别将音频和视频传给声卡和显卡；

（5）声卡和显卡同时播放。

这样一个过程中，所有的类只与主板耦合，而不与其他类保持关系，做到了解耦，而且过程很清晰。实际上计算机硬件就是这样通信的，只不过更复杂一些，所以这些东西都是相通的，重要的是思想。

Java实现：

同事对象的父类

package design;
/**
 * 同事对象的父类，一般实现成抽象类，用于约束同事对象的类型
 * 同时实现一些功能公共方法，例如持有中介者对象
 */
public abstract class Colleague {
    //所有的同事对象都需要持有中介对象
    private Mediator mediator;

    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }

    public Mediator getMediator() {
        return mediator;
    }
}

中介者接口

package design;
/**
 * 中介者接口
 */
public interface  Mediator {
    /**
     * 同事对象自身状态改变时，通过这个方法通知中介者对象
     * @param obj
     */
    public void changed(Colleague obj);

    /**
     * 中介者对象需要知道所有同事对象
     * @param instance
     */
    public void setCDDriver(CDDriver instance);
    public void setCPU(CPU instance);
    public void setVideoCard(Video instance);
    public void setSoundCard(Sound instance);
}

光驱类

package design;
/**
 * 光驱类，负责从光盘中读取数据
 */
class CDDriver extends Colleague {
    //从光盘读取的原始数据
    private String originData;

    public CDDriver(Mediator mediator) {
        super(mediator);
    }
    public String getOriginData() {
        return originData;
    }

    /**
     * 读取光盘数据，一旦读取到数据，就要通知中介者对象数据已经准备好了
     */
    public void readCD(String originData) {
        this.originData = originData;
        //通知中介对象，自己的状态发生了改变
        getMediator().changed(this);
    }
}

CPU类

package design;
/**
 * CPU类，负责将原始数据分离成音频和视频
 */
public class CPU extends Colleague {

    //声音数据
    private String soundData;
    //视频数据
    private String videoData;

    public CPU(Mediator mediator) {
        super(mediator);
    }
    public String getSoundData() {
        return soundData;
    }
    public String getVideoData() {
        return videoData;
    }

    /**
     * 将数据分离，同时通知中介者对象，数据已经分离
     * @param originData
     */
    public void sperateData(String originData) {
        this.soundData = originData.split(",")[1];
        this.videoData = originData.split(",")[0];

        //通知中介对象，自己的状态发生了改变
        getMediator().changed(this);
    }
}

显卡类，播放视频

package design;
/**
 * 显卡类，播放视频
 */
public class Video extends Colleague {

    public Video(Mediator mediator) {
        super(mediator);
    }
    public void showVideo(String videoData) {
        System.out.println("正在观看：" + videoData);
    }
}

声卡类

package design;

/**
 * 声卡类，播放声音
 */
public class Sound extends Colleague {

    public Sound(Mediator mediator) {
        super(mediator);
    }
    public void showSound(String soundData) {
        System.out.println("解说：" + soundData);
    }
}

主板类

package design;
/**
 * 主板类,实现中介者
 */
public class MainBoard implements Mediator {
    private CDDriver cd;
    private CPU cpu;
    private Video vc;
    private Sound sc;

    public void setCDDriver(CDDriver instance) {
        this.cd = instance;
    }
    public void setCPU(CPU instance) {
        this.cpu = instance;
    }
    public void setVideoCard(Video instance) {
        this.vc = instance;
    }
    public void setSoundCard(Sound instance) {
        this.sc = instance;
    }

    /**
     * 当同时对象自身状态发生改变时，调用此方法通知中介者对象
     * 中介者对象在进行逻辑控制，与其他同对象交互
     */
    public void changed(Colleague obj) {
        //如果是光驱类，需要通知CPU去分离数据
        if(obj instanceof CDDriver) {
            String originData = ((CDDriver) obj).getOriginData();
            this.cpu.sperateData(originData);
        }else if(obj instanceof CPU){//如果是CPU类，需要通知声卡和显卡去播放
            String videoData = ((CPU) obj).getVideoData();
            String soundData = ((CPU) obj).getSoundData();
            this.vc.showVideo(videoData);
            this.sc.showSound(soundData);
        }
    }
}

客户端

package design;
/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        Mediator mediator = new MainBoard();
        CDDriver cd = new CDDriver(mediator);
        CPU cpu = new CPU(mediator);
        Video vc = new Video(mediator);
        Sound sc = new Sound(mediator);
        mediator.setCDDriver(cd);
        mediator.setCPU(cpu);
        mediator.setSoundCard(sc);
        mediator.setVideoCard(vc);
        //光驱读数据，通知中介者，中介者通知CPU去分离数据，CPU分离数据完成，通知中介者，中介者通知声卡和显卡播放
        cd.readCD("终结者，终结者音频");
    }
}