[JAVA] Implémentation de la fonction de connexion par Spring Security (securityConfig)

Implémentation de la fonction d'authentification de connexion à l'aide de Spring Security (securityConfig)

procédure

  1. Ajoutez à pom.xml
  2. Création d'une classe securityConfig 3.UserDetailsServiceImpl: Créer une classe de service
  3. Créer le domaine LoginUser
  4. Créer une classe de référentiel pour l'utilisateur

1. Ajoutez à pom.xml

Ajoutez les deux suivants dans la balise

pom.xml



		<!-- Spring Security -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-security</artifactId>
		</dependency>
		<dependency>
			<groupId>org.thymeleaf.extras</groupId>
			<artifactId>thymeleaf-extras-springsecurity5</artifactId>
		</dependency>

2. Création d'une classe securityConfig

securityConfig.java



//importation omise

@Configuration //Classe de configuration
@EnableWebSecurity //Profitez des fonctionnalités Web de Spring Security
public class SecurityConfig extends WebSecurityConfigurerAdapter {


	@Autowired
	private UserDetailsService memberDetailsService;

	/**
	 *En remplaçant cette méthode
	 *"Paramètres de sécurité" pour des demandes spécifiques
	 *Vous pouvez définir des paramètres liés à l'ensemble, tels que des paramètres à ignorer.
	 *Plus précisément, désactivez les paramètres de sécurité pour les ressources statiques.
	 * 
	 * @see org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter#configure(org.springframework.security.config.annotation.web.builders.WebSecurity)
	 */
	@Override
	public void configure(WebSecurity web) throws Exception {
		web.ignoring()
			.antMatchers( "/css/**"
						, "/img/**"
						, "/js/**"
						, "/fonts/**");
	}

	/**
	 *En remplaçant cette méthode, vous pouvez définir l'autorisation et vous connecter./Vous pouvez définir les paramètres liés à la déconnexion.
	 * 
	 * @see org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter#configure(org.springframework.security.config.annotation.web.builders.HttpSecurity)
	 */
	@Override
	protected void configure(HttpSecurity http) throws Exception {

		http.authorizeRequests() //Paramètres d'autorisation
			.antMatchers("/","/login","/excuteLogin","/login/register").permitAll() //「/Autoriser tous les utilisateurs à passer comme
			.antMatchers().hasRole("ADMIN") // /admin/Les chemins commençant par ne sont accessibles que si vous êtes connecté avec les privilèges ADMIN("ROLE" lors de la définition des autorisations_Spécifiez la chaîne de caractères à l'exclusion de "")
            .antMatchers().hasRole("USER")
			//.antMatchers("/admin/**").hasRole("ADMIN") // /admin/Les chemins commençant par ne sont accessibles que si vous êtes connecté avec les privilèges ADMIN("ROLE" lors de la définition des autorisations_Spécifiez la chaîne de caractères à l'exclusion de "")
			//.antMatchers("/user/**").hasRole("USER") // /user/Les chemins commençant par ne sont accessibles que si vous êtes connecté avec les privilèges UTILISATEUR("ROLE" lors de la définition des autorisations_Spécifiez la chaîne de caractères à l'exclusion de "")
			.anyRequest().authenticated(); //D'autres chemins nécessitent une authentification

		http.formLogin() //Paramètres de connexion
			.loginPage("/login") //Chemin de transition vers l'écran de connexion(Si vous spécifiez un chemin nécessitant une authentification de connexion et que vous n'êtes pas connecté, vous serez transféré vers ce chemin.)
			.loginProcessingUrl("/excuteLogin") //Chemin vers la transition lorsque le bouton de connexion est enfoncé(Si vous passez à ici, vous serez automatiquement connecté.)
			.failureUrl("/login?error=true") //Chemin de transition vers l'échec de connexion
			.defaultSuccessUrl("/", true) //1er argument:Par défaut, le chemin vers la transition lorsque la connexion est réussie
			                                        //2ème argument: true :Passez toujours au chemin du premier argument après l'authentification
			                                        //         false:Même si vous n'êtes pas authentifié et que vous êtes passé à l'écran de connexion une fois, lorsque vous vous connectez, vous vous déplacez vers l'URL spécifiée
			.usernameParameter("email") //Demander le nom du paramètre du nom d'utilisateur utilisé pour l'authentification(Cette fois, j'utilise une adresse e-mail)
			.passwordParameter("password"); //Demander le nom du paramètre du mot de passe utilisé pour l'authentification
		
		http.logout() //Paramètres de déconnexion
			.logoutRequestMatcher(new AntPathRequestMatcher("/logout**")) //Chemin de transition lors de la déconnexion
			.logoutSuccessUrl("/login") //Chemin de transition après la déconnexion(Réglez l'écran de connexion ici)
			.deleteCookies("JSESSIONID") //Après vous être déconnecté, supprimez l'ID de session stocké dans le cookie
			.invalidateHttpSession(true); // true:Désactiver la session après la déconnexion false:Ne désactivez pas la session
		
	}

	/**
	 *Paramètres liés à "l'authentification".<br>
	 *Paramètres du "Service Détails de l'utilisateur" pour acquérir des utilisateurs authentifiés<br>
	 *Paramètres "Password Encoder" utilisés pour la vérification du mot de passe
	 * 
	 * @see org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter#configure(org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder)
	 */
	@Override
	public void configure(AuthenticationManagerBuilder auth) throws Exception {
		auth.userDetailsService(memberDetailsService)
			.passwordEncoder(new BCryptPasswordEncoder());
	}

    /**
     * <pre>
     *Renvoie l'implémentation au hachage avec l'algorithme bcrypt.
     *En spécifiant cela, lors du hachage du mot de passe et de la confirmation de correspondance
     * @Autowired
	 * private PasswordEncoder passwordEncoder;
	 *Si vous écrivez, ce sera DI.
     * </pre>
     * @Un objet d'implémentation haché avec l'algorithme return bcrypt
     */
    @Bean
    public PasswordEncoder passwordEncoder() {
    		return new BCryptPasswordEncoder();
    }
}

3. Créez UserDetailsServiceImpl

Une classe de service pour acquérir des informations utilisateur et effectuer une authentification de connexion sur la base de l'adresse e-mail entrée à partir du navigateur. Le code source est le suivant.

UserDetailsServiceImpl.java




@Service
public class UserDetailsServiceImpl implements UserDetailsService {
	/**Référentiel pour obtenir des informations de DB*/

	@Autowired
	private UserRepository userRepository;

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.springframework.security.core.userdetails.UserDetailsService#
	 * loadUserByUsername(java.lang.String)Rechercher dans la base de données, configurer et renvoyer les informations de connexion.
	 */
	@Override
	public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException {
		User user = userRepository.findByMailAddress(email);
		if (user == null) {
			throw new UsernameNotFoundException("L'e-mail n'est pas enregistré.");
		}
		//Exemple d'autorisation
		Collection<GrantedAuthority> authorityList = new ArrayList<>();
		authorityList.add(new SimpleGrantedAuthority("ROLE_USER")); //Accorder des privilèges d'utilisateur
//			if(member.isAdmin()) {
//				authorityList.add(new SimpleGrantedAuthority("ROLE_ADMIN")); //Accorder des privilèges d'administrateur
//			}
		return new LoginUser(user, authorityList);
	}	
}

4. Créer le domaine LoginUser

LoginUser.java



/**
 *Entité qui stocke les informations de connexion de l'administrateur.
 *
 */
public class LoginUser extends User {


	private static final long serialVersionUID = 1L;
	/**Informations de l'utilisateur*/
	private final com.example.domain.User user;

	/**
	 *En plus des informations normales de l'administrateur, définissez les rôles d'autorisation.
	 * 
	 * @param Administrator Informations sur l'administrateur
	 * @param AuthorityList Liste contenant les informations d'autorité
	 */
	public LoginUser(com.example.domain.User user, Collection<GrantedAuthority> authorityList) {
		super(user.getEmail(), user.getPassword(), authorityList);
		this.user = user;
	}

	public com.example.domain.User getUser() {
		return user;
	}
}

5. Création d'un UserRepository

Un référentiel pour rechercher des utilisateurs par adresse e-mail. Il est nécessaire de créer une classe de domaine utilisateur séparément, mais cette fois, elle est omise.

UserRepository.java




public class UserRepository {
	
	@Autowired
	private NamedParameterJdbcTemplate template;
	
	private static final RowMapper<User> USER_ROW_MAPPER = (rs, i) -> {
		User user = new User();
		user.setId(rs.getInt("id"));
		user.setName(rs.getString("name"));
		user.setEmail(rs.getString("email"));
		user.setPassword(rs.getString("password"));
		user.setZipcode(rs.getString("zipcode"));
		user.setAddress(rs.getString("address"));
		user.setTelephone(rs.getString("telephone"));

		return user;
	};
	
	/**
	 *Obtenez 1 information utilisateur à partir de l'adresse e-mail
	 * @param email
	 * @return List<User>
	 */
	public User findByMailAddress(String email) {
		String sql = "select id,name,email,password,zipcode,address,telephone from users where email = :email";
		
		SqlParameterSource param = new MapSqlParameterSource().addValue("email", email);
		
		List<User> userList = template.query(sql, param, USER_ROW_MAPPER);
		
		if(userList.size() == 0) {
			return null;
		}
		return userList.get(0);
	}

Remarque 1: lors de la connexion avec Spring Security implémenté, les informations de mot de passe stockées dans la base de données doivent être hachées. Consultez un autre article pour le hachage de mot de passe lors de l'enregistrement des informations utilisateur.

Recommended Posts

Implémentation de la fonction de connexion par Spring Security (securityConfig)
Fonction de connexion avec Spring Security
Mise en œuvre de la fonction d'authentification avec Spring Security ②
Implémentez la fonction d'authentification avec Spring Security ③
Mise en œuvre de la fonction d'authentification avec Spring Security ①
Partie 1: Essayez d'utiliser la connexion OAuth 2.0 prise en charge par Spring Security 5 avec Spring Boot
Fonction de connexion
Implémentation de la fonction de connexion Ruby on Rails (Session)
Partie 2: Comprendre (approximativement) le flux de processus de la connexion OAuth 2.0 prise en charge par Spring Security 5
Implémentation de la fonction DM
Essayez d'implémenter la fonction de connexion avec Spring Boot
[JQuery] Procédure d'implémentation de la fonction de saisie semi-automatique [Java / Spring]
Créez une fonction de connexion / déconnexion avec Spring Security selon le guide officiel de Spring [pour les débutants]
Partie 3: Comprendre (en profondeur) le flux de processus de la connexion OAuth 2.0 prise en charge par Spring Security 5
Implémentation de la fonction de connexion Ruby on Rails (édition de devise)
À propos de l'authentification Spring Security
Implémentation de la fonction de commentaire (Ajax)
Suivez l'implémentation de la fonction (Ajax)
Implémentation de la fonction de prévisualisation d'image
Spring Security soulève 403 interdits
Mise en œuvre de la fonction de pagénation
Avec Spring Boot, hachez le mot de passe et utilisez l'enregistrement des membres et la sécurité Spring pour implémenter la fonction de connexion.
Implémentez la fonction de connexion dans Rails simplement avec le nom et le mot de passe (1)
Implémentez la fonction de connexion dans Rails simplement avec juste un nom et un mot de passe (2)
[Ruby on Rails] Implémenter la fonction de connexion par add_token_to_users avec l'API
Connectez-vous avec HttpServletRequest # login dans Spring Security dans l'environnement Servlet 3.x