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