共计 5053 个字符，预计需要花费 13 分钟才能阅读完成。
码了好几年代码的打字机器我，对于设计模式这个词，肯定是一点也不陌生，但是对于设计模式的理解，因为日常开发中，增删改查较多，使用设计模式思想来优化代码的机会就很少。也不乏在翻阅源码的时候，叹服于别人优秀高效的设计。所有今天抽出点时间，对设计模式做个归纳、记录，以便日后读到优秀的源码，可以自信的说，这 ** 不就是那啥吗，我也会写~~~
设计模式
设计模式（Design Pattern）是前辈们对代码开发经验的总结，是解决特定问题的一系列套路。它不是语法规定，而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案
代理模式
一个类代表另一个类的功能，在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。
代理模式在我们的生活中也很常见，例如程序员的女友想买一个法国产的某包包，她不需要亲自去法国某个卖驴的专卖店去买，而是可以在代购手中购买，并获得一些小礼物，折扣优惠等等。
静态代理
在代码中，代理就是在使用者和服务提供者中间的服务，提供一些在提供的服务前后处理一些事物的功能。
卖东西人的认证（共同实现的接口）
public interface Seller {void sell();
}法国某经销商：
public class LvFactory implements Seller{
@Override
public void sell() {System.out.println("LV 厂家卖包包");
}
}你女朋友朋友圈某个不知名好友:
class Purchase implements Seller{
private Seller seller;
public Purchase(Seller factory) {this.seller = factory;}
@Override
public void sell() {System.out.println("坐飞机去法国");
seller.sell();
System.out.println("坐飞机回国");
}
}你女朋友：
public static void main(String[] args) {Seller lv = new LvFactory();
new Purchase(lv).sell();}你：
信用卡 boom~~~~~~~~~~~~~~~~~坐飞机去法国
LV 厂家卖包包
坐飞机回国
动态代理
动态代理有别于静态代理，是根据代理的对象，动态创建代理类。这样，就可以避免静态代理中代理类接口过多的问题。动态代理是实现方式，是通过反射来实现的，借助 Java 自带的 java.lang.reflect.Proxy, 通过固定的规则生成。
举个?，女朋友朋友圈这个代购，代购包，也代购手表，那我找他一起买一块手表呢？
手表接口和天梭类：
public interface Watch {void sellWatch();
}
public class TissotWatch implements Watch {
@Override
public void sellWatch() {System.out.println("卖天梭手表");
}
}使用 InvocationHandler 定义代理类：
public class PurchaseProxy implements InvocationHandler {
private Object object;
public PurchaseProxy(Object object) {this.object = object;}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("坐飞机出国");
Object result = method.invoke(object, args);
System.out.println("坐飞机回国");
return result;
}
}在朋友圈买包买表：
public static void main(String[] args) {
// 卖包
Seller lvseller = new LvFactory();
PurchaseProxy lvproxy = new PurchaseProxy(lvseller);
((Seller) Proxy.newProxyInstance(lvseller.getClass().getClassLoader(), new Class[] {Seller.class}, lvproxy)).sell();
// 卖表
Watch tissot = new TissotWatch();
PurchaseProxy tissotproxy = new PurchaseProxy(tissot);
((Watch) Proxy.newProxyInstance(tissot.getClass().getClassLoader(), new Class[] {Watch.class}, tissotproxy)).sellWatch();}坐飞机出国
LV 厂家卖包包
坐飞机回国
坐飞机出国
卖天梭手表
坐飞机回国
动态代理详解
InvocationHandler
InvocationHandler 是一个接口，当代理方法被调用时，会调用起相对应的实现类的 invoke 方法。
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {return null;}三个参数：
- proxy 代理对象
- method 代理对象调用的方法
- args 调用的方法中的参数
Proxy
Java 自带的 java.lang.reflect.Proxy
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException- loader 类加载器
- interfaces 代码要用来代理的接口
- h 一个 InvocationHandler 对象
适配器模式
我们日常使用的适配器是一个接口转换器，它可以是一个独立的硬件接口设备，允许硬件或电子接口与其它硬件或电子接口相连，也可以是信息接口
在代码中，我想实现一个接口中的部分功能，或者想用一个类来冒充另一个类来实现它的功能，就需要适配器模式了。
适配器模式使接口不兼容的那些类可以一起工作，其别名为包装器
类适配器模式
在类适配器模式中，适配器与适配者之间是继承，适配着实现通用接口
举个?，我国标准电压是 220v，手机充电器也是 220v，日本标准电压是 110v，女朋友去日本玩，想给 220v 的手机用 110v 电压充电，就需要一个适配器了。
日本插座：
public class JapanAC {
private final static int v = 110;
public void jcharge() {System.out.printf("使用 %dv 电压充电 \n", v);
}
}充电通用接口：
public interface Charger {void charge();
}买一个 110v 升 220 变压器：
public class Adaptee extends JapanAC implements Charger {
@Override
public void charge() {System.out.println("使用适配器 110v 转 220v");
super.jcharge();
System.out.println("充电完成");
}
}女朋友使用适配器充电：
public static void main(String[] args) {Charger charger = new Adaptee();
charger.charge();}使用适配器 110v 转 220v
使用 110v 电压充电
充电完成
对象适配器模式
把一只猴子伪装成人:
有那么一种猴子：
public interface Monkey {
// 吃香蕉
void eatBanana();
// 骑独轮车
void rideABike();}
public class Shuang implements Monkey {
@Override
public void eatBanana() {System.out.println("猴子吃香蕉");
}
@Override
public void rideABike() {System.out.println("猴子独轮车"); // 猴子不懂人性，只会骑独轮车
}
}有那么个人：
public interface Human {
// 吃香蕉
void eatBanana();
// 开车
void drive();}
public class Da implements Human{
@Override
public void eatBanana() {System.out.println("人吃香蕉");
}
@Override
public void drive() {System.out.println("人开车");
}
}猴子伪装成人的大型真猴修表演：
public class MonkeyMan implements Human{
private Monkey monkey;
public MonkeyMan(Monkey monkey) {this.monkey = monkey;}
@Override
public void eatBanana() {monkey.eatBanana();
}
@Override
public void drive() {monkey.rideABike();
}
}猴子伪装成人：
public static void main(String[] args) {Monkey shuang = new Shuang();
Human human = new MonkeyMan(shuang); // 猴子成人
human.drive();}猴子独轮车
观察者模式
当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。
又被称为发布 - 订阅（Publish/Subscribe）模式
例如微博关注，多个用户关注同一博主，博主更新，会通知到所有用户。
罗老师微博：
public interface Bloger {void add(Fan fan);
void del(Fan fan);
void notifySms(String sms);
}
public class Luo implements Bloger {
private List<Fan> fans;
{fans = new ArrayList<>();
}
@Override
public void add(Fan fan) {fans.add(fan);
}
@Override
public void del(Fan fan) {fans.remove(fan);
}
@Override
public void notifySms(String sms) {fans.forEach(fan -> fan.notifySms(sms));
}
}粉丝：
public interface Fan {void notifySms(String sms);
}
public class Xigua implements Fan {
private String name;
public Xigua(String name) {this.name = name;}
@Override
public void notifySms(String sms) {System.out.println(name + "|" + sms);
}
}罗老师直播买手机：
public static void main(String[] args) {Fan leijun = new Xigua("雷军");
Fan dongmingzhu = new Xigua("董明珠");
Fan renzhengfei = new Xigua("任正非");
Bloger luo = new Luo();
luo.add(leijun);
luo.add(dongmingzhu);
luo.add(renzhengfei);
luo.notifySms("买锤子，送锤子啦！！！");
}雷军 | 买锤子，送锤子啦！！！
董明珠 | 买锤子，送锤子啦！！！
任正非 | 买锤子，送锤子啦！！！
实际生产过程中，观察者模式往往用消息中间件来实现
收工
更多好玩好看的内容，欢迎到我的博客交流，共同进步 WaterMin