参考资料地址1：https://pan.baidu.com/s/12w0_TT26aywnoIcogPg8Uw 提取码: uzf4 参考资料地址2：https://share.weiyun.com/SNltUNLW 密码：zi3dc7
什么是网关？ 网关(Gateway)又称网间连接器、协议转换器。网关在网络层以上实现网络互连，是复杂的网络互连设备，仅用于两个高层协议不同的网络互连。
网关这个东西听起来好像是很底层的一个组件，大家可能会觉得很复杂，实际上并没有。我们就花几行代码，就可以实现一个非常简单的 HTTP 网关的逻辑。
框架页面内容区的排版布局如下。首先是一个DIV充当容器，然后里面顶部位置是标签栏，下边是内容面板。虽然视图层需要我们写的标签并不多。但是为了让内容区适配浏览器的高度，我们要写很多TS代码。HelloWorld
你好世界
仔细观察不难发现，上面的截图中标签盖住了卡片控件。为了解决这个问题，我们可以让
HelloWorld
你好世界
/*
- 载入框架页面就立即执行routeHandle()函数，把当前路由加载页面对应的Tab控件选中
- 例如直接访问http://localhost:7600/mis/role页面，需要让框架页面创建Tab控件，并且选中该Tab
- / routeHandle(route)
/*
- 框架页面的路由标签每次切换引用的页面，就调用routeHandle()，
- 判断一下是创建新的Tab控件，还是切换到现有的Tab控件
- /
watch(
() => router,
() => {
}, { immediate: true, deep: true } ); MIS端框架页面的视图层代码我们要加以修改，比如说routeHandle(route);标签的:class属性要根据isTab切换不同的样式。还有就是给 设置上v-if判断，如果isTab为true就用Tab控件引用Vue压面；反之就用 控件引用Vue页面。 function routeHandle(route) { //判断是否要创建Tab控件 if (route.meta.isTab) {
} else {/* 创建Tab控件之前，先判断mainTabs[]数组中是否存在该Vue页面的Tab控件。 * 比如我们要访问角色管理页面，程序先要判断是否存在角色管理页面的Tab控件。 * 如果不存在就创建Tab控件；如果存在就不创建新的Tab控件，直接切换到现有的Tab控件 */ let tab = siteContent.mainTabs.filter(item => item.name === route.name)[0]; if (tab == null) { tab = { title: route.meta.title, name: route.name }; siteContent.mainTabs.push(tab); } //选中某个Tab控件 siteContent.mainTabsActiveName = tab.name; //选中某个菜单项 siteContent.menuActiveName = tab.name;
} } 这些服务它的资源都会过我们的网关来进行鉴权，你可以在云开发体系下的控制台上，看到我们 URL 的入口，实际上这些 URL 它的背后就是我们的网关。 package com.example.his.api.config.sa_token;siteContent.mainTabs = [] //取消选中某个Tab控件 siteContent.mainTabsActiveName = ""; //选中某个菜单项 siteContent.menuActiveName = "Home";
import java.util.List;
import org.springframework.stereotype.Component;
import cn.dev33.satoken.SaManager; import cn.dev33.satoken.fun.SaFunction; import cn.dev33.satoken.listener.SaTokenEventCenter; import cn.dev33.satoken.session.SaSession; import cn.dev33.satoken.stp.SaLoginModel; import cn.dev33.satoken.stp.SaTokenInfo; import cn.dev33.satoken.stp.StpLogic;
/**
Sa-Token 权限认证工具类 （业务端使用）
/ @Component public class StpCustomerUtil {
private StpCustomerUtil() { }
/**
账号类型标识
/ public static final String TYPE = "customer";
/**
底层的 StpLogic 对象
/ public static StpLogic stpLogic = new StpLogic(TYPE);
/**
获取当前 StpLogic 的账号类型
@return See Note
/ public static String getLoginType() { return stpLogic.getLoginType(); }
/**
重置 StpLogic 对象
1、更改此账户的 StpLogic 对象
2、put 到全局 StpLogic 集合中
3、发送日志@param newStpLogic /
/ public static void setStpLogic(StpLogic newStpLogic) { // 重置此账户的 StpLogic 对象 stpLogic = newStpLogic;
// 添加到全局 StpLogic 集合中 // 以便可以通过 SaManager.getStpLogic(type) 的方式来全局获取到这个 StpLogic SaManager.putStpLogic(newStpLogic);
// $$ 全局事件 SaTokenEventCenter.doSetStpLogic(stpLogic); }
/**
获取 StpLogic 对象
@return /
/ public static StpLogic getStpLogic() { return stpLogic; }
// ------------------- 获取token 相关 -------------------
/**
* 返回token名称
*
* @return 此StpLogic的token名称
*/
public static String getTokenName() {
return stpLogic.getTokenName();
}
/**
* 在当前会话写入当前TokenValue
*
* @param tokenValue token值
*/
public static void setTokenValue(String tokenValue) {
stpLogic.setTokenValue(tokenValue);
}
/**
* 在当前会话写入当前TokenValue
*
* @param tokenValue token值
* @param cookieTimeout Cookie存活时间(秒)
*/
public static void setTokenValue(String tokenValue, int cookieTimeout) {
stpLogic.setTokenValue(tokenValue, cookieTimeout);
}
/**
* 获取当前TokenValue
*
* @return 当前tokenValue
*/
public static String getTokenValue() {
return stpLogic.getTokenValue();
}
/**
* 获取当前TokenValue (不裁剪前缀)
*
* @return /
*/
public static String getTokenValueNotCut() {
return stpLogic.getTokenValueNotCut();
}
/**
* 获取当前会话的Token信息
*
* @return token信息
*/
public static SaTokenInfo getTokenInfo() {
return stpLogic.getTokenInfo();
}
// ------------------- 登录相关操作 -------------------
// --- 登录
/**
* 会话登录
*
* @param id 账号id，建议的类型：（long | int | String）
*/
public static void login(Object id) {
stpLogic.login(id);
}
/**
* 会话登录，并指定登录设备类型
*
* @param id 账号id，建议的类型：（long | int | String）
* @param device 设备类型
*/
public static void login(Object id, String device) {
stpLogic.login(id, device);
}
/**
* 会话登录，并指定是否 [记住我]
*
* @param id 账号id，建议的类型：（long | int | String）
* @param isLastingCookie 是否为持久Cookie
*/
public static void login(Object id, boolean isLastingCookie) {
stpLogic.login(id, isLastingCookie);
}
/**
* 会话登录，并指定此次登录token的有效期, 单位:秒
*
* @param id 账号id，建议的类型：（long | int | String）
* @param timeout 此次登录token的有效期, 单位:秒 （如未指定，自动取全局配置的timeout值）
*/
public static void login(Object id, long timeout) {
stpLogic.login(id, timeout);
}
/**
* 会话登录，并指定所有登录参数Model
*
* @param id 登录id，建议的类型：（long | int | String）
* @param loginModel 此次登录的参数Model
*/
public static void login(Object id, SaLoginModel loginModel) {
stpLogic.login(id, loginModel);
}
/**
* 创建指定账号id的登录会话
*
* @param id 登录id，建议的类型：（long | int | String）
* @return 返回会话令牌
*/
public static String createLoginSession(Object id) {
return stpLogic.createLoginSession(id);
}
/**
* 创建指定账号id的登录会话
*
* @param id 登录id，建议的类型：（long | int | String）
* @param loginModel 此次登录的参数Model
* @return 返回会话令牌
*/
public static String createLoginSession(Object id, SaLoginModel loginModel) {
return stpLogic.createLoginSession(id, loginModel);
}
// --- 注销
/**
* 会话注销
*/
public static void logout() {
stpLogic.logout();
}
/**
* 会话注销，根据账号id
*
* @param loginId 账号id
*/
public static void logout(Object loginId) {
stpLogic.logout(loginId);
}
/**
* 会话注销，根据账号id 和 设备类型
*
* @param loginId 账号id
* @param device 设备类型 (填null代表注销所有设备类型)
*/
public static void logout(Object loginId, String device) {
stpLogic.logout(loginId, device);
}
/**
* 会话注销，根据指定 Token
*
* @param tokenValue 指定token
*/
public static void logoutByTokenValue(String tokenValue) {
stpLogic.logoutByTokenValue(tokenValue);
}
/**
* 踢人下线，根据账号id
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p>
*
* @param loginId 账号id
*/
public static void kickout(Object loginId) {
stpLogic.kickout(loginId);
}
/**
* 踢人下线，根据账号id 和 设备类型
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p>
*
* @param loginId 账号id
* @param device 设备类型 (填null代表踢出所有设备类型)
*/
public static void kickout(Object loginId, String device) {
stpLogic.kickout(loginId, device);
}
/**
* 踢人下线，根据指定 Token
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p>
*
* @param tokenValue 指定token
*/
public static void kickoutByTokenValue(String tokenValue) {
stpLogic.kickoutByTokenValue(tokenValue);
}
/**
* 顶人下线，根据账号id 和 设备类型
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-4 </p>
*
* @param loginId 账号id
* @param device 设备类型 (填null代表顶替所有设备类型)
*/
public static void replaced(Object loginId, String device) {
stpLogic.replaced(loginId, device);
}
// 查询相关
/**
* 当前会话是否已经登录
*
* @return 是否已登录
*/
public static boolean isLogin() {
return stpLogic.isLogin();
}
/**
* 检验当前会话是否已经登录，如未登录，则抛出异常
*/
public static void checkLogin() {
stpLogic.checkLogin();
}
/**
* 获取当前会话账号id, 如果未登录，则抛出异常
*
* @return 账号id
*/
public static Object getLoginId() {
return stpLogic.getLoginId();
}
/**
* 获取当前会话账号id, 如果未登录，则返回默认值
*
* @param <T> 返回类型
* @param defaultValue 默认值
* @return 登录id
*/
public static <T> T getLoginId(T defaultValue) {
return stpLogic.getLoginId(defaultValue);
}
/**
* 获取当前会话账号id, 如果未登录，则返回null
*
* @return 账号id
*/
public static Object getLoginIdDefaultNull() {
return stpLogic.getLoginIdDefaultNull();
}
/**
* 获取当前会话账号id, 并转换为String类型
*
* @return 账号id
*/
public static String getLoginIdAsString() {
return stpLogic.getLoginIdAsString();
}
/**
* 获取当前会话账号id, 并转换为int类型
*
* @return 账号id
*/
public static int getLoginIdAsInt() {
return stpLogic.getLoginIdAsInt();
}
/**
* 获取当前会话账号id, 并转换为long类型
*
* @return 账号id
*/
public static long getLoginIdAsLong() {
return stpLogic.getLoginIdAsLong();
}
/**
* 获取指定Token对应的账号id，如果未登录，则返回 null
*
* @param tokenValue token
* @return 账号id
*/
public static Object getLoginIdByToken(String tokenValue) {
return stpLogic.getLoginIdByToken(tokenValue);
}
/**
* 获取当前 Token 的扩展信息（此函数只在jwt模式下生效）
*
* @param key 键值
* @return 对应的扩展数据
*/
public static Object getExtra(String key) {
return stpLogic.getExtra(key);
}
/**
* 获取指定 Token 的扩展信息（此函数只在jwt模式下生效）
*
* @param tokenValue 指定的 Token 值
* @param key 键值
* @return 对应的扩展数据
*/
public static Object getExtra(String tokenValue, String key) {
return stpLogic.getExtra(tokenValue, key);
}
// ------------------- User-Session 相关 -------------------
/**
* 获取指定账号id的Session, 如果Session尚未创建，isCreate=是否新建并返回
*
* @param loginId 账号id
* @param isCreate 是否新建
* @return Session对象
*/
public static SaSession getSessionByLoginId(Object loginId, boolean isCreate) {
return stpLogic.getSessionByLoginId(loginId, isCreate);
}
/**
* 获取指定key的Session, 如果Session尚未创建，则返回null
*
* @param sessionId SessionId
* @return Session对象
*/
public static SaSession getSessionBySessionId(String sessionId) {
return stpLogic.getSessionBySessionId(sessionId);
}
/**
* 获取指定账号id的Session，如果Session尚未创建，则新建并返回
*
* @param loginId 账号id
* @return Session对象
*/
public static SaSession getSessionByLoginId(Object loginId) {
return stpLogic.getSessionByLoginId(loginId);
}
/**
* 获取当前会话的Session, 如果Session尚未创建，isCreate=是否新建并返回
*
* @param isCreate 是否新建
* @return Session对象
*/
public static SaSession getSession(boolean isCreate) {
return stpLogic.getSession(isCreate);
}
/**
* 获取当前会话的Session，如果Session尚未创建，则新建并返回
*
* @return Session对象
*/
public static SaSession getSession() {
return stpLogic.getSession();
}
// ------------------- Token-Session 相关 -------------------
/**
* 获取指定Token-Session，如果Session尚未创建，则新建并返回
*
* @param tokenValue Token值
* @return Session对象
*/
public static SaSession getTokenSessionByToken(String tokenValue) {
return stpLogic.getTokenSessionByToken(tokenValue);
}
/**
* 获取当前Token-Session，如果Session尚未创建，则新建并返回
*
* @return Session对象
*/
public static SaSession getTokenSession() {
return stpLogic.getTokenSession();
}
/**
* 获取当前匿名 Token-Session （可在未登录情况下使用的Token-Session）
*
* @return Token-Session 对象
*/
public static SaSession getAnonTokenSession() {
return stpLogic.getAnonTokenSession();
}
// ------------------- [临时有效期] 验证相关 -------------------
/**
* 检查当前token 是否已经[临时过期]，如果已经过期则抛出异常
*/
public static void checkActivityTimeout() {
stpLogic.checkActivityTimeout();
}
/**
* 续签当前token：(将 [最后操作时间] 更新为当前时间戳)
* <h1>请注意: 即使token已经 [临时过期] 也可续签成功，
* 如果此场景下需要提示续签失败，可在此之前调用 checkActivityTimeout() 强制检查是否过期即可 </h1>
*/
public static void updateLastActivityToNow() {
stpLogic.updateLastActivityToNow();
}
// ------------------- 过期时间相关 -------------------
/**
* 获取当前登录者的 token 剩余有效时间 (单位: 秒)
*
* @return token剩余有效时间
*/
public static long getTokenTimeout() {
return stpLogic.getTokenTimeout();
}
/**
* 获取当前登录者的 User-Session 剩余有效时间 (单位: 秒)
*
* @return token剩余有效时间
*/
public static long getSessionTimeout() {
return stpLogic.getSessionTimeout();
}
/**
* 获取当前 Token-Session 剩余有效时间 (单位: 秒)
*
* @return token剩余有效时间
*/
public static long getTokenSessionTimeout() {
return stpLogic.getTokenSessionTimeout();
}
/**
* 获取当前 token [临时过期] 剩余有效时间 (单位: 秒)
*
* @return token [临时过期] 剩余有效时间
*/
public static long getTokenActivityTimeout() {
return stpLogic.getTokenActivityTimeout();
}
/**
* 对当前 Token 的 timeout 值进行续期
*
* @param timeout 要修改成为的有效时间 (单位: 秒)
*/
public static void renewTimeout(long timeout) {
stpLogic.renewTimeout(timeout);
}
/**
* 对指定 Token 的 timeout 值进行续期
*
* @param tokenValue 指定token
* @param timeout 要修改成为的有效时间 (单位: 秒)
*/
public static void renewTimeout(String tokenValue, long timeout) {
stpLogic.renewTimeout(tokenValue, timeout);
}
// ------------------- 角色验证操作 -------------------
/**
* 获取：当前账号的角色集合
*
* @return /
*/
public static List<String> getRoleList() {
return stpLogic.getRoleList();
}
/**
* 获取：指定账号的角色集合
*
* @param loginId 指定账号id
* @return /
*/
public static List<String> getRoleList(Object loginId) {
return stpLogic.getRoleList(loginId);
}
/**
* 判断：当前账号是否拥有指定角色, 返回true或false
*
* @param role 角色标识
* @return 是否含有指定角色标识
*/
public static boolean hasRole(String role) {
return stpLogic.hasRole(role);
}
/**
* 判断：指定账号是否含有指定角色标识, 返回true或false
*
* @param loginId 账号id
* @param role 角色标识
* @return 是否含有指定角色标识
*/
public static boolean hasRole(Object loginId, String role) {
return stpLogic.hasRole(loginId, role);
}
/**
* 判断：当前账号是否含有指定角色标识 [指定多个，必须全部验证通过]
*
* @param roleArray 角色标识数组
* @return true或false
*/
public static boolean hasRoleAnd(String... roleArray) {
return stpLogic.hasRoleAnd(roleArray);
}
/**
* 判断：当前账号是否含有指定角色标识 [指定多个，只要其一验证通过即可]
*
* @param roleArray 角色标识数组
* @return true或false
*/
public static boolean hasRoleOr(String... roleArray) {
return stpLogic.hasRoleOr(roleArray);
}
/**
* 校验：当前账号是否含有指定角色标识, 如果验证未通过，则抛出异常: NotRoleException
*
* @param role 角色标识
*/
public static void checkRole(String role) {
stpLogic.checkRole(role);
}
/**
* 校验：当前账号是否含有指定角色标识 [指定多个，必须全部验证通过]
*
* @param roleArray 角色标识数组
*/
public static void checkRoleAnd(String... roleArray) {
stpLogic.checkRoleAnd(roleArray);
}
/**
* 校验：当前账号是否含有指定角色标识 [指定多个，只要其一验证通过即可]
*
* @param roleArray 角色标识数组
*/
public static void checkRoleOr(String... roleArray) {
stpLogic.checkRoleOr(roleArray);
}
// ------------------- 权限验证操作 -------------------
/**
* 获取：当前账号的权限码集合
*
* @return /
*/
public static List<String> getPermissionList() {
return stpLogic.getPermissionList();
}
/**
* 获取：指定账号的权限码集合
*
* @param loginId 指定账号id
* @return /
*/
public static List<String> getPermissionList(Object loginId) {
return stpLogic.getPermissionList(loginId);
}
/**
* 判断：当前账号是否含有指定权限, 返回true或false
*
* @param permission 权限码
* @return 是否含有指定权限
*/
public static boolean hasPermission(String permission) {
return stpLogic.hasPermission(permission);
}
/**
* 判断：指定账号id是否含有指定权限, 返回true或false
*
* @param loginId 账号id
* @param permission 权限码
* @return 是否含有指定权限
*/
public static boolean hasPermission(Object loginId, String permission) {
return stpLogic.hasPermission(loginId, permission);
}
/**
* 判断：当前账号是否含有指定权限, [指定多个，必须全部具有]
*
* @param permissionArray 权限码数组
* @return true 或 false
*/
public static boolean hasPermissionAnd(String... permissionArray) {
return stpLogic.hasPermissionAnd(permissionArray);
}
/**
* 判断：当前账号是否含有指定权限 [指定多个，只要其一验证通过即可]
*
* @param permissionArray 权限码数组
* @return true 或 false
*/
public static boolean hasPermissionOr(String... permissionArray) {
return stpLogic.hasPermissionOr(permissionArray);
}
/**
* 校验：当前账号是否含有指定权限, 如果验证未通过，则抛出异常: NotPermissionException
*
* @param permission 权限码
*/
public static void checkPermission(String permission) {
stpLogic.checkPermission(permission);
}
/**
* 校验：当前账号是否含有指定权限 [指定多个，必须全部验证通过]
*
* @param permissionArray 权限码数组
*/
public static void checkPermissionAnd(String... permissionArray) {
stpLogic.checkPermissionAnd(permissionArray);
}
/**
* 校验：当前账号是否含有指定权限 [指定多个，只要其一验证通过即可]
*
* @param permissionArray 权限码数组
*/
public static void checkPermissionOr(String... permissionArray) {
stpLogic.checkPermissionOr(permissionArray);
}
// ------------------- id 反查token 相关操作 -------------------
/**
* 获取指定账号id的tokenValue
* <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
* 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
*
* @param loginId 账号id
* @return token值
*/
public static String getTokenValueByLoginId(Object loginId) {
return stpLogic.getTokenValueByLoginId(loginId);
}
/**
* 获取指定账号id指定设备类型端的tokenValue
* <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
* 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
*
* @param loginId 账号id
* @param device 设备类型
* @return token值
*/
public static String getTokenValueByLoginId(Object loginId, String device) {
return stpLogic.getTokenValueByLoginId(loginId, device);
}
/**
* 获取指定账号id的tokenValue集合
*
* @param loginId 账号id
* @return 此loginId的所有相关token
*/
public static List<String> getTokenValueListByLoginId(Object loginId) {
return stpLogic.getTokenValueListByLoginId(loginId);
}
/**
* 获取指定账号id指定设备类型端的tokenValue 集合
*
* @param loginId 账号id
* @param device 设备类型
* @return 此loginId的所有相关token
*/
public static List<String> getTokenValueListByLoginId(Object loginId, String device) {
return stpLogic.getTokenValueListByLoginId(loginId, device);
}
/**
* 返回当前会话的登录设备类型
*
* @return 当前令牌的登录设备类型
*/
public static String getLoginDevice() {
return stpLogic.getLoginDevice();
}
