Maison  >  Article  >  Java  >  Comment utiliser le cadre d'authentification et d'autorisation en Java pour implémenter l'authentification des utilisateurs et la gestion des autorisations ?

Comment utiliser le cadre d'authentification et d'autorisation en Java pour implémenter l'authentification des utilisateurs et la gestion des autorisations ?

WBOY
WBOYoriginal
2023-08-02 11:49:191951parcourir

Comment utiliser le cadre d'authentification et d'autorisation en Java pour implémenter l'authentification des utilisateurs et la gestion des autorisations ?

Introduction :
Dans la plupart des applications, l'authentification des utilisateurs et la gestion des autorisations sont des fonctions très importantes. Il existe de nombreux frameworks d'authentification et d'autorisation en Java disponibles pour les développeurs, tels que Spring Security, Shiro, etc. Cet article se concentrera sur la façon d'utiliser le framework Spring Security pour implémenter l'authentification des utilisateurs et la gestion des autorisations.

1. Introduction à Spring Security
Spring Security est un puissant framework de sécurité. Il s'agit d'un plug-in basé sur le framework Spring et peut être utilisé pour ajouter des fonctions d'authentification et d'autorisation. Spring Security fournit de nombreuses fonctions, telles que l'authentification des utilisateurs, la gestion des rôles, la gestion des autorisations, etc.

2. Authentification
L'authentification est le processus de vérification de l'identité de l'utilisateur. Dans Spring Security, l'authentification des utilisateurs peut être réalisée en configurant un fournisseur d'authentification.

  1. Fichier de configuration
    Tout d'abord, le fournisseur d'authentification doit être configuré dans le fichier de configuration Spring. Les fournisseurs d'authentification peuvent être définis à l'aide de l'élément 52b82e06fe430ab7919c3a04d90647be. 52b82e06fe430ab7919c3a04d90647be元素来定义认证提供程序。
<authentication-manager>
    <authentication-provider user-service-ref="userDetailsService"/>
</authentication-manager>
  1. 自定义认证提供程序
    接下来,需要自定义一个用户细节服务类,用于加载用户的详细信息,例如用户名、密码、角色等。可以实现UserDetailsService接口来实现这个类。
@Service
public class CustomUserDetailsService implements UserDetailsService {
    @Autowired
    private UserRepository userRepository;
    
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("User not found with username: " + username);
        }
        return new org.springframework.security.core.userdetails.User(user.getUsername(), user.getPassword(), getAuthorities(user.getRoles()));
    }
    
    private Collection<? extends GrantedAuthority> getAuthorities(Collection<Role> roles) {
        return roles.stream().map(role -> new SimpleGrantedAuthority(role.getName())).collect(Collectors.toList());
    }
}
  1. 数据库模型
    还需要创建数据库表来存储用户信息。可以创建usersroles
  2. CREATE TABLE users (
        id BIGINT AUTO_INCREMENT PRIMARY KEY,
        username VARCHAR(50) NOT NULL,
        password VARCHAR(100) NOT NULL
    );
    
    CREATE TABLE roles (
        id BIGINT AUTO_INCREMENT PRIMARY KEY,
        name VARCHAR(50) NOT NULL
    );
    
    CREATE TABLE user_roles (
        user_id BIGINT,
        role_id BIGINT,
        FOREIGN KEY (user_id) REFERENCES users(id),
        FOREIGN KEY (role_id) REFERENCES roles(id),
        PRIMARY KEY (user_id, role_id)
    );
    Fournisseur d'authentification personnalisé
  1. Ensuite, vous devez personnaliser une classe de service de détails utilisateur pour charger les informations détaillées de l'utilisateur, telles que le nom d'utilisateur, le mot de passe, le rôle, etc. Vous pouvez implémenter cette classe en implémentant l'interface UserDetailsService.
  2. @Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        @Autowired
        private UserDetailsService userDetailsService;
        
        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http
                .authorizeRequests()
                    .antMatchers("/").permitAll()
                    .antMatchers("/admin/**").hasRole("ADMIN")
                    .anyRequest().authenticated()
                    .and()
                .formLogin()
                    .loginPage("/login")
                    .permitAll()
                    .and()
                .logout()
                    .permitAll();
        }
        
        @Autowired
        public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
            auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
        }
        
        @Bean
        public PasswordEncoder passwordEncoder() {
            return new BCryptPasswordEncoder();
        }
    }
      Modèle de base de données

      Vous devez également créer des tables de base de données pour stocker les informations utilisateur. Deux tables, users et roles, peuvent être créées.

      @Configuration
      @EnableWebSecurity
      public class SecurityConfig extends WebSecurityConfigurerAdapter {
          @Override
          protected void configure(HttpSecurity http) throws Exception {
              http
                  .authorizeRequests()
                      .antMatchers("/admin/**").access("hasRole('ADMIN')")
                      .anyRequest().authenticated();
          }
      }
      1. Connexion utilisateur
        Configurez la page de connexion en tant que page de connexion de Spring Security.
      @RestController
      @RequestMapping("/api")
      public class ApiController {
          @PreAuthorize("hasRole('USER')")
          @GetMapping("/users")
          public List<User> getUsers() {
              // code here
          }
          
          @PreAuthorize("hasRole('ADMIN')")
          @PostMapping("/user")
          public User createUser(@RequestBody User user) {
              // code here
          }
      }
        3. Autorisation
      1. Après l'authentification réussie de l'utilisateur, vous pouvez utiliser Spring Security pour la gestion des autorisations.
      Fichier de configuration

      peut réaliser le contrôle d'accès à des URL spécifiques en configurant les règles d'URL et les autorisations d'accès.

      rrreee

      Autorisation d'annotation
        Vous pouvez utiliser une autorisation basée sur les annotations pour l'autorisation.
      1. rrreee
      Conclusion : 🎜Grâce à Spring Security, l'authentification des utilisateurs et la gestion des autorisations peuvent être facilement réalisées. Cet article explique comment utiliser le framework Spring Security pour configurer les fournisseurs d'authentification et d'autorisation, authentifier les utilisateurs en personnalisant les classes de service de détails utilisateur et les modèles de base de données, et gérer les autorisations en configurant les règles d'URL et les annotations. J'espère que cet article vous aidera à comprendre et à utiliser le cadre d'authentification et d'autorisation en Java. 🎜🎜Référence : 🎜🎜🎜Documentation officielle de Spring Security : https://docs.spring.io/spring-security/site/docs/5.4.1/reference/html5/🎜🎜

    Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

    Déclaration:
    Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn