api Token Shiro权限控制

最新推荐文章于 2023-05-10 12:11:26 发布
最新推荐文章于 2023-05-10 12:11:26 发布
阅读量4.4k 收藏 9
点赞数 3
分类专栏： springmvc shiro 文章标签： shiro 权限 Token
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lvzhyt/article/details/81341985
版权

api Token Shiro权限控制

前后端分离，api通过token验证，后端用shiro权限控制。

token 采用放在header中。 首先获取token，ajax通过header回传token,保持同一会话。

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.tg.demo.shiroapi</groupId>
  <artifactId>demo-shiroapi</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>demo-shiroapi Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <!-- versions -->
    <spring.version>5.0.6.RELEASE</spring.version>
    <shiro.version>1.4.0</shiro.version>
    <lombok.version>1.16.20</lombok.version>
    <fastjson.version>1.2.47</fastjson.version>
    <jackson.version>2.9.5</jackson.version>
    <log4j2.version>2.10.0</log4j2.version>
    <slf4j.version>1.7.25</slf4j.version>
    <jedis.version>2.9.0</jedis.version>
    <ehcache.version>2.4.3</ehcache.version>
    <servlet-api.version>3.1.0</servlet-api.version>
    <commons-lang3.version>3.7</commons-lang3.version>

  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <!-- springmvc -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!--添加aspectjweaver包 -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.5</version>
    </dependency>


    <!-- shiro -->
    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-web</artifactId>
      <version>${shiro.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-spring</artifactId>
      <version>${shiro.version}</version>
    </dependency>
    <dependency>
      <groupId>net.sf.ehcache</groupId>
      <artifactId>ehcache-core</artifactId>
      <version>${ehcache.version}</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>${fastjson.version}</version>
    </dependency>

    <!--日志-->
    <!--slf4j-->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <!-- log4j2 -->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-core</artifactId>
      <version>${log4j2.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-api</artifactId>
      <version>${log4j2.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-slf4j-impl</artifactId>
      <version>${log4j2.version}</version>
    </dependency>

    <!--lombok -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>${lombok.version}</version>
    </dependency>

    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>${servlet-api.version}</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-lang3</artifactId>
      <version>${commons-lang3.version}</version>
    </dependency>

    <!-- jackson -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>${jackson.version}</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>${jackson.version}</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>${jackson.version}</version>
    </dependency>

    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>${jedis.version}</version>
    </dependency>
  </dependencies>

  <build>
    <finalName>demo-shiroapi</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.7.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.20.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

Web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
​
  <filter>
    <filter-name>corsFilter</filter-name>
    <filter-class>com.tg.demo.shiroapi.filter.CorsFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>corsFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
​
  <!-- Shiro Filter -->
  <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>
​
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:/applicationContext.xml</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
​
  <servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:dispatcher-servlet.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

 

dispatcher-servlet.xml

<context:component-scan base-package="com.tg.demo.shiroapi"></context:component-scan>
​
    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg index="0" value="utf-8" />
                <property name="supportedMediaTypes">
                    <list>
                        <value>application/json;charset=UTF-8</value>
                        <value>text/plain;charset=UTF-8</value>
                    </list>
                </property>
            </bean>
            <!--对日期进行转化的 -->
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="objectMapper">
                    <bean class="com.tg.demo.shiroapi.CustomObjectMapper">
                        <property name="dateFormat">
                            <bean class="java.text.SimpleDateFormat">
                                <constructor-arg type="java.lang.String" value="yyyy-MM-dd HH:mm:ss" />
                            </bean>
                        </property>
                    </bean>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>
​
    <mvc:cors>
        <mvc:mapping path="/**" />
    </mvc:cors>
​
    <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>

mvc:cors配置对shiroFilter可能不起作用，走mvc之前被shiro拦截，所以配置了web.xml的corsFilter。

aop的开启必须放在spring-mvc/dispatcher-servlet，即dispather对应的xml为文件。

shiro.xml

<?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:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
​
​
    <bean id="sampleRealm" class="com.tg.demo.shiroapi.shiro.realm.SampleRealm" ></bean>
​
    <!--自定义SessionManager-->
    <bean id="sessionManager" class="com.tg.demo.shiroapi.shiro.session.AccessTokenSessionManager" />
​
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="realm" ref="sampleRealm"/>
        <property name="sessionManager" ref="sessionManager"/>
    </bean>
​
    <bean id="login" class="com.tg.demo.shiroapi.shiro.filter.LoginFilter"></bean>
​
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager" />
        <property name="loginUrl" value="/login" />
        <!--    TODO 待提取    -->
        <property name="successUrl" value="/" />
        <property name="unauthorizedUrl" value="/loginPrevent" />
​
        <!--    初始配置，现采用自定义 -->
        <property name="filterChainDefinitions" >
            <value>
                /login = anon
                /loginPrevent = anon
                /index = anon
                /index.jsp = anon
                /** = login
            </value>
        </property>
        <property name="filters">
            <util:map>
                <entry key="login" value-ref="login"></entry>
            </util:map>
        </property>
​
    </bean>
​
    <!-- Shiro生命周期处理器-->
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor" />
​
    <!--使用@RequiresRoles,@RequiresPermissions等注解-->
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
          depends-on="lifecycleBeanPostProcessor"/>
    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
        <property name="securityManager" ref="securityManager"/>
    </bean>
</beans>

自定义loginFilter，拦截返回json信息。

自定义SessionManager, AccessTokenSessionManager重写了getSessionId方法，先从header中获取Token作为sessionId。问题：篡改了sessionId，会导致corsFilter报异常，目前看不受影响，可以通过改写DAO的方式解决。

sampleRealm验证及权限

AccessTokenSessionManager

package com.tg.demo.shiroapi.shiro.session;
​
import org.apache.shiro.session.Session;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
​
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import java.io.Serializable;
​
public class AccessTokenSessionManager extends DefaultWebSessionManager {
​
    public static final String ACCESS_TOKEN = "Access-Token";
​
    protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
        if(request instanceof HttpServletRequest){
            HttpServletRequest httpServletRequest = (HttpServletRequest) request;
            String sessionId = httpServletRequest.getHeader(ACCESS_TOKEN);
            if(sessionId!=null) {
                try {
                    Session session = retrieveSessionFromDataSource(sessionId);
                    System.out.println("Access-Token:"+sessionId);
                    return sessionId;
                }catch (Exception e){
                }
            }
        }
        return super.getSessionId(request,response);
    }
​
​
}
​

 

SampleRealm

package com.tg.demo.shiroapi.shiro.realm;
​
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
​
​
public class SampleRealm extends AuthorizingRealm {
​
    
    public SampleRealm() {
        super();
    }
    /**
     *  认证信息，主要针对用户登录， 
     */
    protected AuthenticationInfo doGetAuthenticationInfo(
            AuthenticationToken authcToken) throws AuthenticationException {
        
        UsernamePasswordToken token = (UsernamePasswordToken) authcToken;
        // get from db password 123
        if(!("admin".equals(token.getUsername())&&"123".equals(new String(token.getPassword())))){
            throw new AccountException("帐号或密码不正确！");
        }
​
        return new SimpleAuthenticationInfo(token,token.getPassword(), getName());
    }
​
     /** 
     * 授权 
     */  
    @Override  
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
        
//      Long userId = TokenManager.getUserId();
        SimpleAuthorizationInfo info =  new SimpleAuthorizationInfo();
        //根据用户ID查询角色（role），放入到Authorization里。
//      Set<String> roles = roleService.findRoleByUserId(userId);
//      info.setRoles(roles);
//      //根据用户ID查询权限（permission），放入到Authorization里。
//      Set<String> permissions = permissionService.findPermissionByUserId(userId);
//      info.setStringPermissions(permissions);
//      info.addStringPermission("sys:hello");
        return info;  
    }  
​
​
}
​

LoginFilter

package com.tg.demo.shiroapi.shiro.filter;
​
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.AccessControlFilter;
​
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
​
​
@Slf4j
public class LoginFilter extends AccessControlFilter {
    final static Class<LoginFilter> CLASS = LoginFilter.class;
​
    public static final String ACCESS_TOKEN = "Access-Token";
​
    @Override
    protected boolean isAccessAllowed(ServletRequest request,
            ServletResponse response, Object mappedValue) throws Exception {
        if(isLoginRequest(request, response)){// && isEnabled()
            return Boolean.TRUE;
        }
​
        Subject subject = getSubject(request, response);
        return subject.isAuthenticated();
​
    }
​
    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
​
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("login_status", "300");
        jsonObject.put("message", "无效的Token.");
        response.setCharacterEncoding("UTF-8");
        response.getWriter().write(jsonObject.toJSONString());
​
        return Boolean.FALSE ;
    }
    
​
}
​LoginController
package com.tg.demo.shiroapi.controller;
​
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
​
@RestController
@RequestMapping("/")
public class LoginController{
​
    public static final String RESULT = "result";
    public static final String MESSAGE = "message";
    @RequestMapping("/login")
    public JSONObject login(String userName,String password){
        JSONObject jsonObject = new JSONObject();
        if(StringUtils.isNoneEmpty(userName,password)) {
            UsernamePasswordToken token = new UsernamePasswordToken(userName, password);
            Subject subject = SecurityUtils.getSubject();
            Session session = subject.getSession();
            System.out.println(session.getId());
​
            try {
                subject.login(token);
                jsonObject.put("token", session.getId());
                jsonObject.put(RESULT, 1);
                jsonObject.put(MESSAGE, "登录成功");
            } catch (AuthenticationException e) {
                jsonObject.put(RESULT, 0);
                jsonObject.put(MESSAGE, "登录失败");
                e.printStackTrace();
            } catch (Exception e) {
                jsonObject.put(RESULT, 0);
                jsonObject.put(MESSAGE, "登录失败");
                e.printStackTrace();
            }
        }else{
            jsonObject.put(RESULT,0);
            jsonObject.put(MESSAGE,"登录失败");
        }
​
        return jsonObject;
    }
​
    @RequestMapping("/loginPrevent")
    public JSONObject needLogin(){
        JSONObject jsonObject = new JSONObject();
​
        jsonObject.put(RESULT,0);
        jsonObject.put(MESSAGE,"没有登录");
        return jsonObject;
    }
​
​
}
​

 

 

 

测试js

var token="";
    function getToken() {
        $.ajax({
            // url:'http://localhost:8081/login?userName=admin&password=123',
            url:'http://localhost:8081/login?userName=admin&password=123',
            type:'get',
            // beforeSend: function (xhr) {
            //   xhr.setRequestHeader("Access-Token", "b21fd4c6-057a-4953-a584-c882dce08955");
            // },
            success: function(data) {
                console.log(data);
                token = data.token;
            }
        });
    }
    function hello() {
        $.ajax({
            // url:'http://localhost:8081/login?userName=admin&password=123',
            url:'http://localhost:8081/hello',
            type:'get',
            beforeSend:  function(xhr) {
                xhr.setRequestHeader("Access-Token", token);
            },
            success:function (data) {
                console.log(data);
            }
        });
    }

完整代码：https://github.com/lvzhyt/demo-shiroapi

 

琴岛橙子
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
解决前后端分离 Shiro 的用户 Token 认证问题
weixin_44338092的博客
04-17 706
【代码】解决前后端分离 Shiro 的用户 Token 认证问题。
永久token
我是一只程序⚪的技术交流平台
07-23 4227
在HTTP检查的时候，出现如下错误： 401的意思代表访问由于凭据无效被拒绝，总结一下就是我们设置的token过期了，那如何设置一个永久有效的token呢？ 我们的token认证是通过JWT实现的，JSON Web Token（JWT）是目前最流行的跨域身份验证解决方案。 JWT TOKEN组成 一个JWT TOKEN为三个部分组成： JWT头 JWT头部分是一个描述JWT元数据的JSON对...
shiro - 使用 token
bhegi_seg的博客
03-28 1188
整合文章： 为什么使用token？session与token的区别 shiro使用(使用token预热,为什么要使用token) shiro使用(使用token) 文章目录 一、session的状态保持及弊端 二、token认证机制 Apache Shiro 用户信息保存在 Session 方案 一、session的状态保持及弊端 当用户第一次通过浏览器使用用户名和密码访问服务器时， 服务器会验证用户数据， 验证成功后在服务器端写入session数据， 向客户端浏览器返回sessionid，.
Spring Boot+Shiro 实现 Token 的登录和认证
小码蚁
01-26 5438
因为项目要改为单点登录，shiro是通过session进行信息验证的，而且还要保留shiro的权限验证，所以只需要把验证这一部分改为token。 Shiro和token的实现和概念网上有很多，这里就不做讲解了。 本文主要参考了这篇文章https://blog.csdn.net/sqlgao22/article/details/99186391/ 先讲一下大体思路： 1、登录后生成token存入数据库并将token放入cookie,这样好处是浏览器发送请求的时候cookie会被自动带上，前端不用.
Shiro的配置及使用
qq_45733154的博客
10-21 2837
Shiro,Springboot整合Shiro,Shiro实现登录拦截，Shiro实现用户认证，用户授权，Shiro整合Thymeleaf
Shiro实现Token认证
最新发布
梅子黄时雨
05-10 1329
shiro使用
shiro权限控制
01-04
Shiro提供了一套完整的Web安全控制API，包括过滤器（Filter）来处理HTTP请求。例如，可以配置RememberMeFilter、LoginFilter、UnauthorizedFilter等，实现用户的登录、权限检查和未授权页面的跳转。Shiro的Web支持...
SpringBoot集成Shiro进行权限控制和管理的示例
08-27
SpringBoot集成Shiro进行权限控制和管理的示例 SpringBoot是一个流行的Java框架，用于快速构建基于Web的应用程序，而Shiro是一个轻量级的身份验证与授权框架，提供了灵活的身份验证和授权机制。本文将介绍如何将...
shiro权限管理案例加文档
01-12
在这个“shiro权限管理案例加文档”中，我们很可能会找到关于如何在实际项目中应用Shiro进行权限控制的详细教程和实例。 **一、Shiro基础** Shiro的核心组件包括：Subject（主体）、Realms（域）、Cryptography...
权限控制shiro
04-14
在Java Web开发中，Shiro 和 SpringMVC 结合使用可以构建出高效且灵活的权限控制系统。 1. **Shiro 简介** Shiro 提供了简单直观的 API，让开发者能够轻松地处理认证、授权、加密和会话管理。它不依赖于 Servlet ...
springboot shiro 权限管理 spring boot
11-13
4. **Controller 权限控制**：通过在 Controller 方法上添加 Shiro 的注解，如 `@RequiresAuthentication`、`@RequiresPermissions` 和 `@RequiresRoles`，可以实现基于方法级别的权限控制。 5. **Session 管理**：...
Shiro 身份认证中心获取token中账号密码的两种方式
m0_67392811的博客
04-07 2499
/** * 身份认证 * @param authenticationToken * @return * @throws AuthenticationException */ @Override protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException .
shiro使用(使用token)
热门推荐
特别享受思考问题的过程
05-12 2万+
既然要做,就做的细致一点，对得起自己！ 为什么使用token，请看这里 解决思路： 1.增加一个过滤器，对每一个请求都进行token的校验。如果为登录请求，则可以放过。 2.将过滤器设置进shiro中。 第一步：实现自定义ShiroFilter.这里选择继承FormAuthenticationFilter，至于为什么不继承AuthenticatingFilter，后面会解释。 从当前s...
Shiro自定义Token
drhrht的博客
08-24 1289
***//*** 公司ID*//*** 用户名称*//*** 用户密码*/}}}}}}}@Override}@Override}}/***//*** 重写supports方法，使 Shiro 能够识别自定义的 Token* @return*/@Override}@Override/*PrincipalCollection 身份的集合一个主体可以有多个身份，但是只有一个主身份*/// 获取主体的主身份。
008-shiro使用token认证
这个需求，做不了
05-25 8374
实际开发中，我们的项目大多数都采用前后端分离或者集群的方式部署。在这些情况下，往往会有些问题，比如前后端分离的跨域问题、跨域携带cookie的问题、分布式应用下的session共享等问题，虽然这些问题都能得到相应的解决，但总是觉得没有直接使用token或者jwt方便。接下来我们来对我们目前实现的shiro功能进行一些修改，让它能直接使用token的方式进行认证。 编写axios异步请求 当然JQuery或直接AJAX请求也可以 现象： 重新DefaultWebSessionManager的getRe.
springboot项目中使用shiro 自定义过滤器和token的方式
ratel的博客
01-04 5012
springboot前后端分离项目中使用shiro 实现自定义过滤器和token的方式
shiro 获取当前用户token
chuangfei7389的博客
06-08 3920
//获取当前登录用户的用户名 AppSecurityUtils.obtainLoginedUsername() //获取当前用户token AppSecurityUtils.obtainAccessToken() AppSecurityUtils.java import org....
Shiro学习：如何在Controller中获取用户名/用户信息（用户名密码+token）
weixin_49046411的博客
03-12 3913
UserRealm登录 Shiro登录后会将用户信息保存在Subject中，假如使用用户名密码登录，你的用户名、密码就会保存在token中。token在认证时候，也就是执行（doGetAuthenticationInfo）的时候，可以将token转化为UsernamePasswordToken ，通过UsernamePasswordToken你可以进行认证、并且在Controller中获取这个信息。 我的执行认证的代码如下： `` @Override protected Authentica
java认证框架_easy-security
weixin_31617975的博客
02-12 415
这是一个Java的安全认证框架，实现登录，权限认证功能。脱离容器的会话ID，轻松实现负载均衡而不用担心会话丢失。支持多种会话缓存实现，权限控制灵活，与spring框架配置使用简单。获取用户登录信息SessionManager sm = ...;Session session = sm.getSession();if(session.isLogin()) {String userId = sessi...
Shiro权限控制详解：从入门到实战
Shiro权限控制是Java安全框架Apache Shiro的核心功能之一，它帮助开发者在Web应用程序中实现用户身份验证和访问控制。本指南旨在逐步介绍如何使用Shiro进行身份验证、授权、配置、编码/加密以及与Web和Spring框架的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值