经常使用设计模式

时间  2019-12-07
标签 经常 使用 设计 模式 繁體版
原文   原文链接

工厂设计模式

  • 工厂设计模式，主要用于进行实例化对象时的解耦操做，避免使用new关键字实例化对象，经过反射，根据类名称动态建立对象
  • 示例：
package design;
/**
   *静态工厂模式
   */
public class Factory {
/**
   *构造方法私有化
   */
private Factory (){

 }
/**
   * 获取指定类名称的对象
   * @param className    * @param <T>
   * @return T
   */
public static <T> 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关键字修饰的变量与普通变量的读取方式不一样
01.png
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与模式-中介者模式》）

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

    • （1）对象在自身状态发生改变时报告给中介对象；
    • （2）中介对象控制着整个系统的逻辑，它知道如何与全部对象交互；
    • （3）对象须要对中介对象发出的请求做出回应。

  • 中介者模式中的角色：设计模式

    • Mediator：中介者接口，定义各个同事之间交互所须要的方法；
    • ConcreteMediator：具体的中介者，它须要了解并维护各个同事对象，并负责具体的协调各同事对象的交互关系；
    • Colleague：全部同事对象的父类，通常实现成抽象类，主要负责约束同事对象的类型，并负责实现一些公共功能；
    • ConcreteMediator：具体的同事类，实现本身的业务，当须要与其余同事对象通讯时，就与持有的中介者通讯，中介者会负责与其余同事的交互。在标准的中介者模式中，将使用中介者来交互的那些对象叫作同事类，它们继承自相同的父类，因此叫作同事。正是因为它们之间的交互很复杂，因此才产生了把这些交互关系分离出去，让中介者来处理。

  • 示例：安全

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

      • （1）光驱从光盘读取到数据，通知主板，数据准备好了；
      • （2）主板收到光驱的请求后，将原始数据传给CPU，让它将数据分离成音频和视频；
      • （3）CPU将数据分离后，通知主板，数据分离完毕；
      • （4）主板收到CPU通知后，分别将音频和视频传给声卡和显卡；
      • （5）声卡和显卡同时播放。

这样一个过程当中，全部的类只与主板耦合，而不与其余类保持关系，作到了解耦，并且过程很清晰。实际上计算机硬件就是这样通讯的，只不过更复杂一些，因此这些东西都是相通的，重要的是思想。性能

  • Java实现：this

    • 同事对象的父类
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("终结者，终结者音频");
    }
}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程