cas shiro 前后端分离 登录_apache shiro安全框架 登录，记住我，前后台分离

最新推荐文章于 2022-08-27 23:55:56 发布
最新推荐文章于 2022-08-27 23:55:56 发布
阅读量174 收藏
点赞数
文章标签： cas shiro 前后端分离 登录
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39616416/article/details/111520691
版权

最近做的项目，由于客户需求，登录的用户信息必须经过身份验证，自己研究了一下，写个博客与大家分享一下我的心得。本次项目用到了shiro的登录，记住我，前后台分离功能。这里只做了登录认证，没有权限管理。

项目构建：

在pom.xml文件：

org.apache.shiro

shiro-spring

1.2.3

org.apache.shiro

shiro-web

1.2.3

org.apache.shiro

shiro-ehcache

1.2.3

org.apache.shiro

shiro-cas

1.2.3

在 web.xml文件里：

contextConfigLocation

classpath:applicationContext.xml,classpath:shiro/spring-context-shiro.xml

shiroFilter

org.springframework.web.filter.DelegatingFilterProxy

shiroFilter

/*

shrio配置文件  spring-context-shiro：<?xml version="1.0" encoding="UTF-8"?>

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="

http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd"

default-lazy-init="true">

Shiro Configuration

/userMember/login = authc

/logout = logout

/apply/** = user

/alter/** = user

class="包路径.FormAuthenticationFilter">

class="包路径.SystemAuthorizingRealm" />

class="包路径.UserAuthorizingRealm" />

class="包路径.SystemAuthorizingRealm">

class="包路径.UserAuthorizingRealm">

class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">

class="org.apache.shiro.web.mgt.CookieRememberMeManager">

value="#{T(org.apache.shiro.codec.Base64).decode('4AvVhmFLUs0KTA3Kprsdag==')}"/>

class="org.apache.shiro.session.mgt.eis.EnterpriseCacheSessionDAO">

在这里有一个 logintype,这个变量是我，是我自定义的，本身的shrio是没有，是做前后台登录的标志位。

FormAuthenticationFilter 类：package 包路径;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang.StringUtils;

import org.apache.shiro.authc.AuthenticationToken;

import org.apache.shiro.web.util.WebUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class FormAuthenticationFilter extends org.apache.shiro.web.filter.authc.FormAuthenticationFilter {

/**

* logger日志

*/

protected Logger logger = LoggerFactory.getLogger(getClass());

/**

* 序列化id

*/

private static final long serialVersionUID = -2271706136984114038L;

/**

* 登录类型

*/

public static final String DEFAULT_LOGINTYPE_PARAM = "logintype";

private String logintypeParam = DEFAULT_LOGINTYPE_PARAM;

protected AuthenticationToken createToken(ServletRequest request, ServletResponse response) {

String username = getUsername(request);

String password = getPassword(request);

String logintype = getLogintype(request);

logger.debug("createToken username:{},password:{},loginType:{"+logintype+"} ...",username,password);

if (password==null){

password = "";

}

String host = getRemoteAddr((HttpServletRequest)request);

boolean rememberMe = isRememberMe(request);

return new UsernamePasswordToken(username, password.toCharArray(), rememberMe, host, logintype);

}

public void setLogintypeParam(String logintypeParam) {

this.logintypeParam = logintypeParam;

}

public String getLogintypeParam() {

return logintypeParam;

}

protected String getLogintype(ServletRequest request) {

return WebUtils.getCleanParam(request, getLogintypeParam());

}

/**

* 获得用户远程地址

*/

public static String getRemoteAddr(HttpServletRequest request){

String remoteAddr = request.getHeader("X-Real-IP");

if (StringUtils.isNotBlank(remoteAddr)) {

remoteAddr = request.getHeader("X-Forwarded-For");

}else if (StringUtils.isNotBlank(remoteAddr)) {

remoteAddr = request.getHeader("Proxy-Client-IP");

}else if (StringUtils.isNotBlank(remoteAddr)) {

remoteAddr = request.getHeader("WL-Proxy-Client-IP");

}

return remoteAddr != null ? remoteAddr : request.getRemoteAddr();

}

}

UsernamePasswordToken 类：package 包路径;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class UsernamePasswordToken extends org.apache.shiro.authc.UsernamePasswordToken {

/**

* logger日志

*/

protected Logger logger = LoggerFactory.getLogger(getClass());

/**

* 序列化id

*/

private static final long serialVersionUID = -2271706136984114038L;

/**

* 登录类型

*/

private String logintype ;

public String getLogintype() {

return logintype;

}

public void setLogintype(String logintype) {

this.logintype = logintype;

}

public UsernamePasswordToken (String username, char[] password,

boolean rememberMe, String host, String logintype) {

super(username, password, rememberMe, host);

this.logintype = logintype;

}

}

DefautModularRealm 类，多个realm集中管理：package 包路径;

import java.util.Collection;

import java.util.Map;

import org.apache.shiro.ShiroException;

import org.apache.shiro.authc.AuthenticationException;

import org.apache.shiro.authc.AuthenticationInfo;

import org.apache.shiro.authc.AuthenticationToken;

import org.apache.shiro.realm.Realm;

import org.apache.shiro.util.CollectionUtils;

import 系统文件路径.SysConstant;

public class DefautModularRealm extends org.apache.shiro.authc.pam.ModularRealmAuthenticator{

private Map definedRealms;

/**

* 多个realm实现

*/

@Override

protected AuthenticationInfo doMultiRealmAuthentication(Collection realms, AuthenticationToken token) {

return super.doMultiRealmAuthentication(realms, token);

}

/**

* 调用单个realm执行操作

*/

@Override

protected AuthenticationInfo doSingleRealmAuthentication(Realm realm,AuthenticationToken token) {

// 如果该realms不支持(不能验证)当前token

if (!realm.supports(token)) {

throw new ShiroException("token错误!");

}

AuthenticationInfo info = null;

try {

info = realm.getAuthenticationInfo(token);

if (info == null) {

throw new ShiroException("token不存在!");

}

} catch (Exception e) {

throw new ShiroException("用户名或者密码错误!");

}

return info;

}

/**

* 判断登录类型执行操作

*/

@Override

protected AuthenticationInfo doAuthenticate(AuthenticationToken authenticationToken)throws AuthenticationException {

this.assertRealmsConfigured();

Realm realm = null;

UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;

//判断是否是后台用户

if (token.getLogintype().equals(SysConstant.FRONT_LOGIN)) {

realm = (Realm) this.definedRealms.get("systemAuthorizingRealm");

}

else if (token.getLogintype().equals(SysConstant.ADMIN_LOGIN)){

realm = (Realm) this.definedRealms.get("userAuthorizingRealm");

}

return this.doSingleRealmAuthentication(realm, authenticationToken);

}

/**

* 判断realm是否为空

*/

@Override

protected void assertRealmsConfigured() throws IllegalStateException {

this.definedRealms = this.getDefinedRealms();

if (CollectionUtils.isEmpty(this.definedRealms)) {

throw new ShiroException("值传递错误!");

}

}

public Map getDefinedRealms() {

return this.definedRealms;

}

public void setDefinedRealms(Map definedRealms) {

this.definedRealms = definedRealms;

}

}

SystemAuthorizingRealm  后台认证realmpackage 包路径;

import javax.annotation.PostConstruct;

import javax.annotation.Resource;

import org.apache.shiro.authc.AuthenticationException;

import org.apache.shiro.authc.AuthenticationInfo;

import org.apache.shiro.authc.AuthenticationToken;

import org.apache.shiro.authc.DisabledAccountException;

import org.apache.shiro.authc.SimpleAuthenticationInfo;

import org.apache.shiro.authc.UnknownAccountException;

import org.apache.shiro.authc.credential.HashedCredentialsMatcher;

import org.apache.shiro.authz.AuthorizationInfo;

import org.apache.shiro.authz.SimpleAuthorizationInfo;

import org.apache.shiro.realm.AuthorizingRealm;

import org.apache.shiro.subject.PrincipalCollection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.stereotype.Service;

import 系统文件路径.ENUM_SYSTEM;

import 系统文件路径.重写后台用户实体类.Principal;

import 系统文件路径.后台用户实体类.UserMemberDO;

import 系统文件路径.后台用户服务.UserMemberService;

@Service

public class SystemAuthorizingRealm extends AuthorizingRealm {

/**

* logger日志

*/

protected Logger logger = LoggerFactory.getLogger(getClass());

/**

* 序列化id

*/

private static final long serialVersionUID = -2271706136984114038L;

/**

* userMemberServicef服务

*/

@Resource

private UserMemberService userMemberService;

/**

* 授权

*/

@Override

protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();

info.addStringPermission("sys:manager");

info.addStringPermission("user");

System.out.println("开始授权");

return info;

}

/**

* 认证

*/

@Override

protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken)

throws AuthenticationException {

UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;

UserMemberDO user = userMemberService.getByName(token.getUsername());

if (user == null ) {

throw new UnknownAccountException("用户名不存在");

} else if (ENUM_SYSTEM.ACCOUNT_VERIFICATION_NO.getKey().equals(user.getStatus())) {

throw new DisabledAccountException("账户未审核通过！");

}

SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(new Principal(user), user.getPassword(), null,

getName());

return authenticationInfo;

}

/**

* 设定密码校验的MD5算法与迭代次数

*/

@PostConstruct

public void initCredentialsMatcher() {

HashedCredentialsMatcher matcher = new HashedCredentialsMatcher("MD5");

setCredentialsMatcher(matcher);

}

@Override

protected void clearCachedAuthorizationInfo(PrincipalCollection principals) {

super.clearCachedAuthorizationInfo(principals);

}

@Override

protected void clearCachedAuthenticationInfo(PrincipalCollection principals) {

super.clearCachedAuthenticationInfo(principals);

}

@Override

protected void clearCache(PrincipalCollection principals) {

super.clearCache(principals);

}

public void clearAllCachedAuthorizationInfo() {

getAuthorizationCache().clear();

}

public void clearAllCachedAuthenticationInfo() {

getAuthenticationCache().clear();

}

public void clearAllCache() {

clearAllCachedAuthorizationInfo();

clearAllCachedAuthenticationInfo();

}

}

UserAuthorizingRealm 前台用户认证realmpackage 包路径.shiro;

import javax.annotation.PostConstruct;

import javax.annotation.Resource;

import org.apache.shiro.authc.AuthenticationException;

import org.apache.shiro.authc.AuthenticationInfo;

import org.apache.shiro.authc.AuthenticationToken;

import org.apache.shiro.authc.DisabledAccountException;

import org.apache.shiro.authc.SimpleAuthenticationInfo;

import org.apache.shiro.authc.UnknownAccountException;

import org.apache.shiro.authc.credential.HashedCredentialsMatcher;

import org.apache.shiro.authz.AuthorizationInfo;

import org.apache.shiro.authz.SimpleAuthorizationInfo;

import org.apache.shiro.realm.AuthorizingRealm;

import org.apache.shiro.subject.PrincipalCollection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.stereotype.Service;

import 系统路径.ENUM_SYSTEM;

import 系统路径.重写前台用户实体类.user.Principal;

import 系统路径.前台用户实体类.user.UserDO;

import 系统路径.前台用户服务.user.UserService;

@Service

public class UserAuthorizingRealm extends AuthorizingRealm {

/**

* logger日志

*/

protected Logger logger = LoggerFactory.getLogger(getClass());

/**

* 序列化id

*/

private static final long serialVersionUID = -2271706136984114038L;

/**

* userMemberServicef服务

*/

@Resource

private UserService userService;

/**

* 授权

*/

@Override

protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();

info.addStringPermission("sys:manager");

info.addStringPermission("user");

System.out.println("开始授权");

return info;

}

/**

* 认证

*/

@Override

protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken)

throws AuthenticationException {

UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;

System.out.println(token.getUsername());

UserDO user = userService.getByName(token.getUsername());

if (user == null ) {

throw new UnknownAccountException("用户名不存在");

}

SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(new Principal(user), user.getPassword(), null,

getName());

return authenticationInfo;

}

/**

* 设定密码校验的MD5算法与迭代次数

*/

@PostConstruct

public void initCredentialsMatcher() {

HashedCredentialsMatcher matcher = new HashedCredentialsMatcher("MD5");

setCredentialsMatcher(matcher);

}

@Override

protected void clearCachedAuthorizationInfo(PrincipalCollection principals) {

super.clearCachedAuthorizationInfo(principals);

}

@Override

protected void clearCachedAuthenticationInfo(PrincipalCollection principals) {

super.clearCachedAuthenticationInfo(principals);

}

@Override

protected void clearCache(PrincipalCollection principals) {

super.clearCache(principals);

}

public void clearAllCachedAuthorizationInfo() {

getAuthorizationCache().clear();

}

public void clearAllCachedAuthenticationInfo() {

getAuthenticationCache().clear();

}

public void clearAllCache() {

clearAllCachedAuthorizationInfo();

clearAllCachedAuthenticationInfo();

}

}

在这里有一个这样的一个类Principal这个类的作用主要是在用户登录的时候shiro保存登录信息，包括id ,姓名，密码，状态。等等。可以自定义。在JSP标签里的输出对象，在下面有讲。

前台登录controller：package 系统路径.controller.usermember;

import org.apache.commons.lang.StringUtils;

import org.apache.shiro.SecurityUtils;

import org.apache.shiro.authc.DisabledAccountException;

import org.apache.shiro.authc.IncorrectCredentialsException;

import org.apache.shiro.authc.UnknownAccountException;

import org.apache.shiro.subject.Subject;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;

import org.springframework.ui.ModelMap;

import org.springframework.web.bind.annotation.ModelAttribute;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.ResponseBody;

import com.alibaba.fastjson.JSON;

import 系统路径.前台用户实体类.Principal;

import java.io.IOException;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Random;

import javax.annotation.Resource;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

@Controller

@RequestMapping("userMember")

public class UserMemberController extends BaseController {

/**

* logger日志

*/

protected Logger logger = LoggerFactory.getLogger(getClass());

/**

* 序列化id

*/

private static final long serialVersionUID = -2271706136984114038L;

/**

* 登录

* @param request 请求

* @param response 响应

* @param member 前台用户对象

* @param model 模板

* @return String 页面

*/

@RequestMapping(value = "/login")

public String login(HttpServletRequest request, HttpServletResponse response,

@ModelAttribute("member") UserMemberDO member, ModelMap model) {

logger.info("login...");

Subject subject = SecurityUtils.getSubject();

Principal principal = (Principal) subject.getPrincipal();

// 如果已经登录，则跳转到管理首页

if (principal != null) {

return "redirect:/home/forward"; // 首页

}

String exceptionClassName = (String) request.getAttribute("shiroLoginFailure");

String errorMsg = null;

if (UnknownAccountException.class.getName().equals(exceptionClassName)) {

logger.info("该用户名不存在");

errorMsg = "该用户名不存在";

} else if (IncorrectCredentialsException.class.getName().equals(exceptionClassName)) {

logger.info("密码错误");

errorMsg = "密码错误";

} else if (DisabledAccountException.class.getName().equals(exceptionClassName)) {

logger.info("该账号审核未通过");

errorMsg = "该账号审核未通过";

} else if (exceptionClassName != null) {

logger.info("登录错误" + exceptionClassName);

errorMsg = "登录错误";

}

model.addAttribute("errorMsg", errorMsg);

return PAGE_LOGIN;

}

}

这里我只写出前台登录的controller,后台的登录controller一样就不贴出了。

在JSP页面：

pageEncoding="UTF-8"%>

登录

登录成功以后，如何显示的登录者的用户名。在这里shrio有自己的页面标签：

首先导入 标签：

登录|

注册

这里详细的就不贴出了，也就不详细说明了。只是告诉大家，有这样一个途径，就不用费尽心思的还要把信息封装到session 里面了。一开始，我不知道有这样的途径，所以，把信息封装到了session里面了，这真的是多此一举。

weixin_39616416
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java web网站中使用shiro实现前后台登录功能
三郎的博客
03-29 1万+
年前公司网站需要重新开发一个新版本,在架构设计上废了一些劲,我项目架构大概是这样:Spring作为容器,Mybatis做数据持久层,SpringMVC做控制层,Shiro做为安全框架,页面使用tomdjs引擎,大概是这样,由于是功能型网站,需要有前后台登录,后台需要审核以及数据统计和分析等等,所以涉及到了两端登录,这里不多说,直接上关键代码: <bean id="defineModularRea
Shiro+Cas微服务化及前后端完全分离
08-25
主要为大家详细介绍了Shiro+Cas微服务化及前后端完全分离，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
shiro+cas 前后端分离 单点登录 解决方案
宋大王的博客
03-07 1489
shiro+cas 前后端分离 单点登录 解决方案写在前面主要的重点cas服务cas客户端 写在前面 在设计开发自己的博客系统时，选择cas+shiro做用户和鉴权的框架。 曾经在徐州客户现场被cas坑过，一直想把cas啃下来。原谅我是个小菜鸟 搭建这个框架爬了很多坑，也参考了很多大佬的博客，自己慢慢试，慢慢思考，也有一点收获。目前项目还没有完成，可能还有很多坑，有很多地方处理的不是很好，现在只是...
shiro分布式控制登录状态_前后端分离Springboot整合shiro -- 02记住登录状态
weixin_39601641的博客
12-21 109
Shiro提供了Remember Me的功能，用户的登录状态不会因为浏览器的关闭而失效，直到Cookie过期。更改ShiroConfig在ShiroConfig 中加入两个方法。/**** @Author xjw* @Date 2018/10/10 13:54* @Description : 设置Cookie对象***/public SimpleCookie rememberMeCookie() ...
Shiro - RememberMe记住我功能实现
小小默：进无止境
11-06 5883
【1】认证和记住我 ① 记住我 Shiro提供了记住我（RememberMe）的功能，比如访问如淘宝等一些网站时，关闭了浏览器，下次再打开时还是能记住你是谁，下次访问时无需再登录即可访问，基本流程如下： 首先在登录页面选中RememberMe然后登录成功；如果是浏览器登录，一般会把RememberMe的Cookie 写到客户端并保存下来； 关闭浏览器再重新打开；会发现浏览器还是记住你的； 访问一...
前后端分离整合shiro做权限控制
qq_47848696的博客
05-11 827
添加 shiro依赖 <!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-spring --> <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId>
shiro-demo_DEMO_shiro_shriodemo_shiro框架demo_shiro前后端分离_
10-04
一个实现了shiro前后端分离的框架。拿来就可以用。
Spring boot整合shiro+jwt实现前后端分离
08-25
主要为大家详细介绍了Spring boot整合shiro+jwt实现前后端分离，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
SpringBoot + Shiro前后端分离权限
08-25
主要为大家详细介绍了SpringBoot + Shiro前后端分离权限，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
SpringBoot + Shiro实现前后端全分离接口安全框架
09-02
SpringBoot-Shiro前后端分离框架,通过shiro控制权限，实现前后端全分离接口安全。
security记住我功能
11-02
security记住我功能
shiro 前后端分离框架 用户登录解决方案
热门推荐
在北京
01-17 2万+
介绍 最近公司要原本springmvc+shiro 权限控制的一个项目，改为前后端分离的，使前端人员能有更多时间来做前端的交互工作，提升用户体验。 但是这个问题就来了，原来没有分离的情况下，shiro 权限是通过凭证来登录的，现在需要更改为前端ajax提交登录信息来登录，于是更改了shiro的登录方式，这里做一个记录。 @RequestMapping(value="/userLogin"...
shiro 前后台realm 写法，用于分辨realm
aoer2500的博客
05-29 129
首先改写一下 UsernamePasswordToken 这个类 新建一个类，叫UsernamePasswordUsertypeToken，继承UsernamePasswordToken package hstc.edu.cn.realm; import org.apache.shiro.authc.UsernamePasswordToken; /** * Cr...
shiro 实现认证授权
gaoyongjianqq的专栏
07-10 8593
一.认证和授权的概念 认证(authentication):show it,you are you; 授权(authoriziation):through it,you can do sth; 二.shiro中的认证与授权 AuthenticatingRealm：shiro中的用于进行认证的领域，实现doGetAuthentcationInfo方法实现用户登录时的认证逻辑； Author...
在前后端分离的项目中，后台使用shiro框架时，怎样使用它的会话管理系统(session)，从而实现权限控制
打工人，打工魂
02-03 1015
http://blog.csdn.net/palerock/article/details/73457415
shiro 集成cas单点登录
guanzhongye007的博客
12-16 2835
一、之前做了cas的单点登录，也做了shiro的权限角色管理，但是没有将两者集成起来，现在做个集成供参考交流。 二、shiro是个比较简单的权限框架，可以阅读官方文档，一步步来，在此只是提示下shiro核心配置就是realm，realm是个父接口，关键在项目中如何实现其子接口，建议继承 Authorizingrealm这个类，实现其中的doGetAuthenticationInfo(用户认证)
前后台分离开发--登录功能
weixin_59058192的博客
09-02 131
用户登录 //-------前台思路--------// 传递三个参数,phone,password ,type (type用来判断是用户登录还是员工登录) //--------后台思路--------// Controller拿到这三个参数(可以用一个LoginDto封装起来) 把参数传递到service 层 并给页面返回一个map 里面存放了登录的一些信息 Service 拿到数据,进行业务处理 ) 非空判断, ) 通过Dto 对象里面的phone,type去查loginInfo表 查.
shiro整合ehCache，清除认证缓存
Seven_0110的博客
01-05 1388
清除当前用户的shiro认证缓存（已验证） //修改成功后清除缓存 DefaultWebSecurityManager securityManager = (DefaultWebSecurityManager)SecurityUtils.getSecurityManager(); ShiroRealm shiroRealm = (ShiroRealm) securityManager.getRealms().iterator().next(); // shiroRealm.clearAllCache();
【编程不良人】SpringSecurity实战学习笔记04---RememberMe
Mr.Cui的Java学习之路
08-27 1401
【编程不良人】SpringSecurity实战学习笔记04---RememberMe
shiro前后端分离
最新发布
09-05
是的，"shiro前后端分离"是一种常见的应用架构模式。Shiro是一个用于身份验证、授权和会话管理的Java开源框架。在前后端分离的架构中，前端和后端分别独立开发，通过API进行通信。在这种模式下，Shiro通常被用于后端...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值