Recentemente, eu estava trabalhando em um projeto de aplicativo. Eu desenvolvi sozinho em segundo plano. As funções básicas de login, registro e verificação de permissão não foram incluídas na primeira etapa do desenvolvimento na ordem de desenvolvimento de tarefas. Agora, algumas funções relacionadas aos negócios foram concluídas, mas o portal do usuário ainda não foi implementado. Isso mostra apenas que eu estava muito ansioso quando analisei os requisitos e deixei o portal de usuários mais básico para trás.
Agora você precisa adicionar funções de login de usuário e verificação de permissão com base no código existente.
Em relação à verificação de login e permissão, referindo -se à experiência anterior de desenvolvimento do iOS, o lado do aplicativo fornece nome de usuário e senha para trocar de tokens e é necessária permissão de login para cada solicitação através do token trocado.
Agora, por outro lado, preciso considerar os seguintes problemas:
1. Como cumprir facilmente a implementação dessas funções no código das funções existentes, para que o código existente não seja muito alterado e não haverá aborrecimentos para implementar a verificação de permissão no futuro.
2. Como gerar tokens com base no nome de usuário e na senha e como distinguir a correção do cliente que fornece tokens em funções que exigem permissões
Primeiro de tudo, enfrentando o primeiro problema, de acordo com a experiência, a solução convencional são filtros e interceptores. Se o login e a verificação de permissão forem colocados no acordo de requisitos, desde que os URLs das funções posteriores recebam um determinado padrão, o uso de filtros ou interceptores será bem -sucedido. Mas agora estou enfrentando URLs que não têm design ou especificações no estágio inicial, por isso não quero enfrentar o uso de filtros ou interceptores.
Além das soluções convencionais acima, a Spring AOP se tornou uma arma para resolver esse tipo de problema. Ele usa programação de face-tangente para fornecer uma pré-notação para todos os métodos que requerem verificação de permissão. No entanto, como o URL, o nome ou o método da classe não é regular, pensei em uma anotação personalizada e verificar permissões para todos os métodos que adicionam anotações personalizadas.
1. Como você já pensou em usar a Spring AOP, o primeiro passo é ativar a AOP no arquivo de configuração da primavera
// Abra aOP
<AOP: AspectJ-AutoProxy />
A configuração acima é baseada na derramamento de pacotes de jar relacionados à mola no projeto e introduzindo o URL da AOP no cabeçalho do arquivo de configuração.
2. Em seguida, vamos definir uma anotação personalizada primeiro
@Target ({elementType.method, elementType.type}) @retention (retentionpolicy.runtime) public @interface userAccess {}3. Não podemos nos apressar para fazer funções de verificação de permissão, porque nosso token ainda não gerou uma solução.
Para geração de token, é considerado um único sinal, para que os tokens não possam ser corrigidos o tempo todo. Caso contrário, a qualquer momento, desde que você tenha tokens, pelo menos duas pessoas poderão usar a mesma conta ao mesmo tempo, o que não é permitido em nossos negócios no momento. No final, escolhi o "nome de usuário + senha + tempo de login" para fazer a criptografia MD5 como um token (existem muitos métodos, como o UUID ao garantir a singularidade e a mutabilidade). Gere tokens quando o nome de usuário e a senha forem verificados com sucesso e salve o token na forma de pares de valor-chave de "Nome de usuário: Token" e "Token: User" (também pode ser salvo no banco de dados) e finalmente retornar o token ao cliente.
O código a seguir é apenas um exemplo simples:
@ServicePublic Class LogInservice {/*** Armazene "Nome do usuário: token" par de valores-chave*/mapa estático public <string, string> tokenmap = new hashmap <string, string> ();/*** store "token: user" key-value par*/public static mape public string login (nome da string, senha da string) {System.out.println (nome+"-----"+senha);/*** Verifique se o login é bem-sucedido* 1. Login com sucesso* 1.1. Gere o token correspondente e atualize * 1.2. Jogue uma exceção se falhar*/string token = tokenmap.get (nome); usuário do usuário = null; if (token == null) {user = new user (); user.setName (name); user.setpassword (senha); system.out.println ("novo usuário login ");} else {user = LoginUserMap.get (token); loginUserMap.remove (token); System.out.println (" Atualize o token de login do usuário ");} token = md5util.md5 (name+senha+a date (). token); system.out.println ("atualmente"+tokenmap.size ()+"usuários"); para (Usuário u: LoginUserMap.values ()) {System.out.println (u.getName ()+":"+u.getpassword ());} token;}}}4. Ao mesmo tempo, nosso cliente obteve um token após o login. Enquanto carregamos o token em todas as solicitações que exigem permissão, podemos obter com êxito a resposta (sugestão: para facilitar a codificação do aplicativo), o token não pode ser transportado para os cuidados de solicitação, e o código existente não precisa ser as principais alterações e não precisamos de cuidar do futuro. Acabei de encontrar um método para fazer um experimento:
@Controlador@requestmapping ("/login") classe pública Logincontroller {@aUTowiredPrivate LogInservice LogInservice; @Useraccess @requestmapping (value = "/loginin", método = requestMethod.get) public @ResponsoBodyBody String login (httpServletRequest request) {string name = request.getParameter ("name"); string senha = requestParameter ("senha"); string token = logInserice.login (, names;Observe que a parte em negrito é personalizar a anotação. É impossível ter tokens para os parâmetros de solicitação da função de login; portanto, não importa quantas vezes seja verificada, ela não pode ser passada. Apenas faça um exemplo. @UserAccess Add apenas funciona sobre a funcionalidade que requer verificação de permissão
5. Anotação personalizada agora é um bom ponto de entrada
@Component@Aspecpublic Class PermissionAspect {// Defina a anotação personalizada como o ponto de entrada @Before ("@anotação (com.example.chap01.annotation.userAccess)") public void CheckPermission (junção junção) lança excepção {System.out.println ("pré-notification"; jun juntpoint.getargs (); httpServletRequest request = (httpServletRequest) args [0]; string token = request.getParameter ("token"); system.out.println ("token pré-notificação:"+token); Usuário = LogInservice.LoginUserMap.get (token); if (user == null) {System.out.println ("A verificação não é passada!"); lançar uma nova exceção ("sem permissão");}}}}}Neste ponto, as funções de login e verificação de permissão estão todas concluídas.
Além disso, o código -fonte do Github pessoal está anexado: https://github.com/zw201913/applogin.git
O exposto acima é tudo sobre este artigo, espero que seja útil para o aprendizado de todos.