JAVA设计模式理解与总结(下)代理模式&适配器模式&观察者模式

码了好几年代码的打字机器我,对于设计模式这个词,肯定是一点也不陌生,但是对于设计模式的理解,因为日常开发中,增删改查较多,使用设计模式思想来优化代码的机会就很少。也不乏在翻阅源码的时候,叹服于别人优秀高效的设计。所有今天抽出点时间,对设计模式做个归纳、记录,以便日后读到优秀的源码,可以自信的说,这**不就是那啥吗,我也会写~

设计模式

设计模式(Design Pattern)是前辈们对代码开发经验的总结,是解决特定问题的一系列套路。它不是语法规定,而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案

代理模式

一个类代表另一个类的功能,在代理模式中,我们创建具有现有对象的对象,以便向外界提供功能接口。

代理模式在我们的生活中也很常见,例如程序员的女友想买一个法国产的某包包,她不需要亲自去法国某个卖驴的专卖店去买,而是可以在代购手中购买,并获得一些小礼物,折扣优惠等等。

静态代理

在代码中,代理就是在使用者和服务提供者中间的服务,提供一些在提供的服务前后处理一些事物的功能。

卖东西人的认证(共同实现的接口)

1
2
3
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("买锤子,送锤子啦!!!");
}

雷军 | 买锤子,送锤子啦!!!

董明珠 | 买锤子,送锤子啦!!!

任正非 | 买锤子,送锤子啦!!!

实际生产过程中,观察者模式往往用消息中间件来实现

收工





更多好玩好看的内容,欢迎到我的博客交流,共同进步        WaterMin