大家平时工作应该都处理过用户登录的需求, 传统的写法是这样的, controller --> server --> mysql
如果出现多种用户登录类型, 那么server层的代码就会变成这样:
@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测试
这样一来, 如果后续增加新的登录方式, 只需要增加新的策略实现类去实现UserLogin, 和上下文类去继承UserContext, 而不用修改原有的代码, 甚至不用关心旧代码是怎么实现的, 很好的遵循了设计原则,
另外代码中有用到接口和抽象类, 其实也是一种设计原则, 针对接口编程, 而不针对实现编程
ps:
我在 处理boss登录的时候, 换了一种方法, 使用了静态工厂, 但是这样页面需要传递登录类型, 而且后续增加登录类型需要修改map, 不知道这2种获取context的方法哪种更好点, 期待大神交流!
package com.demo07.utils;
import com.demo07.context.BossUserContext;
import com.demo07.context.StoreUserContext;
import com.demo07.context.UserContext;
import org.apache.commons.lang3.StringUtils;
import java.util.HashMap;
import java.util.Map;
/**
* @author canxiusi.yan
* @description UserContextFactory
* @date 2022/2/13 20:11
*/
public class UserContextFactory {
private static final Map<UserLoginTypeEnum, UserContext> contextMap = new HashMap<>();
static {
contextMap.put(UserLoginTypeEnum.STORE_LOGIN, new StoreUserContext());
contextMap.put(UserLoginTypeEnum.BOSS_LOGIN, new BossUserContext());
}
/**
* 获取登录类型
* @param type
* @return
*/
public static UserContext getLoginType(String type) {
if (!contextMap.containsKey(UserLoginTypeEnum.getLoginType(type))) {
throw new IllegalArgumentException("登录类型不存在");
} else if (StringUtils.isBlank(type)) {
throw new IllegalArgumentException("登录类型不存在");
} else {
return contextMap.get(UserLoginTypeEnum.getLoginType(type));
}
}
}
