Spring MVC integra o método de controle de permissão Shiro

O Apache Shiro é uma estrutura de segurança de código aberto poderoso e flexível que lida com processos de controle de segurança comuns em aplicativos de nível corporativo, como autenticação, autorização, gerenciamento de sessões e criptografia em um nível de granulação fina. O objetivo principal do Apache Shiro é a facilidade de uso e o entendimento. Às vezes, o controle do processo de segurança pode ser muito complicado, o que é uma dor de cabeça para os desenvolvedores, mas não significa necessariamente isso. As estruturas devem mascarar a complexidade o máximo possível e expor uma API concisa e intuitiva, simplificando assim o trabalho dos desenvolvedores e garantindo sua segurança de aplicativos. Desta vez, falaremos sobre como usar o Shiro para implementar o controle de permissão nos aplicativos da Web da primavera.

Função

O Apache Shiro é uma estrutura abrangente de segurança de aplicativos com muitos recursos. A figura a seguir mostra as funções mais importantes em Shiro:

Os principais objetivos de Shiro são "quatro pilares da segurança de aplicativos" - autenticação, autorização, gerenciamento de sessões e criptografia:

1. Autenticação: isso é comumente conhecido como "login", a fim de provar o proprietário do comportamento do usuário.
2. Autorização: o processo de controle de acesso, ou seja, determinando quais usuários podem acessar qual conteúdo.
3. Gerenciamento de sessão: as sessões específicas do usuário podem ser gerenciadas mesmo em aplicativos que não sejam da Web, o que é um destaque do Shiro.
4. Tecnologia de criptografia: use algoritmos de criptografia para garantir a segurança dos dados e é muito fácil de usar.

Arquitetura

De uma perspectiva holística, a arquitetura de Shiro tem três conceitos principais: Assunto (sujeito, ou seja, usuário), gerente de segurança (gerente de segurança) e reinos (domínio). A figura a seguir descreve a relação entre esses componentes:

Esses componentes podem ser entendidos da seguinte forma:

1. Assunto: O assunto é uma coleta específica de dados do usuário que está operando atualmente. O sujeito pode ser uma pessoa, ou pode representar um serviço de terceiros, daemon, tarefas de tempo ou algo assim, ou seja, quase tudo o que interage com o aplicativo.
2. Gerente de Segurança: É o núcleo da arquitetura de Shiro e desempenha um papel semelhante a um "guarda -chuva". É principalmente responsável por coordenar vários componentes internos para formar uma rede de segurança.
3. Realms (domínio): a "ponte" entre os dados de segurança do shiro e o aplicativo. A Shiro obterá esses dados da Realms quando for necessário interagir com dados relacionados à segurança, como contas de usuário para executar autenticação e autorização.

Preparação de dados

Nos aplicativos da Web, o principal controle sobre a segurança são funções, recursos e permissões (qual a função pode acessar quais recursos). Um usuário pode ter várias funções e uma função também pode acessar vários recursos, ou seja, uma função pode corresponder a várias permissões. Para implementar o design do banco de dados, precisamos construir pelo menos 5 tabelas: tabela de usuários, tabela de papéis, tabela de recursos, tabela de recursos de função, tabela de solo de usuário. A estrutura dessas 5 tabelas é a seguinte:

Tabela de usuários:

Lista de papéis:

Tabela de recursos:

Tabela de recursos de função:

Tabela-sol-sol:

A classe Pojo correspondente é a seguinte:

 /*** Usuário*/Public Class User {ID inteiro privado; Nome de usuário privado de string; senha de sequência privada; // getter & setter ...}

 /*** função*/função da classe pública {private string id; Rolename privado de string;}

 /*** Resource*/public class Resource {private String ID; private string resname;}

 /*** ROUS-RESOURCE*/Public Class ROLERES {private String ID; private string papeid; Private String resid;}

 /*** Role do usuário*/classe pública userrole {private string ID; private string userID; private string papeid;}

Para etapas detalhadas para integrar a primavera e o Shiro, consulte o meu blog "Integrando o Apache Shiro em aplicativos de primavera". Aqui adicionamos: você precisa apresentar as dependências de Shiro com antecedência, abrir mvnrepository.com e pesquisar Shiro. Precisamos das três primeiras dependências, ou seja, Shiro-Core, Shiro-Web e Shiro-Spring. Tomando o projeto MAVEN como exemplo, adicione as seguintes dependências no nó <dependencies> em pom.xml :

 <Depencency> <PuerpId> org.apache.shiro </frupiid> <ArtifactId> shiro-core </sutifactId> <versão> 1.4.0 </versão> </dependency> <pendency> <puriD> org.apache.shiro </groupid> <ArtifactId> Shiro-wiro> </artiftId. <PuerpId> org.apache.shiro </frugiD> <TRAFACTID> shiro-spring </artifactId> <versão> 1.4.0 </version> </dependency>

No application-context.xml você precisa configurar shiroFilter como este:

 <!-Configure a classe de fábrica do filtro de Shiro, o ID-shirofilter deve ser consistente com os filtros que configuramos em web.xml-> <bean id = "shirofilter"> <propriedades name = "SecurityManager" ref = "SecurityManager"/> <!-Login Page-> <Nome da propriedade = "Loginurl") name = "succcessurl" value = "/index"/> <!-acesso ilegal às páginas saltadas-> <nome da propriedade = "UNAuthorizedurl" value = "/403"/> <!-Permission Configuration-> <Nome da propriedade = "FilterChaindefinitions"> <! Para os recursos ignorados acima, todos os outros recursos precisam ser autenticados antes que possam ser acessados ->/** = authc </value> </propriedade> </bean>

Em seguida, você precisa definir o reino. O domínio personalizado é integrado da classe AuthorizingRealm :

 classe pública MyRealm estende AutorizandoRealm {@AUTOWIRED UserService privado UserService; / *** Permissão de verificação*/ @Override Autorização protegidaInfo DogetAuthorizationInfo (PrincipalCollection PrincipalCollection) {String loginName = SecurityUtils.getSubject (). GetPrincipal (). Tostring (); if (loginName! = null) {string userId = securityUtils.getSubject (). getSession (). getAttribute ("userSessionId"). tostring (); // Objeto de informação de permissão, usado para armazenar todas as funções e permissões do usuário encontrado SimpleAuthorizationInfo info = new SimpleAuthorizationInfo (); // coleção de função de usuário shirouser shirouser = (shirouser) principalcollection.getPrimaryPrincipal (); info.setRoles (shirouser.getRoles ()); info.addstringPermissions (shirouser.geturlset ()); retornar informações; } retornar nulo; } / ** * Função de retorno de chamada de autenticação, ligue * / Protected AuthenticationInfo DogetAuthenticationInfo (Token AuthenticationToken) {String userName = (String) token.getPrincipal (); Usuário do usuário = novo usuário (); sysuser.setUsername (nome de usuário); tente {list <sysuser> usuários = userservice.findbynames (usuário); List <String> rolelist = userservice.SelectROLENAMELISTBYUSERID (Users.get (0) .getId ()); if (users.size ()! = 0) {string pwd = users.get (0) .getpassword (); // Depois de todas as verificações, coloque as informações do usuário na sessão session = SecurityUtils.getSubject (). GetSession (); session.setAttribute ("UserSession", Users.get (0)); session.setAttribute ("UserSessionId", Users.get (0) .getId ()); session.setAttribute ("userroles", org.apache.commons.lang.stringutils.join (rolelist, ",")); Retornar novo SimpleAuthenticationInfo (nome de usuário, usuários.get (0) .getpassword ()); } else {// O usuário não foi encontrado lançar novo UnknownAccountException (); }} catch (Exceção e) {System.out.println (E.getMessage ()); } retornar nulo; } /*** Atualize o cache de informações de autorização do usuário. */ public void clearcacheDauthorizationInfo (diretores principais) {super.clearcacheDauthorizationInfo (diretores); } /*** Atualize o cache de informações do usuário. */ public void clearcachedauthenticationInfo (diretores principais) {super.clearcachedauthenticationInfo (diretores); } /*** Limpe o cache de informações de autorização do usuário. */ public void clearallcachedAuthorizationInfo () {getAuthorizationCache (). Clear (); } /*** Limpe o cache de informações do usuário. */ public void clearallcacheDauthenticationInfo () {getAuthenticationCache (). Clear (); } / *** Limpe todos os caches* / public void clearcache (diretores principais e diretores) {super.clearcache (diretores); } / *** Limpe todos os caches de autenticação* / public void clearallcache () {clearallcachedauthenticationInfo (); ClearallCachedAuthorizationInfo (); }}

Por fim, defina um controlador para o login do usuário aceitar solicitações de login de usuário:

 @ControllerPublic Classe UserController {/*** Login do usuário*/@PostMapping ("/login") public String Login (Usuário @Valid, Usuário de BindingResult BindingResult, Redirectattributes RedirectatRributes) {Try {if (BindingResult.haserrors () (LOGRUNHT (LOGREST (LOGRESTTRORES) {Return) {Logern; } // Use a ferramenta de permissão para autenticação, após o login com sucesso, pule para o sucesso definido no shirofilter securityutils.getsubject (). Login (new UsernamePasswordToken (user.getUserName (), user.getpassword ()); retornar "Redirecionar: índice"; } catch (autenticaçãoException e) {redirectattributes.addflashattribute ("mensagem", "nome de usuário ou senha de erro"); retornar "Redirecionar: login"; }}/*** logout*/@getMapping ("/logout") public string logout (redirectattributes redirectattributes) {securityutils.getSubject (). Logout (); retornar "Redirecionar: login"; }}

O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.