三、结构型模式
一共七种
3.1 适配器模式
（1）概念
适配器模式（Adapter Pattern）是指将一个类的接口转换成客户期望的另一个接口，使
原本的接口不兼容的类可以一起工作，属于结构型设计模式。
（2）适用场景
- 1、已经存在的类，它的方法和需求不匹配（方法结果相同或相似）的情况。
- 2、适配器模式不是软件设计阶段考虑的设计模式，是随着软件维护，由于不同产品、不同厂家造成功能类似而接口不相同情况下的解决方案。有点亡羊补牢的感觉。生活中也非常的应用场景，例如电源插转换头、手机充电转换头、显示器转接头。
在中国民用电都是 220V 交流电，但我们手机使用的锂电池使用的 5V 直流电。因此，我
们给手机充电时就需要使用电源适配器来进行转换。
（3）代码示例
创建 AC220 类，表示 220V 交流电：
- AC220
package com.alibaba.design.adapterpattern.powerapapter; /** * @author zhouyanxiang * @create 2020-07-2020/7/29-21:06 */ public class AC220 { public int outputAC220V(){ int output = 220; System.out.println("输出电流" + output + "V"); return output; } }
创建 DC5 接口，表示 5V 直流电的标准：
- DC5
package com.alibaba.design.adapterpattern.powerapapter; /** * @author zhouyanxiang * @create 2020-07-2020/7/29-21:07 */ public interface DC5 { public int outoupDC5V(); }
创建电源适配器 PowerAdapter 类：
- PowerAdapter
package com.alibaba.design.adapterpattern.powerapapter; /** * @author zhouyanxiang * @create 2020-07-2020/7/29-21:07 */ public class PowerAdapter implements DC5 { private AC220 ac220; public PowerAdapter(AC220 ac220) { this.ac220 = ac220; } @Override public int outoupDC5V() { int adapterInput = ac220.outputAC220V(); int adapterOutput = adapterInput / 44; System.out.println("使用PowerAdapter输入AC:" + adapterInput + "V,输出DC：" + adapterOutput + "V"); return adapterOutput; } }
客户端测试类PowerAdapterTest
- PowerAdapterTest
package com.alibaba.design.adapterpattern.test; import com.alibaba.design.adapterpattern.powerapapter.AC220; import com.alibaba.design.adapterpattern.powerapapter.DC5; import com.alibaba.design.adapterpattern.powerapapter.PowerAdapter; /** * @author zhouyanxiang * @create 2020-07-2020/7/29-21:10 */ public class PowerAdapterTest { public static void main(String[] args) { DC5 dc5 = new PowerAdapter(new AC220()); dc5.outoupDC5V(); } }
上面的案例中，通过增加 PowerAdapter 电源适配器，实现了二者的兼容。
（4）重构第三登录自由适配的业务场景
下面我们来一个实际的业务场景，利用适配模式来解决实际问题。我们很早以前开发的老系统应该都有登录接口，但是随着业务的发展和社会的进步，单纯地依赖用户名密码登录显然不能满足用户需求了。现在，我们大部分系统都已经支持多种登录方式，如 QQ 登录、微信登录、手机登录、微博登录等等，同时保留用户名密码的登录方式。虽然登录形式丰富了，但是登录后的处理逻辑可以不必改，同样是将登录状态保存到 session，遵循开闭原则。首先创建统一的返回结果 ResultMsg 类：
package com.alibaba.design.adapterpattern.loginadapter; /** * Created by Tom. */ public class ResultMsg { private int code; private String msg; private Object data; public ResultMsg(int code, String msg, Object data) { this.code = code; this.msg = msg; this.data = data; } public int getCode() { return code; } public void setCode(int code) { this.code = code; } public String getMsg() { return msg; } public void setMsg(String msg) { this.msg = msg; } public Object getData() { return data; } public void setData(Object data) { this.data = data; } }
假设老系统的登录逻辑 SiginService：
package com.alibaba.design.adapterpattern.loginadapter.v1.service; import com.alibaba.design.adapterpattern.loginadapter.Member; import com.alibaba.design.adapterpattern.loginadapter.ResultMsg; /** * Created by Tom. */ public class SiginService { /** * 注册方法 * @param username * @param password * @return */ public ResultMsg regist(String username, String password){ return new ResultMsg(200,"注册成功",new Member()); } /** * 登录的方法 * @param username * @param password * @return */ public ResultMsg login(String username,String password){ return null; } }
为了遵循开闭原则，老系统的代码我们不会去修改。那么下面开启代码重构之路，先创建 Member 类：
package com.alibaba.design.adapterpattern.loginadapter; /** * Created by Tom. */ public class Member { private String username; private String password; private String mid; private String info; public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public String getMid() { return mid; } public void setMid(String mid) { this.mid = mid; } public String getInfo() { return info; } public void setInfo(String info) { this.info = info; } }
创建一个新的类SinginForThirdService继承原来的逻辑，运行非常稳定的代码我们不去改动：
package com.alibaba.design.adapterpattern.loginadapter.v1.service; import com.alibaba.design.adapterpattern.loginadapter.ResultMsg; /** * Created by Tom on 2019/3/16. */ public class SinginForThirdService extends SiginService { public ResultMsg loginForQQ(String openId){ //1、openId是全局唯一，我们可以把它当做是一个用户名(加长) //2、密码默认为QQ_EMPTY //3、注册（在原有系统里面创建一个用户） //4、调用原来的登录方法 return loginForRegist(openId,null); } public ResultMsg loginForWechat(String openId){ return null; } public ResultMsg loginForToken(String token){ //通过token拿到用户信息，然后再重新登陆了一次 return null; } public ResultMsg loginForTelphone(String telphone,String code){ return null; } public ResultMsg loginForRegist(String username,String password){ super.regist(username,null); return super.login(username,null); } }
客户端测试代码
package com.alibaba.design.adapterpattern.loginadapter.v1; import com.alibaba.design.adapterpattern.loginadapter.v1.service.SinginForThirdService; /** * Created by Tom on 2019/3/16. */ public class SiginForThirdServiceTest { public static void main(String[] args) { SinginForThirdService service = new SinginForThirdService(); service.login("tom","123456"); service.loginForQQ("sdfasdfasf"); service.loginForWechat("sdfasfsa"); } }
通过这么一个简单的适配，完成了代码兼容。当然，我们代码还可以更加优雅，根据不
同的登录方式，创建不同的 Adapter。首先，创建 LoginAdapter 接口：
package com.alibaba.design.adapterpattern.loginadapter.v2.adapters; import com.alibaba.design.adapterpattern.loginadapter.ResultMsg; /** * 在适配器里面，这个接口是可有可无，不要跟模板模式混淆 * 模板模式一定是抽象类，而这里仅仅只是一个接口 * Created by Tom */ public interface LoginAdapter { boolean support(Object adapter); ResultMsg login(String id, Object adapter); }
分别实现不同的登录适配，QQ 登录 LoginForQQAdapter：
package com.alibaba.design.adapterpattern.loginadapter.v2.adapters; import com.alibaba.design.adapterpattern.loginadapter.ResultMsg; /** * Created by Tom on 2019/3/16. */ public class LoginForQQAdapter implements LoginAdapter { @Override public boolean support(Object adapter) { return adapter instanceof LoginForQQAdapter; } @Override public ResultMsg login(String id, Object adapter) { return null; } }
新浪微博登录 LoginForSinaAdapter：
package com.alibaba.design.adapterpattern.loginadapter.v2.adapters; import com.alibaba.design.adapterpattern.loginadapter.ResultMsg; /** * Created by Tom. */ public class LoginForSinaAdapter implements LoginAdapter { @Override public boolean support(Object adapter) { return adapter instanceof LoginForSinaAdapter; } @Override public ResultMsg login(String id, Object adapter) { return null; } }
手机号登录 LoginForTelAdapter：
package com.alibaba.design.adapterpattern.loginadapter.v2.adapters; import com.alibaba.design.adapterpattern.loginadapter.ResultMsg; /** * Created by Tom. */ public class LoginForTelAdapter implements LoginAdapter { @Override public boolean support(Object adapter) { return adapter instanceof LoginForTelAdapter; } @Override public ResultMsg login(String id, Object adapter) { return null; } }
Token 自动登录 LoginForTokenAdapter:
package com.alibaba.design.adapterpattern.loginadapter.v2.adapters; import com.alibaba.design.adapterpattern.loginadapter.ResultMsg; /** * Created by Tom. */ public class LoginForTokenAdapter implements LoginAdapter { @Override public boolean support(Object adapter) { return adapter instanceof LoginForTokenAdapter; } @Override public ResultMsg login(String id, Object adapter) { return null; } }
微信登录 LoginForWechatAdapter：
package com.alibaba.design.adapterpattern.loginadapter.v2.adapters; import com.alibaba.design.adapterpattern.loginadapter.ResultMsg; /** * Created by Tom. */ public class LoginForWechatAdapter implements LoginAdapter { @Override public boolean support(Object adapter) { return adapter instanceof LoginForWechatAdapter; } @Override public ResultMsg login(String id, Object adapter) { return null; } }
然后，创建第三方登录兼容接口 IPassportForThird:
package com.alibaba.design.adapterpattern.loginadapter.v2; import com.alibaba.design.adapterpattern.loginadapter.ResultMsg; /** * 只扩展 * Created by Tom on 2019/3/16. */ public interface IPassportForThird { /** * QQ登录 * @param id * @return */ ResultMsg loginForQQ(String id); /** * 微信登录 * @param id * @return */ ResultMsg loginForWechat(String id); /** * 记住登录状态后自动登录 * @param token * @return */ ResultMsg loginForToken(String token); /** * 手机号登录 * @param telphone * @param code * @return */ ResultMsg loginForTelphone(String telphone, String code); /** * 注册后自动登录 * @param username * @param passport * @return */ ResultMsg loginForRegist(String username, String passport); }
实现兼容 PassportForThirdAdapter：
package com.alibaba.design.adapterpattern.loginadapter.v2; import com.alibaba.design.adapterpattern.loginadapter.ResultMsg; import com.alibaba.design.adapterpattern.loginadapter.v1.service.SiginService; import com.alibaba.design.adapterpattern.loginadapter.v2.adapters.*; /** * 结合策略模式、工厂模式、适配器模式 * Created by Tom on 2019/3/16. */ public class PassportForThirdAdapter extends SiginService implements IPassportForThird { @Override public ResultMsg loginForQQ(String id) { // return processLogin(id,RegistForQQAdapter.class); return processLogin(id, LoginForQQAdapter.class); } @Override public ResultMsg loginForWechat(String id) { return processLogin(id, LoginForWechatAdapter.class); } @Override public ResultMsg loginForToken(String token) { return processLogin(token, LoginForTokenAdapter.class); } @Override public ResultMsg loginForTelphone(String telphone, String code) { return processLogin(telphone, LoginForTelAdapter.class); } @Override public ResultMsg loginForRegist(String username, String passport) { super.regist(username,passport); return super.login(username,passport); } private ResultMsg processLogin(String key,Class<? extends LoginAdapter> clazz){ try{ //适配器不一定要实现接口 LoginAdapter adapter = clazz.newInstance(); //判断传过来的适配器是否能处理指定的逻辑 if(adapter.support(adapter)){ return adapter.login(key,adapter); } }catch (Exception e){ e.printStackTrace(); } return null; } //类图的快捷键 Ctrl + Alt + Shift + U }
客户端测试代码:
package com.alibaba.design.adapterpattern.loginadapter.v2; /** * Created by Tom. */ public class PassportTest { public static void main(String[] args) { IPassportForThird passportForThird = new PassportForThirdAdapter(); passportForThird.loginForQQ(""); } }
最后，来看一下类图：
至此，我们在遵循开闭原则的前提下，完整地实现了一个兼容多平台登录的业务场景。
（5）模式在源码中的体现
Spring 中适配器模式也应用得非常广泛，例如：SpringAOP 中的 AdvisorAdapter 类，它有三个实现类 MethodBeforeAdviceAdapter、AfterReturningAdviceAdapter 和ThrowsAdviceAdapter，先来看顶层接口 AdvisorAdapter 的源代码：
package org.springframework.aop.framework.adapter; import org.aopalliance.aop.Advice; import org.aopalliance.intercept.MethodInterceptor; import org.springframework.aop.Advisor; public interface AdvisorAdapter { boolean supportsAdvice(Advice var1); MethodInterceptor getInterceptor(Advisor var1); }
再看 MethodBeforeAdviceAdapter 类：
package org.springframework.aop.framework.adapter; import java.io.Serializable; import org.aopalliance.aop.Advice; import org.aopalliance.intercept.MethodInterceptor; import org.springframework.aop.Advisor; import org.springframework.aop.MethodBeforeAdvice; class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable { MethodBeforeAdviceAdapter() { } public boolean supportsAdvice(Advice advice) { return advice instanceof MethodBeforeAdvice; } public MethodInterceptor getInterceptor(Advisor advisor) { MethodBeforeAdvice advice = (MethodBeforeAdvice)advisor.getAdvice(); return new MethodBeforeAdviceInterceptor(advice); } }
Spring 会根据不同的 AOP 配置来确定使用对应的 Advice，跟策略模式不同的一个方法可以同时拥有多个 Advice。
（6）适配器模式的优缺点
- 优点：
1、能提高类的透明性和复用，现有的类复用但不需要改变。
2、目标类和适配器类解耦，提高程序的扩展性。
3、在很多业务场景中符合开闭原则。 - 缺点：
1、适配器编写过程需要全面考虑，可能会增加系统的复杂性。
2、增加代码阅读难度，降低代码可读性，过多使用适配器会使系统代码变得凌乱。
3.2 代理模式
（1） 概念
代理模式（ProxyPattern）的定义也非常简单，是指为其他对象提供一种代理，以控制对这个对象的访问。
代理对象在客服端和目标对象之间起到中介作用，代理模式属于结构型设计模式。
（2）适用场景
使用代理模式主要有两个目的：一保护目标对象，二增强目标对象。
Subject 是顶层接口，RealSubject 是真实对象（被代理对象），Proxy 是代理对象，代理对象持有被代理对象的引用，客户端调用代理对象方法，同时也调用被代理对象的方法，但是在代理对象前后增加一些处理。在代码中，我们想到代理，就会理解为是代码增强，其实就是在原本逻辑前后增加一些逻辑，而调用者无感知。代理模式属于结构型模式，有静态代理和动态代理
（3）代码示例
1. 静态代理模式
举个例子：人到了适婚年龄，父母总是迫不及待希望早点抱孙子。而现在社会的人在各种压力之下，都选择晚婚晚育。于是着急的父母就开始到处为自己的子女相亲，比子女自己还着急。这个相亲的过程，就是一种我们人人都有份的代理。来看代码实现：
顶层接口 Person：
package com.alibaba.design.proxypattern; /** * @author zhouyanxiang * @create 2020-07-2020/7/30-10:54 */ public interface Person { public void findLove(); }
儿子要找对象，实现 Son 类：
package com.alibaba.design.proxypattern.staticproxy; import com.alibaba.design.proxypattern.Person; /** * @author zhouyanxiang * @create 2020-07-2020/7/30-10:55 */ public class Son implements Person { @Override public void findLove() { System.out.println("儿子要求：肤白貌美大长腿"); } }
父亲要帮儿子相亲，实现 Father 类：
package com.alibaba.design.proxypattern.staticproxy; import com.alibaba.design.proxypattern.Person; /** * @author zhouyanxiang * @create 2020-07-2020/7/30-10:55 */ public class Father implements Person { private Son son; public Father(Son son){ this.son = son; } @Override public void findLove(){ System.out.println("父亲物色对象"); this.son.findLove(); System.out.println("双方父母同意，确立关系"); } public void findJob(){ } }
来看测试代码：
- FatherTest
package com.alibaba.design.proxypattern.staticproxy; /** * @author zhouyanxiang * @create 2020-07-2020/7/30-10:58 */ public class FatherTest { public static void main(String[] args) { Father father = new Father(new Son()); father.findLove(); //农村，媒婆 //婚介所 //大家每天都在用的一种静态代理的形式 //对数据库进行分库分表 //ThreadLocal //进行数据源动态切换 } }
2. 动态代理模式
动态代理和静态对比基本思路是一致的，只不过动态代理功能更加强大，随着业务的扩展适应性更强。如果还以找对象为例，使用动态代理相当于是能够适应复杂的业务场景。不仅仅只是父亲给儿子找对象，如果找对象这项业务发展成了一个产业，进而出现了媒婆、婚介所等这样的形式。那么，此时用静态代理成本就更大了，需要一个更加通用的解决方案，要满足任何单身人士找对象的需求。我们升级一下代码，先来看 JDK 实现方式：
创建媒婆（婚介）JDKMeipo 类：
package com.alibaba.design.proxypattern.dynamicproxy.jdkproxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; /** * @author zhouyanxiang * @create 2020-07-2020/7/30-10:52 */ public class JDKMeipo implements InvocationHandler { private Object target; public Object getInstance(Object target) throws Exception{ this.target = target; Class<?> clazz = target.getClass(); return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this); } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { before(); Object obj = method.invoke(this.target,args); after(); return obj; } private void before(){ System.out.println("我是媒婆，我要给你找对象，现在已经确认你的需求"); System.out.println("开始物色"); } private void after(){ System.out.println("OK的话，准备办事"); } }
创建单身客户 Customer 类：
package com.alibaba.design.proxypattern.dynamicproxy.jdkproxy; import com.alibaba.design.proxypattern.Person; /** * @author zhouyanxiang * @create 2020-07-2020/7/30-11:11 */ public class Customer implements Person { @Override public void findLove() { System.out.println("高富帅"); System.out.println("身高180cm"); System.out.println("有6块腹肌"); } }
测试代码
package com.alibaba.design.proxypattern.dynamicproxy.jdkproxy; import java.lang.reflect.Method; /** * @author zhouyanxiang * @create 2020-07-2020/7/30-11:11 */ public class JDKProxyTest { public static void main(String[] args) { try { Object obj = new JDKMeipo().getInstance(new Customer()); Method method = obj.getClass().getMethod("findLove",null); method.invoke(obj); }catch (Exception e){ e.printStackTrace(); } } }
（4） 模式在源码中的体现
代理模式在 Spring 源码中的应用,先看 ProxyFactoryBean 核心的方法就是 getObject()方法，我们来看一下源码：
public Object getObject() throws BeansException { initializeAdvisorChain(); if (isSingleton()) { return getSingletonInstance(); }else { if (this.targetName == null) { logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " + "Enable prototype proxies by setting the 'targetName' property."); } return newPrototypeInstance(); } }
在 getObject()方法中，主要调用 getSingletonInstance()和 newPrototypeInstance()；在 Spring 的配置中，如果不做任何设置，那么 Spring 代理生成的 Bean 都是单例对象。如果修改 scope 则每次创建一个新的原型对象。
Spring 利用动态代理实现 AOP 有两个非常重要的类，一个是 JdkDynamicAopProxy 类
和 CglibAopProxy 类，来看一下类图：
Spring 中的代理选择原则
- 1、当 Bean 有实现接口时，Spring 就会用 JDK 的动态代理。
- 2、当 Bean 没有实现接口时，Spring 选择 CGLib。
- 3、Spring 可以通过配置强制使用 CGLib，只需在 Spring 的配置文件中加入如下代码：
<aop:aspectj-autoproxy proxy-target-class="true"/>
（5）代理模式的优缺点
- 优点：
1、代理模式能将代理对象与真实被调用的目标对象分离。
2、一定程度上降低了系统的耦合度，扩展性好。
3、可以起到保护目标对象的作用。
4、可以对目标对象的功能增强。 - 缺点：
1、代理模式会造成系统设计中类的数量增加。
2、在客户端和目标对象增加一个代理对象，会造成请求处理速度变慢。
3、增加了系统的复杂度。
（6） 动态代理模式和静态代理模式的区别
- 1、静态代理只能通过手动完成代理操作，如果被代理类增加新的方法，代理类需要同步
新增，违背开闭原则。 - 2、动态代理采用在运行时动态生成代码的方式，取消了对被代理类的扩展限制，遵循开
闭原则。 - 3、若动态代理要对目标类的增强逻辑扩展，结合策略模式，只需要新增策略类便可完成，
无需修改代理类的代码。
3.3 装饰器模式
（1）概念
装饰者模式（Decorator Pattern）是指在不改变原有对象的基础之上，将功能附加到对象上，提供了比继承更有弹性的替代方案（扩展原有对象的功能），属于结构型模式。
（2）适用场景
装饰者模式在我们生活中应用也比较多如给煎饼加鸡蛋；给蛋糕加上一些水果；给房子装修等，为对象扩展一些额外的职责。装饰者在代码程序中适用于以下场景：
1、用于扩展一个类的功能或给一个类添加附加职责。
2、动态的给一个对象添加功能，这些功能可以再动态的撤销。
