1、什么是外观模式
    将一些复杂的流程封装成一个接口对外提供，同时对这个有复杂逻辑的接口进行优化，一般都是按照功能来分割开来，但是这样会使代码更容易浏览，逻辑更为清晰，调试更为简单。

    2、外观模式的应用场景

    图片1.png
    刚刚上边也提到了，外观模式就是将复杂的流程封装为一个接口给用户调用，该模式有三种角色：
    子系统角色：将复杂的流程按照功能分割成各个模块，每个模块就称之为子系统角
    色。
    门面角色：外观模式的核心，调用子系统角色，将各个子系统角色组合起来。
    客户角色：通过调用Facade来完成要实现的功能。

    3、具体代码实现

    需要重构的代码

    1. @Slf4j
    2. public class PayCallbackService {
    3.     // 用户下单成功后，有那些操作？
    4.     // 1.增加支付回调接口日志
    5.     // 2.修改订单数据库状态为已经成功
    6.     // 3.调用积分服务接口
    7.     // 4.调用消息服务平台服务接口
    9.     public boolean callback(Map<String, String> verifySignature) {
    10.         // 1.第一步打印日志信息
    11.         String orderId = verifySignature.get("orderId"); // 获取后台通知的数据，其他字段也可用类似方式获取
    12.         String respCode = verifySignature.get("respCode");
    13.         log.info("orderId:{},respCode:{}", orderId, respCode);
    14.         // 2.修改订单状态为已经支付
    15.         new PaymentTransactionMapper() {
    16.             @Override
    17.             public void updatePaymentStatus() {
    18.                 log.info(">>>修改订单状态为已经支付>>>>>");
    19.             }
    20.         }.updatePaymentStatus();
    21.         // 3.调用积分接口增加积分
    22.         HttpClientUtils.doPost("jifen.com", "积分接口");
    23.         // 4.调用消息服务平台提示
    24.         HttpClientUtils.doPost("msg.com", "调用消息接口");
    25.         return true;
    26.     }
    27. }

    优化后

    1. //创建各个子系统角色想·
    2. @Component
    3. @Slf4j
    4. public class LogService {
    6.     public void logService(Map<String, String> verifySignature) {
    7.         // 1.第一步打印日志信息
    8.         String orderId = verifySignature.get("orderId"); // 获取后台通知的数据，其他字段也可用类似方式获取
    9.         String respCode = verifySignature.get("respCode");
    10.         log.info("第一个模块>>>orderId:{},respCode:{}", orderId, respCode);
    11.     }
    13. }
    15. @Slf4j
    16. @Component
    17. public class PaymentService {
    19.     public void updatePaymentStatus() {
    20.         // 2.修改订单状态为已经支付
    21.         new PaymentTransactionMapper() {
    22.             @Override
    23.             public void updatePaymentStatus() {
    24.                 log.info("第二个模块>>>修改订单状态为已经支付>>>>>");
    25.             }
    26.         }.updatePaymentStatus();
    27.     }
    28. }
    29. @Component
    30. @Slf4j
    31. public class IntegralService {
    33.     public void callIntegral() {
    34.         // 3.调用积分接口增加积分
    35.         HttpClientUtils.doPost("jifen.com", "积分接口");
    36.         log.info("第三个模块>>>调用积分接口打印日志>>>>>");
    37.     }
    38. }
    41. @Component
    42. @Slf4j
    43. public class MsgService {
    45.     public void msgService() {
    46.         log.info("第四个模块>>>调用消息模块打印日志>>>>>");
    47.     }
    48. }
    54. 创建门面接口
    55. @Component
    56. public class PayCallbackFacade {
    57.     @Autowired
    58.     private LogService logService;
    59.     @Autowired
    60.     private PaymentService paymentService;
    61.     @Autowired
    62.     private IntegralService integralService;
    63.     @Autowired
    64.     private MsgService msgService;
    66.     public boolean callbackFacade(Map<String, String> verifySignature) {
    67.         logService.logService(verifySignature);
    68.         paymentService.updatePaymentStatus();
    69.         integralService.callIntegral();
    70.         msgService.msgService();
    71.         return true;
    72.     }
    73. }

    4、优点
    松散耦合：使得客户端和子系统之间解耦，让子系统的内部模块更容易 扩展和维护；
    简单易用：客户端根本不知道各个子系统内部的实现，只需要与facade 交互即可；
    更好的划分访问层次：有些方法是对系统外提供的，也有些方法是内部 相互交互使用的，子系统将那些暴露给外部的功能集中到门 面中去，这样就可以实现客户端的使用，很好的隐藏了子系 统内部的实现细节。