shiro的学习

最新推荐文章于 2020-05-20 13:33:04 发布
最新推荐文章于 2020-05-20 13:33:04 发布
阅读量143 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hyhanyu/article/details/81363083
版权

先在pom文件里导入shiro的jar，这个例子shiro的版本用的是<shiro.version>1.2.2</shiro.version> ，使用@RequiresPermissions等注解，一定要加spring aop的包和org.aspectj.aspectjweaver的jar。

<!-- 导入shiro核心包 -->
		<dependency>
			<groupId>org.apache.shiro</groupId>
			<artifactId>shiro-core</artifactId>
			<version>${shiro.version}</version>
		</dependency>
		<!-- 导入shiro-spring支持 -->
		<dependency>
			<groupId>org.apache.shiro</groupId>
			<artifactId>shiro-spring</artifactId>
			<version>${shiro.version}</version>
		</dependency>
		<!-- 导入shiro-web支持 -->
		<dependency>
			<groupId>org.apache.shiro</groupId>
			<artifactId>shiro-web</artifactId>
			<version>${shiro.version}</version>
		</dependency>
		<!-- 导入shiro-EHCache支持 -->
		<dependency>
			<groupId>org.apache.shiro</groupId>
			<artifactId>shiro-ehcache</artifactId>
			<version>1.2.2</version>
		</dependency>

然后创建一个sprin-shiro的文件：

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:tx="http://www.springframework.org/schema/tx" 
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
		http://www.springframework.org/schema/context
		http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/tx
		http://www.springframework.org/schema/tx/spring-tx-4.3.xsd
		http://www.springframework.org/schema/util
		http://www.springframework.org/schema/util/spring-util-4.3.xsd
		http://www.springframework.org/schema/mvc
		http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd">
                     
    
      <!--定义cookie的属性  -->
      <bean id="rememberMeCookie" class="org.apache.shiro.web.servlet.SimpleCookie">
       <constructor-arg value="rememberMe" />
       <property name="httpOnly" value="true" />
       <!-- 默认记住7天（单位：秒） -->
       <property name="maxAge" value="604800" />
   </bean>
   <!-- rememberMe管理器  (org.apache.shiro.codec.Base64).decode('')里面的key可以随意更改
                    生成方法 在AbstractRememberMeManager类里：
       AesCipherService aes = new AesCipherService();
       byte[] key = aes.generateNewKey().getEncoded();
       String base64 = Base64.encodeToString(key);
   -->
   <bean id="rememberMeManager" class="org.apache.shiro.web.mgt.CookieRememberMeManager">
    <property name="cipherKey" value="#{T(org.apache.shiro.codec.Base64).decode('MPdCMZ9urzEA50JDlDYYDg==')}" />
       <property name="cookie" ref="rememberMeCookie" />
   </bean>
    <!--自定义的拦截器  -->
    <bean id="remeberFilter" class="com.glodio.shiro.RemeberFilter" />
    <!-- shiro配置 用于验证信息和权限 -->
    <bean id="realm" class="com.glodio.shiro.ShiroDBRealm" >
    <!--密码匹配  --> 
    <property name="credentialsMatcher">
            <bean class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
                 <!--调用什么加密方法  -->
                 <property name="hashAlgorithmName" value="MD5"></property> 
                  <!--调用什么加密几次  -->
                 <property name="hashIterations" value="1"></property>
            </bean>
        </property>        
    </bean>
    
    <!--配置 securityManager -->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
	        <property name="realm" ref="realm" />   
	        <property name="rememberMeManager" ref="rememberMeManager" />     	   		
	</bean>
	
	
    <!--shiroFilter这个名字 一定要和web.xml的名字一样  -->
	<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">		    	
	    <!-- Shiro的核心安全接口，这个属性是必须的 -->
	    <property name="securityManager" ref="securityManager"/>
	    <!--登录的url 如果没有登录 就会跳转到该页面  --> 
	    <property name="loginUrl" value="/"/>
	    <!--没权限的url  -->
	    <property name="unauthorizedUrl" value="/"/>
	    <!--配置自己的过滤器  -->
	    <property name="filters">
	       <util:map>
              <entry key="remeberFilter" value-ref="remeberFilter"></entry>
           </util:map>  
	    </property>
	    <!--验证规则 只有要一个符合 下面的就不会执行 所以匿名访问的要写在前面  -->
	    <property name="filterChainDefinitions">
	        <value>
	        	/ = anon
	        	/login.html = anon
	            /system/login = anon
	            /logout = anon
	            /src/** = anon
	            /public/** = anon
	          	/** = remeberFilter
	        </value>
	    </property>
	</bean>
	
	
	<bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>
  
</beans>

如果要加 @RequiresPermissions 等注解 ，必须在spring mvc的注解里添加：

 <aop:config proxy-target-class="true"/>
      <!--在controller层加注解：使用shiro时必须添加的配置--> 
     <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
          depends-on="lifecycleBeanPostProcessor">
           <property name="proxyTargetClass" value="true"/> 
     </bean>      
     <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
        <property name="securityManager" ref="securityManager"/>
    </bean>

在web.xml文件里加shiro的过滤器

<filter>
    <filter-name>shiroFilter</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    <init-param>
        <param-name>targetFilterLifecycle</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>shiroFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

 

RemeberFilter类：

import java.util.ArrayList;
import java.util.List;
import javax.annotation.Resource;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.AccessControlFilter;
import org.springframework.beans.factory.annotation.Autowired;
import com.glodio.bean.Role;
import com.glodio.bean.Url;
import com.glodio.bean.User;
import com.glodio.bean.UserInf;
import com.glodio.service.IRoleService;
import com.glodio.service.IUserService;
import com.glodio.service.UrlService;
import com.glodio.util.StringUtil;

public class RemeberFilter extends AccessControlFilter{

    

    @Autowired
    private UrlService urlService;

    @Resource
    private IRoleService iRoleService;
    
    @Resource
    IUserService iUserService;

    
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue)
            throws Exception {
        boolean result = false;
        Subject subject = SecurityUtils.getSubject();
        //这个session 就是httpSession 在web容器下 shiro的session 就是httpSession
        Session session = subject.getSession();
        //如果登录直接返回true
        if(subject.isAuthenticated()){
            return true;
        }
        //如果是记住 没有登录 那么需要初始化session中的用户信息
        if(subject.isRemembered() && !subject.isAuthenticated()){
            result = true;
            User user = (User)session.getAttribute("user");
            if(user == null){
                String userName = (String) subject.getPrincipal();
                user = iUserService.queryBean(userName);
                if(user != null){
                    session.setAttribute("user", user);
                    initRoles(user,session);
                }
            }
            
            
        }
        
        return result;
    }
    
    //如果被拒绝 那么直接返回到登录页
    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        
        redirectToLogin(request, response);
        return false;
    }

    

  
    private void initRoles(User bean, Session session) {
        if (StringUtil.strIsNullOrEmpty(bean.getRolename())) {
           
            return;
        }
        Role role = iRoleService.selectByRoleName(bean.getRolename());
        if (role == null || StringUtil.strIsNullOrEmpty(role.getUrlremark())) {
            
            return;
        }
        String[] ulrIds = role.getUrlremark().split(";");
        if (ulrIds == null || ulrIds.length == 0) {
            return;
        }
        List<Integer> ids = new ArrayList<>();
        for (String id : ulrIds) {
            ids.add(Integer.parseInt(id));
        }
        List<String> permissions = new ArrayList<>();
        List<Url> urls = urlService.selectListByIds(ids);
        if (urls != null) {
            session.setAttribute("urls", urls);
            for(Url url : urls){
                permissions.add(url.getUrlAddr());
            }
            
        }
        UserInf userInf = new UserInf();
        userInf.setUsr(bean);
        userInf.setPermissions(permissions);
        session.setAttribute(UserInf.USERINF, userInf);  
    }
    
    

}

ShiroDBRealm类：

import javax.annotation.Resource;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;

import com.glodio.bean.User;
import com.glodio.bean.UserInf;
import com.glodio.service.IUserService;

public class ShiroDBRealm extends AuthorizingRealm {
	
	@Resource
	private IUserService iUserService;
	

	@Override
	protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection arg0) {
		Session session = SecurityUtils.getSubject().getSession();
		UserInf userInf  = (UserInf) session.getAttribute(UserInf.USERINF);
		SimpleAuthorizationInfo authorizationInfo = null;
		if(userInf != null){
		    authorizationInfo = new SimpleAuthorizationInfo();
		    authorizationInfo.addStringPermissions(userInf.getPermissions());
		  
		}
		return authorizationInfo;
	}

	@Override
	protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authcToken) throws AuthenticationException {
        // 把token转换成User对象  
	    UsernamePasswordToken upt = (UsernamePasswordToken)authcToken;
	    String username = upt.getUsername();
	    String password = String.valueOf(upt.getPassword());
	    User userLogin = tokenToUser(upt);
        // 根据验证用户名查找用户   这里可以根据用户状态 抛出多个异常 然后在login方法里进行捕捉
	    User u = iUserService.queryBeanPassword(username);
        if(u == null) {
            throw new UnknownAccountException("用户不存在");
        }
        //当前 Realm 的 name  
        String realmName = this.getName();  
        //principal 就是用户名
        Object principal = upt.getPrincipal();
        ByteSource salt = ByteSource.Util.bytes(username);
        //会验证密码是否匹配
        return new SimpleAuthenticationInfo(principal, u.getPassword(), salt,realmName);  
	}
	
    private User tokenToUser(UsernamePasswordToken authcToken) {  
        User user = new User();  
        user.setUsername(authcToken.getUsername());  
        user.setPassword(String.valueOf(authcToken.getPassword()));  
        return user;  
    }

}

login方法：

@ResponseBody
    @RequestMapping("/login")
    public Map<String, Object> login(HttpServletRequest request, @Param("username") String username,
            @Param("password") String password) throws Exception {
        Map<String, Object> dataMap = new HashMap<>();
        boolean result = false;
        User bean = iUserService.queryBeanPassword(username);
        Subject subject = SecurityUtils.getSubject();
        
        UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(username, password);
        //捕捉登录出现的异常
        try {
           //是否记住用户名，shiro 在cookie里面只存了用户名
            usernamePasswordToken.setRememberMe(true);
            subject.login(usernamePasswordToken);
            if(subject.isAuthenticated()){
                result = true;
            }
            // if no exception, that's it, we're done!
        } catch (UnknownAccountException uae) {
            // username wasn't in the system, show them an error message?
            result = false;
            dataMap.put("msg", "当前用户名不存在！");
        } catch (IncorrectCredentialsException ice) {
            dataMap.put("msg", "用户名或密码错误！");
        } catch (LockedAccountException lae) {
            // account for that username is locked - can't login. Show them a
            // message?

        } catch (AuthenticationException ae) {
            ae.printStackTrace();
            dataMap.put("msg", "系统出错，请稍后重试！");
        }
        if (result) {
            if (bean != null ) {
                result = true;
                request.getSession().setAttribute("user", bean);
                // String rolename = bean.getRolename();
                initRoles(bean, request.getSession());

            }
        }
        dataMap.put("result", result);
        return dataMap;

    }

权限验证：在controller 里面的方法 加@RequiresPermissions等注解就行。如果没有这个权限，会抛出异常 ，所有必须捕获这个异常

@RequiresPermissions("src/org.html")
	@RequestMapping("/OrgList")
	public @ResponseBody Map<String, Object> OrgList(HttpServletRequest request) throws Exception{
		Map<String, Object> dataMap = new HashMap<>();
		Map<String, Object> map = new HashMap<String, Object>();
		ArrayList<Org> list = null;
		int total = 0;
		
		int pageNumber = Integer.parseInt(request.getParameter("pageNumber"));
		int pageSize = Integer.parseInt(request.getParameter("pageSize"));
		
		if(pageNumber > 0) {
			pageNumber = (pageNumber-1)*pageSize;
		}
		else {
			pageNumber = 0;
		}
		
		map.put("pageNumber", pageNumber);
		map.put("pageSize", pageSize);
		
		// 获取当前用户bean,取得用户所在机构，根据所在机构获取用户所有机构权限,再根据所有机构的显示数据信息
		User user = (User)request.getSession().getAttribute("user");
		List<Integer> orgIdList = iOrgService.getOrgIdCollection(user.getOrgId());
		map.put("list", orgIdList);

		total = iOrgService.queryAllCountForOrgId(orgIdList);
		if(total > 0) {
			list = iOrgService.queryBeansForOrgId(map);
		}
		total = (total+pageSize)/pageSize;
		dataMap.put("total", total);
		dataMap.put("list", list);
		
		return dataMap;
	}

CustomExceptionResolver类：简单的捕获了AuthorizationException异常

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


import org.apache.shiro.authz.AuthorizationException;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;
@Component
public class CustomExceptionResolver implements HandlerExceptionResolver{

    @Override
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler,
            Exception ex) {
        ex.printStackTrace();
        //对异常类型进行判断
        if(ex instanceof AuthorizationException){
            response.setCharacterEncoding("utf-8");
            PrintWriter writer = null;
            try {
                writer = response.getWriter();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            writer.println("没有该权限！");
            writer.close();
            return null;
        }else{
            return new ModelAndView();
        }
         
    }
}

 

Filter Name                     Class
anon                  org.apache.shiro.web.filter.authc.AnonymousFilter
authc                   org.apache.shiro.web.filter.authc.FormAuthenticationFilter
authcBasic         org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter
logout                  org.apache.shiro.web.filter.authc.LogoutFilter
noSessionCreation  org.apache.shiro.web.filter.session.NoSessionCreationFilter
perms                  org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter
port                            org.apache.shiro.web.filter.authz.PortFilter
rest                          org.apache.shiro.web.filter.authz.HttpMethodPermissionFilter
roles                          org.apache.shiro.web.filter.authz.RolesAuthorizationFilter
ssl                          org.apache.shiro.web.filter.authz.SslFilter
user                          org.apache.shiro.web.filter.authc.UserFilter

这个可以看出每个过滤器名称都有一个过滤器类，所以

 <property name="filterChainDefinitions">
            <value>
                / = anon
                /login.html = anon
                /system/login = anon
                /logout = anon
                /src/** = anon
                /public/** = anon
                  /** = remeberFilter
            </value>
        </property>

我们自己可以定义一些过滤器来控制访问的权限 或 做一些其他事

hy飞无
关注
专栏目录
shiro的登录 subject.login(token)中执行逻辑和流程
qq_41358574的博客
11-02 7973
今天登录的时候一直没有记录当前用户信息下来，执行security.getsubject()时结果一直为空，遂看了下源码 使用subject.login的登录场景： （controller层） @GetMapping public Result userLogin(@ApiParam(name="userId",value="用户学号",required=true) @RequestParam(value = "userId",requir
shiro验证注解
qq_34321710的博客
06-28 468
@RequiresAuthentication 验证用户是否登录，等同于方法subject.isAuthenticated() 结果为true时。 @RequiresUser 验证用户是否被记忆，user有两种含义： 一种是成功登录的（subject.isAuthenticated() 结果为true）； 另外一种是被记忆的（subject.isRemembered()结果为true）。 @RequiresGuest 验证是否是一个guest的请求，与@RequiresUser完全相反。 换言之，Requi
Shiro的认证和权限控制
Android小码农的博客
10-26 933
权限控制的方式 从类别上分，有两大类： - 认证：你是谁？–识别用户身份。 - 授权：你能做什么？–限制用户使用的功能。 权限的控制级别 从控制级别（模型）上分： - URL级别-粗粒度 - 方法级别-细粒度 - 页面级别-自定义标签（显示） - 数据级别-最细化的（数据） URL级别的权限控制-粗粒度 在web.xml中配置一个过滤器filter，在过滤器中，对请求的地址进行解析，字符串截...
基于javaSE引用的 shiro的基本使用
qq_44697103的博客
05-20 258
1.创建maven项目 2.导入shiro依赖库 <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-core</artifactId> <version>1.4.1</version> </dependency> 3.创建shiro配置文件 List item在res
Shiro学习笔记——remember me
shen的博客
09-18 214
认证和记住我的区别 subject.isAuthenticated()，表示用户进行了身份验证登录的，即使用subject.login进行了登录。 subject.isRemebered()，表示用户是通过记住我登录的，此时可能并不是真正的你（如你的朋友使用你的电脑，或者你的cookie被窃取）在访问的。 两者二选一，即subject.isAuthenticated()==true，则subje...
shiro学习笔记
04-03
这份"Shiro学习笔记"可能包含了以下主题： - Shiro的安装与配置 - Shiro基本概念详解 - Realm的创建与使用 - 登录与登出流程 - 权限控制机制 - 缓存管理和会话管理 - Shiro与Spring的整合 - Shiro的Filter链配置 - ...
shiro学习示例
02-07
在"shiro学习示例"中，我们可以深入理解Shiro的核心概念和实际应用。 1. **Shiro基本概念** - **认证**：确认用户身份的过程，即用户输入用户名和密码，系统通过验证来确认用户的身份。 - **授权**：确定用户是否...
shiro 学习资料
12-27
在学习 Apache Shiro 的过程中，你需要理解它的核心组件、配置方式以及如何与具体应用结合。Shiro 的灵活性和易用性使其成为 Java 开发者处理安全问题的首选工具之一。通过深入学习和实践，你可以更好地掌握这个框架...
shiro学习源码与资料
02-24
这个压缩包包含的资源是关于Shiro学习的源码和课件，适合对Java安全有兴趣或者正在学习Shiro的开发者。 首先，我们来深入理解Shiro的核心概念： 1. **身份认证（Authentication）**：这是验证用户身份的过程。...
【Shiro权限管理】22.Shiro之记住我
程序猿之洞
01-06 6969
注：该系列所有测试均在之前创建的Shiro3的Web工程的基础上。 在我们登录一些网站的时候，在登录输入框的下侧一般都会有一个“记住我”的勾选框，选择之后，我们 下次进入网站的时候就会自动进行登录操作，无需我们再次输入密码。而在访问一些敏感信息的时候，还是需要 进行登录操作的。 有关“记住我”的实现原理如下： 1、首先在登录页面选中“记住我”然后登录成功；如果是浏览器登录，一般会把“
springboot整合shiro实现权限控制
jiankang66的博客
05-24 4万+
Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码学和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。上个月写了一个在线教育的项目用到了shiro权限控制，这几天又复盘了一下，对其进行了深入探究，来总结一下。 下面所总结的有关shiro的代码已经传到我的github上，可以访问下面的......
Shiro身份验证（三）
小小舒宸的专栏
11-27 8711
身份验证就是验证身份的过程，即在应用程序中验证他们到底存不存在。为了验证他们的身份，他们需要提供一些让应用程序信任的标识信息。 在Shiro中，用户必须提供principals（身份）和credentials（凭证）给Shiro，让应用程序验证用户身份。 Principals是一个主体的标识属性，它可以是任何东西，比如用户名、邮箱和手机等唯一标识。虽然Subject可以有任意数量pri
区别isRemembered 和 isAuthenticated 例子
钱袋博客
11-17 7659
假设你使用卓越网，你已经成功登录并且在购物蓝中添加了一些书籍，但你由于临时要参加一个会议，匆忙中你忘记退出登录，当会议结束，回家的时间到了，于是你离开了办公室。 第二天当你回到工作，你意识到你没有完成你的购买动作，于是你回到卓越网，这时，卓越网“记得”你是认证，通过你的名字向你打招呼，仍旧给你提供个性化的图书推荐，对于卓越，subject.isRemembered()将返回真。 但是当
shiro学习_Subject的使用
it_lihongmin的博客
07-15 5556
Shiro为我们暴露的认证授权组件Subject，为我们提供了当前用户、角色和授权的相关信息，并且允许我们在实际项目中通过以下三种方式进行调用 （当然最终的认证授权部分的还是Subject通过SecurityManager调用具体实现的realm进行判定）： 1、编程式授权（当然在实际的生产环境中很少使用） 1） 直接通过角色的访问控制（即调用数据库查看当前subject对应的用户是否具有某
Shiro 实现记住我功能
Charge8的博客
04-27 6245
登录一些网站的时候，在登录输入框的下侧一般都会有一个“记住我”的勾选框，选择之后，下次进入网站时就会自动进行登录操作，无需我们再次输入密码。 有关“记住我”的实现原理如下： 1、首先在登录页面选中“记住我”然后登录成功；如果是浏览器登录，一般会把“记住我”的Cookie写到客户端并保存下来。 2、关闭浏览器再重新打开，会发现浏览器还是记住你的。 3、访问一般的网页服务器端还是知道你是...
Apache Shiro验证: 已记住（Remembered） vs 已验证（Authenticated）
Flyer的后花园
01-30 1717
Apache Shiro验证（Authentication） 验证（Authentication）：身份验证的过程--也就是证明一个用户的真实身份。为了证明用户身份，需要提供系统理解和相信的身份信息和证据。需要通过向shiro提供用户的身份（Principals）和证明（credentials）来判定是否和系统所要求的匹配。 身份（Principals）是Subject的“身份属性”，可以是任何
Shiro使用redis作为缓存(解决shiro频繁访问Redis)(十一)
热门推荐
这个名字想了很久
09-03 6万+
原文地址，转载请注明出处：&amp;amp;nbsp;https://blog.csdn.net/qq_34021712/article/details/80791219&amp;amp;nbsp;&amp;amp;nbsp; &amp;amp;nbsp;&amp;amp;nbsp;©王赛超&amp;amp;nbsp; 之前写过一篇博客,使用的一个开源项目,实现了redis作为缓存 缓存用户的权限 和 session信息,还有两个功能没有修改,一个是用户并发
cas5.3.2单点登录-自定义登录验证(四)
这个名字想了很久
09-03 1万+
原文地址，转载请注明出处：&amp;amp;amp;nbsp;https://blog.csdn.net/qq_34021712/article/details/81144874&amp;amp;amp;nbsp;&amp;amp;amp;nbsp; &amp;amp;amp;nbsp;&amp;amp;amp;nbsp;©王赛超&amp;amp;amp;nbsp; 我们在使用SSO单点登录的时候不只是验证一下用户名和密码是否一致,有时候还需要验证一些别的校
Shiro记住我无效，被拦截；
Loading...
07-29 3130
Shiro记住我无效，被拦截 场景描述：        Shiro的记住我功能就是登录的时候，选择了记住当前用户的选项来登录，关闭浏览器之后，在登录信息存活期间再次访问项目里的某个页面可以直接访问。可以在程序中对某些敏感操作进行判断是否为通过记住我登录的用户，从而进行其他一系列限制操作。        在按照网上的配置配置完之后，发现记住我之后再次访问其他功能时，会被拦截，并且不会通过项目中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值