confiar:

<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring-boot-web-starter</artifactId>
    <version>1.4.1</version>
</dependency>

1. Token personalizado herda UsernamePasswordToken

public class JwtToken extends UsernamePasswordToken {
   private String token;

    public String getToken() {
        return token;
    }

    public void setToken(String token) {
        this.token = token;
    }

    public JwtToken(String username, String password) {
        super(username, password);
    }
}

Nota: Após herdar a classe UsernamePasswordToken, a conta e a senha usam o construtor da classe UsernamePasswordToken

2. Personalize o reino

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.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;

public class CustomerRealm extends AuthorizingRealm {

    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof JwtToken;
    }

    //授权

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {

        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        /*
          常见的方法：
          addRole(String role)：向授权信息中添加角色。
          addRoles(Collection<String> roles)：向授权信息中添加多个角色。
          addStringPermission(String permission)：向授权信息中添加权限（字符串形式）。
          addStringPermissions(Collection<String> permissions)：向授权信息中添加多个权限（字符串形式）。
          setRoles(Set<String> roles)：设置授权信息的角色集合。
          setStringPermissions(Set<String> permissions)：设置授权信息的权限集合。
          getRoles()：获取授权信息中的角色集合。
          getStringPermissions()：获取授权信息中的权限集合。
         */
        // 在这里只是设置权限了一个普通的权限：字符串
        authorizationInfo.addStringPermission("user:add:*");
        return authorizationInfo;
    }

    //认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        JwtToken jwtToken = (JwtToken) authenticationToken;
        return new SimpleAuthenticationInfo("任意对象","147258369",this.getName());
    }
}

Pontos a serem observados ao personalizar o Realm :

O primeiro ponto:

No método doGetAuthenticationInfo, seu valor de retorno:
return new SimpleAuthenticationInfo("任意对象","147258369",this.getName());
O objeto SimpleAuthenticationInfo deve se concentrar em:

O primeiro parâmetro são os dados do usuário salvos após a verificação bem-sucedida, que é um tipo de objeto.

O segundo parâmetro passado é o parâmetro a ser comparado com a senha:

Primeiro olhem essa foto, esse é o código quando simulei o login, vocês podem ver que passei o número da conta e senha para o JwtToken:

E JwtToken herda a classe UsernamePasswordToken, continue clicando no código-fonte:

Você pode ver que na classe UsernamePasswordToken, o método correspondente à conta e senha é obtido, e então continuo chamando o seguinte método no controlador de login para efetuar login:
Subject subject = SecurityUtils.getSubject();
subject.login(token);
Após a execução do código acima, ele entrará no método doGetAuthenticationInfo, e após a autenticação de login bem-sucedida (consultar a conta e a senha no banco de dados), se o segundo parâmetro de SimpleAuthenticationInfo for passado para mim para new JwtToken("123456789", " 147258369 ") Se o segundo parâmetro for diferente, a autenticação falhará. Pessoalmente, acho que o segundo tipo de parâmetro de SimpleAuthenticationInfo é :

Ao efetuar login, passe a senha da classe UsernamePasswordToken herdada por JwtToken:

Os nomes são iguais, então acho que serão comparados. Se forem inconsistentes, será relatado um erro: (palpite pessoal)

Se a autenticação falhar durante o login: retornará: exceção IncorrectCredentialsException

O segundo ponto (o momento de inserir o método doGetAuthorizationInfo):

O método doGetAuthorizationInfo não é chamado ativamente, mas passivamente. Quando houver uma anotação RequiresPermissions na interface solicitada, o método será executado para determinar se há uma permissão correspondente.

Processo de execução (solicite a interface com o caminho de interceptação): use o método de login shrio no filtro, insira o método doGetAuthenticationInfo para autenticação e solicite a interface após a autenticação ser bem-sucedida. Se houver permissão ou anotação de função de shiro na interface, então ele irá entrar no método doGetAuthorizationInfo para obter a permissão ou função correspondente e, em seguida, retornar à interface, se você tiver permissão, execute o método da interface

Terceiro ponto: quando estava testando, descobri que depois de adicionar a dependência AOP, o filtro também interceptaria o caminho de lançamento. No momento, não encontrei uma solução para isso, então não tenho escolha a não ser remover a dependência AOP (Não sei você. Será assim)

Quarto ponto:

3. Defina a classe de configuração do shrio

import org.apache.shiro.mgt.DefaultSessionStorageEvaluator;
import org.apache.shiro.mgt.DefaultSubjectDAO;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.servlet.Filter;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;


@Configuration
public class shiroConfig {

    //创建shirofilter,负责拦截所有请求
    @Bean(name = "shiroFilterFactoryBean")
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        Map<String, Filter> filters = new HashMap<>();
        filters.put("auth", new MyFilter());
        shiroFilterFactoryBean.setFilters(filters);
        //配置系统受限资源
        //配置系统公共资源
        Map<String,String> map  = new LinkedHashMap<>();
        // 在这里，我放行请求的的是我的登录接口
        map.put("/user/login","anon");
        // 其余接口我都要进行拦截 ，拦截器是 new MyFilter()
        map.put("/**","auth");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
        return shiroFilterFactoryBean;
    }

    //创建shiro安全管理器
    @Bean
    public DefaultWebSecurityManager getDefaultWebSecurityManager(Realm realm){
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();

        //关闭shiro自带的session
        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
        defaultWebSecurityManager.setSubjectDAO(subjectDAO);
        //配置realm
        defaultWebSecurityManager.setRealm(realm);
        return defaultWebSecurityManager;
    }

    //创建自定义realm
    @Bean
    public Realm getRealm(){
        CustomerRealm customerRealm = new CustomerRealm();
        //设置缓存管理器
        customerRealm.setCachingEnabled(false);
        customerRealm.setAuthenticationCachingEnabled(true);
        customerRealm.setAuthenticationCacheName("AuthenticationCache");
        customerRealm.setAuthorizationCachingEnabled(true);
        customerRealm.setAuthorizationCacheName("AuthorizationCache");
        return customerRealm;
    }

}

Pontos a serem observados sobre classes de configuração:

Ao configurar o caminho de interceptação e liberação, você não deve usar hashmap , mas usar LinkedHashMap, e depois ao configurar o path , coloque primeiro as solicitações que não precisam ser interceptadas, e geralmente coloque /** no final:

4. Configure o filtro:

package com.example.mp_pring.config.shiro;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMethod;

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

@Component
public class MyFilter extends BasicHttpAuthenticationFilter {
    /**
     * 执行登录认证
     *
     * @param request
     * @param response
     * @param mappedValue
     * @return
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        try {
            return executeLogin(request, response);
        } catch (Exception e) {
            System.out.println("JwtFilter过滤认证失败!");
            return false;
        }
    }

    @Override
    protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
        // token 一般都是放在请求头中
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String token = httpServletRequest.getHeader("Token");

        // 假设已经拿到token，并校验token了，如果校验不通过就直接 return false;
        // token校验成功，拿到账号跟密码
        JwtToken jwtToken = new JwtToken("123456789","147258369");
        try {
            // 提交给realm进行登入，如果错误他会抛出异常并被捕获
            Subject subject = SecurityUtils.getSubject();
            subject.login(jwtToken);
            // 如果没有抛出异常则代表登入成功，返回true
            return true;
        } catch (AuthenticationException e) {
            response.setCharacterEncoding("utf-8");
            response.getWriter().print("error");
            return false;
        }

    }

    /**
     * 对跨域提供支持
     * @param request
     * @param response
     * @return
     * @throws Exception
     */
    @Override
    protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));
        httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
        httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));
        // 跨域时会首先发送一个option请求，这里我们给option请求直接返回正常状态
        if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
            httpServletResponse.setStatus(HttpStatus.OK.value());
            return false;
        }
        return super.preHandle(request, response);
    }
}

5. Demonstração:

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletResponse;

/**
 * @Description:
 * @Author sk
 * @Date: 2023/4/4 18:40
 */
@Controller
@RequestMapping("/user")
public class UserControllerabc {


    @RequestMapping("/login")
    @ResponseBody
    public String login() throws Exception {
        JwtToken token = new JwtToken("123456789","147258369");
        try {
            Subject subject = SecurityUtils.getSubject();
            subject.login(token);
            System.out.println("认证成功");
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("认证失败");
        }
        return "success";
    }

    @RequestMapping("/test")
    @ResponseBody
    @RequiresPermissions("user:add:*")
    public String test() {
        Subject subject = SecurityUtils.getSubject();
        Object principal = subject.getPrincipal();
        PrincipalCollection principals = subject.getPrincipals();
        return "success:验证成功：user:add:*";
    }

    @RequestMapping("/test1")
    @ResponseBody
    @RequiresPermissions("user:add:a")
    public String test1() {
        return "success:验证成功：user:add:a";
    }
}

Login: http://localhost:8080/user/login

Entre na interface que requer permissão: http://localhost:8080/user/test ，http://localhost:8080/user/test 1

Essas duas interfaces requerem permissões user:add:* e user:add:a para acessar, neste caso:

O conjunto de permissões é user:add:* , portanto, logicamente falando, as interfaces test e test1 podem ser acessadas e * representa um curinga

Como você pode ver, todas as visitas foram bem-sucedidas.

Modificar permissões

Defino a permissão aqui para user:add:a , então não consigo acessar a interface de teste, tente uma onda:

Percebe-se que se não houver permissão, um erro será reportado diretamente

6. Arquivo de demonstração:

Este projeto foi carregado neste blog, você mesmo pode baixá-lo se precisar e pode usá-lo diretamente

7. Atenção! ! ! ! ! :

Depois de usar o shrio, usei diretamente as anotações de transação na camada do controlador, fazendo com que todas as interfaces neste controlador reportassem 404 (mas isso não apareceu no meu outro projeto).Após a verificação, é a execução aop do shrio e do Tempo Transacional. : Você pode consultar blogs de outras pessoas: Interface 404_@transactional controller_Muzi's Mumu's Blog-CSDN Blog

springboot integra shiro para completar a autenticação de token e os pontos que precisam de atenção

1. Token personalizado herda UsernamePasswordToken

2. Personalize o reino

Pontos a serem observados ao personalizar o Realm :

3. Defina a classe de configuração do shrio

Pontos a serem observados sobre classes de configuração:

4. Configure o filtro:

5. Demonstração:

6. Arquivo de demonstração:

7. Atenção! ! ! ! ! :

Acho que você gosta