桥接模式-多类型登录方式的思考

于 2024-08-27 22:56:41 发布
阅读量431 收藏 8
点赞数 20
分类专栏： 设计模式 文章标签： 桥接模式 java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/imbzz/article/details/141560589
版权

桥接模式-SSO单点登录

背景:(业务细节已脱敏)

基于实习期间的一个代码重构的思考——业务细节已脱敏
基于内部旧框架实现业务toB管理系统，需要迁移数据并新的内部技术框架对进行代码重构

需求:

登录接口是旧项目已有的，包括原有系统的账号密码，邮箱，短信，以及第三方客户OA系统等方式进行授权，现需要对旧框架实现的登录功能迁移到中台进行统一集成

问题:

  1. 原有旧框架独立于中台，旧框住不再维护，需要迁移

  2. 业务有所变更，并且时常有变更且仍与k讨论，带有不确定性

  3. 原有登录方式都写到service类中，函数方法全部堆积在service，代码数量较大，结构混乱

解决方式:

通过桥接模式对登录方式的结构进行整理，完全符合开闭原则，提高代码的扩展性,应对仍在商讨的业务

Autho2详解文章

OAuth2.0 实现单点登录

  1. 什么是OAuth2.0

OAuth2.0 来实现第三方授权，基于第三方应用访问用户信息的权限（本质上就是给别人调用自己服务接口的权限）。

四种授权模式

  1. 客户端模式

这是最简单的一种模式，我们可以直接向验证服务器请求一个 Token（这里可能有些小伙伴对Token的概念不是很熟悉，Token 相当于是一个令牌，我们需要在验证服务器 （User Account And Authentication） 服务拿到令牌之后，才能去访问资源，比如用户信息、借阅信息等，这样资源服务器才能知道我们是谁以及是否成功登录了）
图片.png

  • 虽然这种模式比较简便，但是已经失去了用户验证的意义，
  • 压根就不是给用户校验准备的，而是更适用于服务内部调用的场景
  1. 密码模式

密码模式相比客户端模式，就多了用户名和密码的信息，用户需要提供对应账号的用户名和密码，才能获取到 Token
图片.png

  • 虽然这样看起来比较合理，但是会直接将账号和密码泄露给客户端，
  • 需要后台完全信任客户端不会拿账号密码去干其他坏事，所以这也不是我们常见的
  1. 隐式授权模式

首先用户访问页面时，会重定向到认证服务器，接着认证服务器给用户一个认证页面，等待用户授权，用户填写信息完成授权后，认证服务器返回 Token
图片.png
它适用于没有服务端的第三方应用页面，并且相比前面一种形式，验证都是在验证服务器进行的，敏感信息不会轻易泄露，但是 Token 依然存在泄露的风险 。

  1. 授权码模式

这种模式是最安全的一种模式，也是推荐使用的一种，比如我们手机上的很多 App 都是使用的这种模式。

相比隐式授权模式，它并不会直接返回 Token，而是返回授权码，真正的 Token 是通过应用服务器访问验证服务器获得的。在一开始的时候，应用服务器（客户端通过访问自己的应用服务器来进而访问其他服务）和验证服务器之间会共享一个 secret，这个东西没有其他人知道，而验证服务器在用户验证完成之后，会返回一个授权码，应用服务器最后将授权码和 secret 一起交给验证服务器进行验证，并且 Token 也是在服务端之间传递，不会直接给到客户端
图片.png

  • 这样就算有人中途窃取了授权码，也毫无意义，因为，Token 的获取必须同时携带授权码和 secret ，
  • 但是 secret 第三方是无法得知的，并且 Token 不会直接丢给客户端，大大减少了泄露的风险。

安全性高的原因

  1. 是在应用服务器上进行验证，不会返回token给前端

为什么先获取到code，再申请取token

  1. 要换取access_token的三要素：用户的同意授权+第三方appid+第三方app_secret
  2. 用户输入验证信息后拿到code，说明用户同意授权，但是用户拿不到服务器的第三方appid+第三方app_secret
  3. 服务器将返回的code，同第三方appid和app_secret一起发送，才能满足三要素拿到真正的token

桥接模式优化

图片.png桥接模式是将抽象部分与它的实现部分分离，使它们都可以独立地变化 。

问题

  1. 为什么不直接在service里面直接每种登录方式写一个方法，何必像桥接模式每种登录方式写一个实现类
  1. 在service里面给每种登录写一个实现方法，我们需要滑动整个文件才能知道有多少个方法，而桥接模式一个登录方式一个类单独维护，一目了然。
  2. 如果某种登录方式在service实现非常复杂，像需要Autho2等方式的授权，需要挤下很多的方法，肯定是不利于维护的。
  1. 为什么不用策略模式
  1. 我觉得桥接模式中包含了策略模式，比如第三方登录的就可以根据不同的需要，选择不同的登录策略，引入桥接模式可以针对登录这一模块添加跟登录相关的其他接口，比如注册，退出登录等接口，注册的话也可以选择不同策略。另外像支付一样比较单一功能的接口一般使用策略模式就足够。 桥接模型更像: 多个接口x多个实现类， 策略模式更像：一个接口类x多实现类。
  2. 此桥接模式的使用，还根据情况使用了单例模式和工厂模式
  1. 桥接模式有什么好处

完全开闭原则，新增方法无需修改原代码
类结构清晰，不会全部接口积压在一个service中

代码实现

完整结构图
图片.png
但是下面的代码对该图的一些瑕疵进行了一下优化

  1. 瑕疵：上图中的右侧子实现类必须实现右侧接口的全部方法
  • 通过在接口层和实现层两者中间引入 抽象层 来解决这个问题
  1. 瑕疵：每次使用右侧子实现类都要new出来吗?
  • 通过工厂模式+单例模式实现右侧子实现类的单例懒加载

具体代码:

  1. 右侧登录方式接口层
public interface RegisterLoginFuncInterface {
    public String login(String account, String password);
    public String register(UserInfo userInfo);
    public boolean checkUserExists(String userName);
    public String login3rd(HttpServletRequest request);
}
  1. 右侧登录方式的抽象层
public abstract class AbstractRegisterLoginFunc implements RegisterLoginFuncInterface {
    protected String commonLogin(String account, String password, UserRepository userRepository) {
        UserInfo userInfo = userRepository.findByUserNameAndUserPassword(account, password);
        if(userInfo == null) {
            return "account / password ERROR!";
        }
        return "Login Success";
    }

    protected String commonRegister(UserInfo userInfo, UserRepository userRepository) {
        if(commonCheckUserExists(userInfo.getUserName(), userRepository)) {
            throw new RuntimeException("User already registered.");
        }
        userInfo.setCreateDate(new Date());
        userRepository.save(userInfo);
        return "Register Success!";
    }

    protected boolean commonCheckUserExists(String userName, UserRepository userRepository) {
        UserInfo user = userRepository.findByUserName(userName);
        if(user == null) {
            return false;
        }
        return true;
    }

    public String login(String account, String password) {
        throw new UnsupportedOperationException();
    }

    public String register(UserInfo userInfo){
        throw new UnsupportedOperationException();
    }

    public boolean checkUserExists(String userName){
        throw new UnsupportedOperationException();
    }

    public String login3rd(HttpServletRequest request) {
        throw new UnsupportedOperationException();
    }
}
  1. 右侧具体登录方式的实现类
@Component
public class RegisterLoginByDefault extends AbstractRegisterLoginFunc implements RegisterLoginFuncInterface {

    @Autowired
    private UserRepository userRepository;

    @PostConstruct
    private void initFuncMap() {
        RegisterLoginComponentFactory.funcMap.put("Default", this);
    }

    @Override
    public String login(String account, String password) {
        return super.commonLogin(account, password, userRepository);
    }

    @Override
    public String register(UserInfo userInfo) {
        return super.commonRegister(userInfo, userRepository);
    }

    @Override
    public boolean checkUserExists(String userName) {
        return super.commonCheckUserExists(userName, userRepository);
    }
}

Gitee只是第三方登录的一种，其余微信，支付宝等第三方登录可以按需要无缝接入，这里只写一个Gitee作为案例

@Component
public class RegisterLoginByGitee extends AbstractRegisterLoginFunc implements RegisterLoginFuncInterface {
    @Value("${gitee.state}")
    private String giteeState;
    @Value("${gitee.token.url}")
    private String giteeTokenUrl;
    @Value("${gitee.user.url}")
    private String giteeUserUrl;
    @Value("${gitee.user.prefix}")
    private String giteeUserPrefix;

    @Autowired
    private UserRepository userRepository;

    @PostConstruct
    private void initFuncMap() {
        RegisterLoginComponentFactory.funcMap.put("GITEE", this);
    }

    @Override
    public String login3rd(HttpServletRequest request) {
        String code = request.getParameter("code");
        String state = request.getParameter("state");
        if(!giteeState.equals(state)) {
            throw new UnsupportedOperationException("Invalid state!");
        }

        //请求Gitee平台获取token，并携带code
        String tokenUrl = giteeTokenUrl.concat(code);
        JSONObject tokenResponse = HttpClientUtils.execute(tokenUrl, HttpMethod.POST);
        String token = String.valueOf(tokenResponse.get("access_token"));
        System.out.println(token);
        //请求用户信息，并携带 token
        String userUrl = giteeUserUrl.concat(token);
        JSONObject userInfoResponse = HttpClientUtils.execute(userUrl, HttpMethod.GET);

        //获取用户信息，userName添加前缀 GITEE@, 密码保持与userName一致。讨论过程请参见2.3小节
        String userName = giteeUserPrefix.concat(String.valueOf(userInfoResponse.get("name")));
        String password = userName;
        return autoRegister3rdAndLogin(userName, password);
    }

    private String autoRegister3rdAndLogin(String userName, String password) {
        //如果第三方账号已经登录过，则直接登录
        if(super.commonCheckUserExists(userName, userRepository)) {
            return super.commonLogin(userName, password, userRepository);
        }
        UserInfo userInfo = new UserInfo();
        userInfo.setUserName(userName);
        userInfo.setUserPassword(password);
        userInfo.setCreateDate(new Date());

        //如果第三方账号是第一次登录，先进行“自动注册”
        super.commonRegister(userInfo, userRepository);
        //自动注册完成后，进行登录
        return super.commonLogin(userName, password, userRepository);
    }
}
  1. 左侧抽象调用入口类
public abstract class AbstractRegisterLoginComponent {
    protected RegisterLoginFuncInterface funcInterface;

    public AbstractRegisterLoginComponent(RegisterLoginFuncInterface funcInterface) {
        validate(funcInterface);
        this.funcInterface = funcInterface;
    }

    protected final void validate(RegisterLoginFuncInterface funcInterface) {
        if(!(funcInterface instanceof RegisterLoginFuncInterface)) {
            throw new UnsupportedOperationException("Unknown register/login function type!");
        }
    }

    public abstract String login(String username, String password);
    public abstract String register(UserInfo userInfo);
    public abstract boolean checkUserExists(String userName);
    public abstract String login3rd(HttpServletRequest request);
}
  1. 左侧具体入口子类
public class RegisterLoginComponent extends AbstractRegisterLoginComponent{

    public RegisterLoginComponent(RegisterLoginFuncInterface funcInterface) {
        super(funcInterface);
    }

    @Override
    public String login(String username, String password) {
        return funcInterface.login(username, password);
    }

    @Override
    public String register(UserInfo userInfo) {
        return funcInterface.register(userInfo);
    }

    @Override
    public boolean checkUserExists(String userName) {
        return funcInterface.checkUserExists(userName);
    }

    @Override
    public String login3rd(HttpServletRequest request) {
        return funcInterface.login3rd(request);
    }
}
  1. 工厂模式对实现类进行懒加载
  • 子实现类的创建运用了工厂模式+单例模式实现懒加载
public class RegisterLoginComponentFactory {
    // 缓存 AbstractRegisterLoginComponent（左路）。根据不同的登录方式进行缓存
    public static Map<String, AbstractRegisterLoginComponent> componentMap
            = new ConcurrentHashMap<>();
    // 缓存不同类型的实现类（右路），如：RegisterLoginByDefault,RegisterLoginByGitee
    public static Map<String, RegisterLoginFuncInterface> funcMap
            = new ConcurrentHashMap<>();

    // 根据不同的登录类型，获取 AbstractRegisterLoginComponent
    public static AbstractRegisterLoginComponent getComponent(String type) {
        //如果存在，直接返回
        AbstractRegisterLoginComponent component = componentMap.get(type);
        if(component == null) {
            //并发情况下，汲取双重检查锁机制的设计，如果componentMap中没有，则进行创建
            synchronized (componentMap) {
                component = componentMap.get(type);
                if(component == null) {
                    //根据不同类型的实现类（右路），创建RegisterLoginComponent对象，
                    //并put到map中缓存起来，以备下次使用。
                    component = new RegisterLoginComponent(funcMap.get(type));
                    componentMap.put(type, component);
                }
            }
        }
        return component;
    }
}
  1. controller调用
@RestController
@RequestMapping("/bridge")
public class UserBridgeController {

    @Autowired
    private UserBridgeService userBridgeService;

    @PostMapping("/login")
    public String login(String account, String password) {
        return userBridgeService.login(account, password);
    }

    @PostMapping("/register")
    public String register(@RequestBody UserInfo userInfo) {
        return userBridgeService.register(userInfo);
    }

    @GetMapping("/gitee")
    public String gitee(HttpServletRequest request) throws IOException {
        return userBridgeService.login3rd(request, "GITEE");
    }
}

仅个人思考，有错请指出
在这里插入图片描述

孤寒_imbzz
关注
  • 20
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式学习--桥接模式
csdnlaiyanqi的博客
09-09 343
桥接模式的主要作用：通过抽象部分与实现部分相分离，把多种可匹配的使用相组合 说白了就是在A类中含有B类的接口，通过构造函数传递B类的实现，这个B类就是设计的桥 那么我们平时开发中有哪些场景是使用到了该模式呢？ 最典型的是JDBC多驱动程序的实现，还有同品牌类型的台式机和笔记本，平板。 业务实现中的多类接口同组实现等。因为在一些组合中如果每个类有多个不同的实现， 就会出现迪卡尔积，这样使用桥接模式就非常简单。 ...
桥接模式 -- 多维度变化
智多牛 - 俯首甘为孺子牛！
01-14 1799
在正式介绍桥接模式之前，我先跟大家谈谈两种常见文具的区别，它们是毛笔和蜡笔。假如我们需要大中小3种型号的画笔，能够绘制12种不同的颜色，如果使用蜡笔，需要准备3×12 = 36支，但如果使用毛笔的话，只需要提供3种型号的毛笔，外加12个颜料盒即可，涉及到的对象个数仅为 3 + 12 = 15，远小于36，却能实现与36支蜡笔同样的功能。如果增加一种新型号的画笔，并且也需要具有12种颜色，对应的
设计模式-桥接模式
weixin_43119856的博客
11-20 344
设计模式-桥接模式
设计模式——桥接模式
qwqgood的博客
05-31 3648
桥接模式（将一个继承关系变为组合关系） 场景：多种手机 现在有三类手机，每种类别的手机有三种不同的品牌，每种手机都有相同的功能（打电话等），现在需要我们创建调用某种手机的call方法 传统实现： 类似工厂模式，先按照手机类别创建三个类，每个类下根据品牌创建具体的手机对象 可以实现功能，但是当类很多时会出现组合爆炸 桥接模式 桥接模式本质是使用合成复用原则将其中的一个继承变为了组合，使得代码的耦合度降低 public interface Brand { void call(); } publ
结构型模式之桥接模式的案例示范
HUBA_yosa的博客
01-04 1447
1. 桥接模式介绍 桥接模式的主要作用就是通过将抽象部分与实现部分分离，把多种可匹配的使用进行组合。说白了核心实现就是A类中含有B类接口，通过构造函数传递B类的实现，这个B类就是设计的桥。 桥接模式在平常的开发中有哪些场景？ JDBC多种驱动程序的实现、同品牌类型的台式机和笔记本平板、业务实现中多类接口同组过滤服务等。这些场景都比较适合桥接模式进行实现，因为在一些组合中如果每一个类都实现不同的服务可能会出现笛卡尔积，而使用桥接模式就可以非常简单。 2. 案例场景模拟 随着市场的竞争在支付服务行业出现了微
【设计模式】使用桥接模式拆解短信发送中的类型与渠道
积木成林，聚沙成塔
09-12 485
桥接模式的主流定义有两种，第一种是GoF的定义：将抽象和实现解耦，使得两者可以独立地变化。通过这句话，我们能够得到的信息是需要降低抽象和实现和依赖紧密程度，以达到两者之间可以独立扩展，互不影响的效果。在大多数情况下，抽象一般指的是接口和抽象类，实现就是实现类。在桥接模式中的抽象和实现，无所谓接口、抽象类还是实现类的差异。桥接模式抽象更多的是提供一定的约束，比如一个固定的执行流程，在这个流程中会定义出一些可以自由替换的口子，而实现就是去适配这些口子，让一个固定的执行流程可以得到不同的执行结果。
桥接模式-结构型
weixin_30770495的博客
08-25 135
定义 桥梁模式是对象的结构模式。又称为柄体(Handle and Body)模式或接口(Interface)模式。桥梁模式的用意是“将抽象化(Abstraction)与实现化(Implementation)脱耦，使得二者可以独立地变化”。 桥梁模式的用意 桥梁模式虽然不是一个使用频率很高的模式，但是熟悉这个模式对于理解面向对象的设计原则，包括“开-闭”原则以及组合/聚合复用原则都很有帮助。理...
寂然解读设计模式 - 桥接模式
weixin_44808014的博客
01-06 197
I walk very slowly, but I never walk backwards 设计模式 - 桥接模式 寂然 大家好，我是寂然，本节课，我们来聊设计模式中的桥接模式，闲言少叙，首先，我们来看一个生活中的案例 案例演示 - 电脑分类 现在我们对不同类型的电脑，不同品牌实现操作编程，其实我们知道，电脑有各种各样的类型，比如台式机，笔记本，平板电脑等，而每个类型都有不同的品牌，比如台式机的品牌有华为，三星，苹果，笔记本的品牌也有华为，三星，苹果等…,如下图所示 案例分析 这样的话，我们现
Java桥接模式：打破继承束缚，优雅实现多维度变化
陈书予
03-16 1163
桥接模式（Bridge Pattern）是一种结构型设计模式，它将抽象部分与实现部分分离，使它们可以独立变化。该模式通过创建抽象类和实现类之间的桥梁，将它们联系起来。这样一来，抽象类和实现类就可以分别修改而不会影响到彼此。桥接模式的主要思想是面向接口编程和实现分离。在软件开发中，经常遇到需要改变系统中某些部分的实现，而不希望对客户端产生影响。例如，在开发一个绘图程序时，需要对图形对象进行绘制操作，但是绘制操作的方式可能是使用不同的绘制工具，例如画笔、颜料等等。
设计模式 之 桥接模式解析
东晨雨的博客
05-22 278
预计阅读时间：10分钟 1、桥接模式的定义 将抽象部分与它的实现部分分离，使它们都可以独立地变化。在桥接模式中的桥接是单向的，也就是只能是抽象部分的对象去使用具体实现部分的对象，而不能反过来，也就是个单向桥。 2、案例分析 （1）需求：发送提示消息，从业务上看，消息又分成普通消息、加急消息和特急消息多种，不同的消息类型，业务功能处理是不一样的，比如加急消息是在消息上添加加急，而特急消...
JAVA桥接模式
帅哥威的博客
09-07 717
JAVA桥接模式   通过本文将学习到 1、前言 2、桥接模式的概念 3、桥接模式的UML图 4、桥接模式的实现 5、桥接模式的优缺点及使用环境 6、总结       1、前言 今天上了一个大佬的课，在聊大学学的东西。数据结构、编译原理、软件工程、算法导论、离散数学、....这些，从30年前大学开启计算机这门学科开始就没怎么变过。换句话说这些东西是内功想以后走的远，内功不高...
【学习设计模式10】分离抽象与实现——桥接模式
Aiky哇
05-17 312
上篇：【学习设计模式9】兼容扩展坞—适配器模式_Aiky哇的博客-CSDN博客上篇：【学习设计模式8】组装流水线——建造者模式_Aiky哇的博客-CSDN博客上篇：【学习设计模式7】复制粘贴就得了——原型模式_Aiky哇的博客-CSDN博客那么有没有一种方法可以名正言顺的复制粘贴呢？当然有了，那就是原型模式。原型模式也叫克隆模式。https://aikysay.blog.csdn.net/article/details/123407658建造者模式的定义建造者模式的使用流程建造者模式的适用场景建造者模...
结构型模式：代理/适配器/装饰者/桥接/外观模式
略
07-11 817
有些人可能炒过股票，但其实大部分人都不太懂，这种没有足够了解证券知识的情况下做股票是很容易亏钱的，刚开始炒股肯定都会想，如果有个懂行的帮帮手就好，其实基金就是个好帮手，支付宝里就有许多的基金，它将投资者分散的资金集中起来，交由专业的经理人进行管理，投资于股票、债券、外汇等领域，而基金投资的收益归持有者所有，管理机构收取一定比例的托管管理费用。为良好的代码设计和可维护性，我们将网络通信部分隐藏起来，只暴露给本地服务一个接口，通过该接口即可访问远程服务提供的功能，而不必过多关心通信部分的细节。
设计模式-- 结构型设计模式
weixin_60269711的博客
04-19 454
目录 1.什么是设计模式? 2.创建型模式 3适配器模式Adapter：适配器 1.定义:适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作 3.桥接模式Bridge：桥接 1.定义:将抽象部分与实现部分分离，使它们都可以独立的变化。 4.装饰器模式 1.定义：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。 5.外观模式 1.定义:为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更...
设计模式-结构性模式-桥接模式
LB_bei的博客
08-23 649
桥接模式就是将抽象部分与他的实现部分分离，使他们都可以独立的变化；桥接模式用一种巧妙地方式处理多层继承存在的问题，用抽象关联来取代传统的多层继承，将类之间的静态继承关系转变为动态的组合关系，使得系统更加灵活，并易于扩展，有效地控制了系统中类的个数；
设计模式 7 桥接模式
小小程序猿
08-26 376
桥接模式允许在运行时将抽象类与其实现类解耦。它通过引入一个接口来使得抽象类与具体的实现类分开，从而支持两者的独立变化。这样可以避免复杂的多层继承结构。
【设计模式】模块模式和桥接模式
小秀的博客
08-24 441
能够使一个单独的对象拥有公共/私有的方法和变量，从而屏蔽来自全局作用域的特殊部分。这可以减少我们的函数名与在页面中其他脚本区域内定义的函数名冲突的可能性。比如，一个 toast ，给一个元素绑定动画效果，可以将动画效果的实现隔离，从而不同的 toast 可以在 与不同的动画相结合。模块化模式最初被定义为在传统软件工程中为类提供私有和公共封装的一种方法。使用场景：一个类存在两个或多个独立变化的维度，且这两个维度都需要进行扩展。桥接模式：将抽象部分与它的实现部分分离，使它们都可以独立地变化。
【Java设计模式】Bridge模式：在Java中解耦抽象与实现
最新发布
weixin_42545951的博客
08-27 470
在Java开发中，设计模式是提高代码质量和可维护性的重要工具。本文将介绍Bridge模式，它是一种结构型设计模式，用于解耦抽象与实现，增强软件系统的灵活性和可扩展性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值