关于后端:Java程序员不得不知道的一些设计模式

设计模式（Design pattern）是一套被重复应用、少数人通晓的、通过分类编目标、代码设计教训的总结。应用设计模式是为了可重用代码、让代码更容易被别人了解、保障代码可靠性。毫无疑问，设计模式于己于别人于零碎都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。
一些简略的设计模式略过，如常量接口模式、标识类型模式。
以下，将从最简略的设计模式开始讲起：

单例模式是指一个类只能领有惟一的实例。为了保障这一点，咱们必须要限度类的创立。即某个单例类，只能够实例化一次。那怎么才能够做到呢？

 实现思路如下：

给须要单例的类申明公有的构造方法。这样就限度了其余类对此类的随便创立。
在单例类外部，申明本人的动态成员变量，且实例化本人。由在以后类中，是能够拜访本人的所有公有成员及办法的，所以，即便构造方法为公有也能够胜利创建对象。
个别状况下，再提供一个静态方法以返回创立的喻一对象。个别状况下，咱们将此办法取名为 newInstace,getInstance 等，不过这并不是硬性的规定。
示例代码如下：

public class SingletonDemo {
    // 私有化构造方法
    private SingletonDemo(){}
    // 申明动态公有成员变量
    private static SingletonDemo demo;
    // 提供动态工厂办法
    public static SingletonDemo getInstance(){if(demo==null){demo = new SingletonDemo();
        }
        return demo;
    }
}

既然有单例，就会有多例。多例是指限定一个类的只能创立 N（具体数量）个的设计模式。如以下性别类，就只能创立两个实例。实现思路是在本类中申明多个类的实例，并提供静态方法返回不同的实例即可：

第一种实现：

public class Gender {
    private String sex;
    private Gender(String sex){this.sex = sex;}
    // 男性
    private static Gender MALE;
    // 女性
    private static Gender FEMALE;
    public static Gender getMale(){if(MALE==null){MALE = new Gender("男");
        }
        return MALE;
    }
    public static Gender getFemale(){if(FEMALE==null){FEMALE = new Gender("女");
        }
        return FEMALE;
    }
}

第二种实现：

public class Gender {
    private String sex;
    private Gender(String sex){this.sex = sex;}
    // 男性
    private static Gender MALE;
    // 女性
    private static Gender FEMALE;
    static{// 动态代码块中初始化
        MALE = new Gender("男");
        FEMALE = new Gender("女");
    }
    public static Gender getMale(){return MALE;}
    public static Gender getFemale(){return FEMALE;}
}

第三种实现：间接应用枚举

public enum Gender{MALE("男"),FEMALE("女");
    private String sex;
    private Gender(String sex){this.sex=sex;}
    @Override
    public String toString() {return sex;}
}

工厂办法指在一个类外部，提供一个静态方法，返回本人的实例或是其余类的实例。具体是返回本人的实例，还是返回其余类的实例，这个要看具体业务的需要。咱们的数据连接池返回的就是其余对象的实例：

public class FactoryDemo{
    private static Connection con;
    static{
    // 在此连贯数据库
    con = DriverManager.getConnection(…);
}
// 提供一个动态工厂办法
public static Connection getConn(){return con;}
}

一个接口，往往定义很多办法，但实现此接口的类，可能只须要几个办法。那么那些多余的办法，占据了咱们大量的代码，将失去意义。那怎么才能够即省去一些无用的办法，又实现此接口呢？这就是适配置器模式。
Awt 开发中的 Listener 大量应用了此模式。如 WindowListener 和 WindowAdapter。
请见下面两个类（WindowListener 和 WindowAdapter）的源代码。

如果一个类，即是某个类的子类，又领有某个类的一个成员变量，则被叫做包装模式。
如：

public Interface IA{}  // 定义一个接口
public class B implements IA{  // 首先 B 是 IA 的子类
    private IA ia;              // 而后 B 领有一个 IA 的成员变量。}

应用装璜器或是包装模式个别是为了加强类的性能。如加强某个办法等。

代理模式的定义：对其余对象提供一种代理以管制对这个对象的拜访。在某些状况下，一个对象不想或者不能间接援用另一个对象，而代理对象能够在客户端和指标对象之间起到中介的作用。
假如有一个 Italk 接口，有空的办法 talk（）（谈话），所有的 people 对象都实现（implements）这个接口，实现 talk（）办法，前端有很多中央都将 people 实例化，执行 talk 办法，起初发现这些前端里有一些除了要谈话以外还要唱歌（sing），那么咱们既不能在 Italk 接口里减少 sing()办法，又不能在每个前端都减少 sing 办法，咱们只有减少一个代理类 talkProxy，这个代理类里实现 talk 和 sing 办法，而后在须要 sing 办法的客户端调用代理类即可，代码如下：

// 定义接口
interface ITalk {public void talk(String msg);
}
// 定义一个代理，接管 ITalk, 并减少一个办法 sing
class TalkProxy implements ITalk{
    private ITalk talker;
    private String music;
    public TalkProxy(ITalk talker,String music){
        this.talker=talker;
        this.music = music;
    }
    
    @Override
    public void talk(String msg) {talker.talk(msg);
        sing();}
    // 再多定义一个唱歌办法
    private void sing(){System.err.println("正在唱:"+music);
    }
}
// 接口的一个实现类
class Tom implements ITalk{public void talk(String msg) {System.err.println("正在谈话："+msg);
    }
}
// 测试调用
public class ProxyDemo{public static void main(String[] args) {TalkProxy proxy = new TalkProxy(new Tom(),"十里香");
        proxy.talk("Hello");
    }
}

在 JDK 中，Proxy 类和 InvocationHandler 能够在不增加任何代码的状况下加强某个办法：

package cn.arcstack.pattern;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;
// 测试代码
public class DyncProxyDemo {public static void main(String[] args) {List list =(List) MyProxy.getProxy(new ArrayList());
        list.add("Hello");
    }
}
// 书写代理类
class MyProxy implements InvocationHandler{
    // 申明被代理之前的对象
    private Object src;
    // 公有构造方法
    private MyProxy(Object src){this.src=src;}
    // 提供一个静态方法以返回被代理当前的对象
    public static Object getProxy(Object src){
        Object dest = null;// 被代理当前的对象
        try{
            // 解决代理的外围代码
            dest = Proxy.newProxyInstance(MyProxy.class.getClassLoader(),
                        src.getClass().getInterfaces(),
                        new MyProxy(src));
        }catch(Exception e){throw new RuntimeException(e.getMessage(),e);
        }
        return dest;
    }
    // 拦挡办法
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {System.err.println("耿直执行办法:"+method.getName());
        Object oo = method.invoke(src, args);
        return oo;
    }
    
}

观察者模式又叫做公布订阅模式。在此种模式中，一个指标物件治理所有相依于它的观察者物件，并且在它自身的状态扭转时被动发出通知。这通常透过呼叫各观察者所提供的办法来实现。此种模式通常被用来实作事件处理零碎。如 Awt 中的监听器 Listener 都是采纳了种模式。

在此种模式下，观察者只是一个接口，即定义一个标准，具体的实现应该是客户端实现。就像 Swing 中的注册一个监听器一样如：

JFrame frame = new Jframe();// 申明被察看，被监听者对象
frame.addWindowListener(new WindowListener(){…});// 增加一个实现 WindowListener 的观察者
frame.setVisible(true);    // 执行一些后续的操作，只有注册了观察者，就会被观察者所监听到

示例代码如下：

public class ObserverDemo {public static void main(String[] args) {
        // 杰克逊对象
        Singer jackson = new Singer();
        // 注册观察者
        jackson.addListener(new SingListener() {public void listener(Singer singer) {System.err.println("监听到了手的正在唱歌。。。。");
            }
        });
        // 唱歌
        jackson.sing();}
}
// 设置一个监听器接口 - 监听谁在唱歌
interface SingListener{public void listener(Singer singer);
}
// 一个可能的被监听者
class Singer{
    // 申明观察者
    private SingListener listener;
    public void addListener(SingListener sl){this.listener=sl;}
    public void sing(){
        // 判断是否有观察者
        if(this.listener!=null){this.listener.listener(this);
        }
        System.err.println("歌手正在唱歌");
    }
}

给观察者增加一个察看事件对象，SingEvent, 以便于解藕：
残缺的示例代码如下：

package cn.arcstack.pattern;
// 测试代码
public class ObserverDemo {public static void main(String[] args) {Singer jackson = new Singer();
        jackson.addListener(new SingListener() {public void listener(SingEvent event) {System.err.println("歌手是:"+event.getSource());
            }
        });
        jackson.sing();}
}
// 设置一个监听器接口 - 监听谁在唱歌
interface SingListener{public void listener(SingEvent event);
}
// 设计一个事件对象
class SingEvent{
    // 接管事件对象，即被观察者
    private Object source;
    public SingEvent(Object source){this.source=source;}
    public Object getSource() {return source;}
}
// 一个可能的被监听者
class Singer{
    // 申明观察者
    private SingListener listener;
    public void addListener(SingListener sl){this.listener=sl;}
    public void sing(){
        // 判断是否有观察者
        if(this.listener!=null){this.listener.listener(new SingEvent(this));
        }
        System.err.println("歌手正在唱歌"+this);
    }
}

策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还能够互相替换。策略模式让算法独立于应用它的客户而独立变动。
策略模式的组成
-形象策略角色：策略类，通常由一个接口或者抽象类实现。
-具体策略角色：包装了相干的算法和行为。
-环境角色：持有一个策略类的援用，最终给客户端调用。

package cn.arcstack.pattern;
/**
 * 策略模式
 */
public class StrategyDemo {public static void main(String[] args) {Context ctx = new Context(new JavaProgrammer());
        ctx.doSth();}
}
// 设计一个公共的接口
interface IStrategy{public void doSth();
}
// 别离书写多个实现类，有不同的实现策略
class JavaProgrammer implements IStrategy{public void doSth() {System.err.println("写 Java 代码");
    }
}
class PhpProgrammer implements IStrategy{public void doSth() {System.err.println("写 PHP 代码");
    }
}
// 实现策略类
class Context{
    private IStrategy strategy;
    public Context(IStrategy strategy){this.strategy = strategy;}
    // 具体调用
    public void doSth(){this.strategy.doSth();
    }

门面设计模式的构造：

没有门面设计模式的调用办法：

有了门面设计模式的类框架图如下：即由原来的客户端一一调用每一个零碎，批改成一应用一个对立中调用：

具体实现代码略。

在软件系统中，“行为请求者”与“行为实现者”通常出现一种“紧耦合”。但在某些场合，比方要对行为进行“记录、撤销 / 重做、事务”等解决，这种无奈抵挡变动的紧耦合是不适合的。在这种状况下，如何将“行为请求者”与“行为实现者”解耦？将一组行为形象为对象，实现二者之间的松耦合。这就是命令模式（Command Pattern）

示例代码如下：

package cn.arcstack.pattern;
public class CommandDemo {public static void main(String[] args) {
        // 命令的接收者只有一个
        Receiver receiver = new Receiver();
        // 定义命令的执行者
        Invoker invoker = new Invoker();
        // 通过 Command 类具体告诉命令的接收者做什么工作
        invoker.setCommand(new CommandA(receiver));
        invoker.execute();
        // 再设置第二个命令
        invoker.setCommand(new CommandB(receiver));
        invoker.execute();}
}
// 定义命令
abstract class Command{
    // 定义接管命令对象
    protected Receiver receiver;
    public Command(Receiver rec){this.receiver=rec;}
    public abstract void execute();}
// 指定接收者的工作
class Receiver{public void actionA(){System.err.println("做第一件事");
    }
    public void actionB(){System.err.println("做第二件事");
    }
}
// 执行者
class Invoker{
    // 接管一个命令
    private Command command;
    public void setCommand(Command cmd){this.command = cmd;}
    // 执行命令
    public void execute(){command.execute();
    }
}
// 定义两个具体的命令
class CommandA extends Command{public CommandA(Receiver rec) {super(rec);
    }
    @Override
    public void execute() {this.receiver.actionA();
    }
}
// 定义两个具体的命令
class CommandB extends Command{public CommandB(Receiver rec) {super(rec);
    }
    @Override
    public void execute() {this.receiver.actionB();
    }
}

用原型实例指定创建对象的品种，并且通过拷贝这些原型创立新的对象。
Prototype 原型模式是一种创立型设计模式，Prototype 模式容许一个对象再创立另外一个可定制的对象，基本无需晓得任何如何创立的细节, 工作原理是: 通过将一个原型对象传给那个要动员创立的对象，这个要动员创立的对象通过申请原型对象拷贝它们本人来施行创立。
它次要面对的问题是：“某些结构复杂的对象”的创立工作；因为需要的变动，这些对象常常面临着激烈的变动，然而他们却领有比较稳定统一的接口。
如何应用?
因为 Java 中的提供 clone()办法来实现对象的克隆，所以 Prototype 模式实现一下子变得很简略。
代码略。

能够了解成为轻量级模式, 是一种软件设计模式。
面向对象的思维很好地解决了抽象性的问题，个别也不会呈现性能上的问题。然而在某些状况下，对象的数量可能会太多，从而导致了运行时的代价。那么咱们如何去防止大量细粒度的对象，同时又不影响客户程序应用面向对象的形式进行操作？
见上面的代码：
// 应用 Integer 对象的示例

    Integer b1 = 100;
    Integer b2 = 100;
    System.err.println(b1==b2);   //true
    // 因为大量细粒度的对象呈现在 128 以下，所以，下现的值为 false
    Integer b3 = 128;
    Integer b4 = 128;
System.err.println(b3==b4); //false

在理论的开发中，单例、多例、工厂、适配置器、代理、装璜、包装是常常应用的发模式，其余模式只须要理解就能够了。

本文由 mdnice 多平台公布

关于后端:Java程序员不得不知道的一些设计模式

1、什么是设计模式

2、单例模式 Singleton

4、多例模式 Multition

5、工厂办法模式 Factory Method

6、适配置器模式 Adapter

7、装璜器设计模式 (Decorator) 也叫包装设计模式(Wrapper)

8、代理模式 Proxy

9、动静代理 Dync Proxy

10、观察者模式 Observer

11、策略模式 Strategy

12、门面设计模式

13、命令模式 Command

14、原型模式 Prototype

15、亨元模式 flyweight

16、总结

Just My Socks（注册教程内含优惠码）

关于后端:Java程序员不得不知道的一些设计模式

1、什么是设计模式

2、单例模式 Singleton

4、多例模式 Multition

5、工厂办法模式 Factory Method

6、适配置器模式 Adapter

7、装璜器设计模式 (Decorator) 也叫包装设计模式(Wrapper)

8、代理模式 Proxy

9、动静代理 Dync Proxy

10、观察者模式 Observer

11、策略模式 Strategy

12、门面设计模式

13、命令模式 Command

14、原型模式 Prototype

15、亨元模式 flyweight

16、总结

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）