开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> 设计模式学习笔记---策略模式+简单工厂模式实现用户登录 -> 正文阅读

[Java知识库]设计模式学习笔记---策略模式+简单工厂模式实现用户登录

大家平时工作应该都处理过用户登录的需求, 传统的写法是这样的, controller --> service?--> mysql

如果出现多种用户登录类型, 那么service层的代码就会变成这样:

    @Override
    public UserInfo doUserLogin(UserInfo userInfo) {
        if (UserLoginTypeEnum.BOSS_LOGIN.equals(type)) {
            // 老板登录
        } else if (UserLoginTypeEnum.STORE_LOGIN.equals(type)) {
            // 顾客登录
        }
        // 等多的登录类型
    }

我相信大家第一次写用户登录都是这样写的, 这种写法很简单, 但是如果哪天增加了新的登录方式, 且不止一种, 那么就要在下面增加很多else..if , 太多的else..if 语句影响阅读代码, 特别是对旧代码的修改, 很容易出现bug, 这就是违背了面向对象最基本的设计原则 : 开闭原则, 也就是对修改关闭, 对拓展开放.

那如何设计代码, 既可以增加新的登录功能, 又不会修改原有代码?

最近在研究设计模式, 使用策略模式就可以很好地解决问题

在<head first 设计模式>一书中是这样描述策略模式的:

? ? ? ? 策略模式定了了算法族, 分别封装起来, 让他们之间可以互相替换, 此模式让算法的变化独立

于使用算法的客户

我们来看策略模式的类图 :?

搞清楚他们之间的依赖关系很重要, 下面来重新设计用户登录, 你会发现焕然一新!

1. 根据类图设计出策略类, 当然要把它设计成接口

package com.demo07.strategy;

import com.demo07.model.UserInfo;
import com.demo07.service.UserService;

/**
 * 用户登录策略
 * @author canxiusi.yan
 * @description UserLogin
 * @date 2022/2/13 15:56
 */
public interface UserLogin {

    /**
     * 用户登录, 返回该用户信息
     * @return
     */
    UserInfo doLogin(UserInfo userInfo, UserService userService);
}

? ? ? ? 该接口定义了总策略, 具体实现哪一种策略要根据它的实现类决定, 下面来设计具体的实现类

? ? ? ? 老板登录策略

package com.demo07.strategy.concrete_strategy;

import com.demo07.model.UserInfo;
import com.demo07.service.UserService;
import com.demo07.strategy.UserLogin;

/**
 * @author canxiusi.yan
 * @description BossUserLogin
 * @date 2022/2/13 16:04
 */
public class BossUserLoginStrategy implements UserLogin {

    @Override
    public UserInfo doLogin(UserInfo userInfo, UserService userService) {
        UserInfo bossUser = userService.doLogin(userInfo);
        bossUser.setName("老板");
        return bossUser;
    }
}

? ? ? ? 顾客登录策略

package com.demo07.strategy.concrete_strategy;

import com.demo07.model.UserInfo;
import com.demo07.service.UserService;
import com.demo07.strategy.UserLogin;

/**
 * 具体策略
 * @author canxiusi.yan
 * @description StoreUserLogin
 * @date 2022/2/13 15:57
 */
public class StoreUserLoginStrategy implements UserLogin {

    @Override
    public UserInfo doLogin(UserInfo userInfo, UserService userService) {
        // 调用service查询数据库
        UserInfo storeUser = userService.doLogin(userInfo);
        storeUser.setName("顾客");
        return storeUser;
    }
}

那么这2个接口在哪里调用呢, 当然不能在controller直接注入, 那样使用策略模式就没有任何意义了

下面根据类图设计环境类

? ? ? ? ?首先是抽象父类, 该类对外暴露用户登录的方法, 包含UserLogin成员变量, 不要把忘了他是谁, 他是之前定义的策略顶级接口

package com.demo07.context;

import com.demo07.model.UserInfo;
import com.demo07.service.UserService;
import com.demo07.strategy.UserLogin;
import lombok.Getter;
import lombok.Setter;

/**
 * 用户登录上下文
 * @author canxiusi.yan
 * @description UserContext
 * @date 2022/2/13 16:09
 */
@Setter
@Getter
public abstract class UserContext {

    protected UserLogin userLogin;

    /**
     * 对外暴露用户登录接口
     * @param userInfo
     * @param userService
     * @return
     */
    public abstract UserInfo doLogin(UserInfo userInfo, UserService userService);
}

? ? ? ? 有了抽象类, 当然不能少了子类, 子类当然就是具体的不用登录类型的环境了, 首先是顾客, 其次是老板, 代码中的注释可以看下

package com.demo07.context;

import com.demo07.model.UserInfo;
import com.demo07.service.UserService;
import com.demo07.strategy.concrete_strategy.StoreUserLoginStrategy;

/**
 * 商店用户登录上下文
 *
 * @author canxiusi.yan
 * @description StoreUserContext
 * @date 2022/2/13 16:10
 */
public class StoreUserContext extends UserContext {

    /**
     * 初始化构造器决定登录上下文
     */
    public StoreUserContext() {
        this.userLogin = new StoreUserLoginStrategy();
    }

    @Override
    public UserInfo doLogin(UserInfo userInfo, UserService userService) {
        // 他会调用策略实现类中的方法
        return userLogin.doLogin(userInfo, userService);
    }
}

package com.demo07.context;

import com.demo07.model.UserInfo;
import com.demo07.service.UserService;
import com.demo07.strategy.concrete_strategy.BossUserLoginStrategy;

/**
 * @author canxiusi.yan
 * @description BossUserContext
 * @date 2022/2/13 16:24
 */
public class BossUserContext extends UserContext {

    public BossUserContext() {
        this.userLogin = new BossUserLoginStrategy();
    }

    @Override
    public UserInfo doLogin(UserInfo userInfo, UserService userService) {
        // 为什么这个上下文类也要单独定义
        // 这登录之前也可以检查用户的账户状态
        // 主要是为了根据业务场景, 登录之前可以在上下文中设置一些该用户登录 独有的 信息
        // 后续增加模板方法模式, 这些验证操作可以写到公共模板方法里
        UserInfo bossUser = userLogin.doLogin(userInfo, userService);
        // 之后也可以设置一些他独有的信息, 比如session, 最后把返回用户信息
        return bossUser;
    }
}

到这里我们知道, 调用关系是上下文实现类调用策略类, 策略类调用server, 之后调用数据库, 那么这个context对象如何获取, 这里我使用了简单工厂模式(他不属于设计模式, 但是可以屏蔽对象的具体实现细节), 感兴趣的可以看下简单工厂模式的设计原理, 我这里直接贴代码

package com.demo07.factory;

import com.demo07.context.UserContext;

/**
 * @author canxiusi.yan
 * @description UserStrategyFactory
 * @date 2022/2/13 16:07
 */
public abstract class UserContextFactory {

    /**
     * 获取用户登录上下文, 可以设计为final, 防止子类覆盖
     * @return 
     */
    public final UserContext getUserContext() {
        UserContext userContext = this.getUserLoginContext();
        return userContext;
    }

    /**
     * 获取用户登录策略
     * @return
     */
    protected abstract UserContext getUserLoginContext();
}

package com.demo07.factory;

import com.demo07.context.StoreUserContext;
import com.demo07.context.UserContext;
import org.springframework.stereotype.Component;

/**
 * @author canxiusi.yan
 * @description UserStrategyFactoryImpl
 * @date 2022/2/13 16:58
 */
@Component
public class StoreUserContextFactory extends UserContextFactory {

    @Override
    public UserContext getUserLoginContext() {
        return new StoreUserContext();
    }
}

package com.demo07.factory;

import com.demo07.context.BossUserContext;
import com.demo07.context.UserContext;
import org.springframework.stereotype.Component;

/**
 * @author canxiusi.yan
 * @description BossUserContextFactory
 * @date 2022/2/13 18:30
 */
@Component
public class BossUserContextFactory extends UserContextFactory {

    @Override
    protected UserContext getUserLoginContext() {
        return new BossUserContext();
    }
}

之后就是在controller 调用了, 直接上代码

package com.demo07.controller;

import com.demo07.context.UserContext;
import com.demo07.factory.StoreUserContextFactory;
import com.demo07.model.UserInfo;
import com.demo07.service.UserService;
import com.demo07.utils.UserContextFactory;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @author canxiusi.yan
 * @description UserController
 * @date 2022/2/13 16:05
 */
@RestController
@RequestMapping("/user")
public class UserController {

    @Resource
    private UserService userService;

    @Resource
    private StoreUserContextFactory store;


    @PostMapping("/store-login")
    public UserInfo doStoreLogin(@RequestBody UserInfo userInfo) {
        // 既然已经区分了不用用户的登录接口, 这里不应该在让页面传递登录type, 而是可以直接用工厂获取登录上下文对象
        return store.getUserLoginContext().doLogin(userInfo, userService);
    }

    @PostMapping("/boss-login")
    public UserInfo doBossLogin(@RequestBody UserInfo userInfo) {
        UserContext boss = UserContextFactory.getLoginType("老板登录");
        UserInfo bossUser = boss.doLogin(userInfo, userService);
        return bossUser;
    }
}

package com.demo07.service;

import com.demo07.model.UserInfo;
import org.springframework.stereotype.Service;

/**
 * @author canxiusi.yan
 * @description UserServiceImpl
 * @date 2022/2/13 16:05
 */
@Service
public class UserServiceImpl implements UserService {

    @Override
    public UserInfo doLogin(UserInfo userInfo) {
        // 这里可以处理公共的登录方法
        return UserInfo.builder().build();
    }
}

postMan测试?