Personnalisé WebSecurityConfigurerAdapter

Tout d'abord, les deux approches sont utilisées à des fins différentes et ne sont pas interchangeables.

Cas 1:

UserDetailsService est utilisé uniquement comme DAO pour localiser des informations de l'utilisateur par votre authentification et basé sur cette info authentifier l'utilisateur, pas d'authentification devrait être fait dans les UserDetailsService, juste d'accès aux données.
Les spécifications de mentionner clairement. C'est ce que vous cherchez.

Case2:

AuthentictionProvider sur l'autre main est utilisée pour offrir personnalisé méthode d'authentification, par exemple si vous voulez à la coutume de s'authentifier sur des domaines autres que les login et mot de passe, vous pouvez le faire que par la mise en œuvre de AuthentictionProvider et la fourniture de cet objet à votre AuthenticationManagerBuilder. Je ne pense pas que ce est ce que vous voulez faire dans votre projet. Vous êtes à la recherche pour mettre en œuvre votre authentification basée sur les utilisateurs stockées dans la base de données en utilisant le login et le mot de passe qui est par défaut.
Au-dessus de Cas 1 lorsque vous avez mis en place juste UserDetailsService, de l'instance de AuthentictionProvider a été créé pour vous dans AuthenticationManager par le conteneur et il a été DaoAuthenticationProvider depuis que vous avez fourni UserDetailsService qui n'est rien d'autre que de DAO dans votre système qui est utilisé pour la restauration de l'utilisateur pour l'authentification.

Maintenant à votre mise en œuvre,
dans votre configuration, au lieu de :

  @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
//       auth.userDetailsService(new AdminSecurityService());
        auth.authenticationProvider(new AdminSecurityAuthenticationProvider());
    }

faire quelque chose comme ceci

@Autowired
private CustomUserDetailsService userDetailsService;

 @Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth.userDetailsService(userDetailsService);

}

et votre CustomUserDetailsService a à mettre en œuvre org.springframework.security.core.userdetails.UserDetailsService

@Service
public class CustomUserDetailsService implements UserDetailsService {
private final AdminRepository userRepository;
@Autowired
public CustomUserDetailsService(AdminRepository userRepository) {
this.userRepository = userRepository;
}
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
Admin user = userRepository.findByLogin(username);
if (user == null) {
throw new UsernameNotFoundException(String.format("User %s does not exist!", username));
}
return new UserRepositoryUserDetails(user);
}
private final static class UserRepositoryUserDetails extends Admin implements UserDetails {
private static final long serialVersionUID = 1L;
private UserRepositoryUserDetails(User user) {
super(user);
}
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
return AuthorityUtils.createAuthorityList("ROLE_USER");
}
@Override
public String getUsername() {
return getLogin();//inherited from user
}
@Override
public boolean isAccountNonExpired() {
return true;//not for production just to show concept
}
@Override
public boolean isAccountNonLocked() {
return true;//not for production just to show concept
}
@Override
public boolean isCredentialsNonExpired() {
return true;//not for production just to show concept
}
@Override
public boolean isEnabled() {
return true;//not for production just to show concept
}
//getPassword() is already implemented in User.class
}
}

bien sûr, la mise en œuvre est à vous, mais vous devez être en mesure de fournir à l'utilisateur un mot de passe, et le reste des méthodes de cette interface basée sur l'extrait de l'utilisateur (Admin.class dans votre cas). Espérons que cela aide. Je n'ai pas exécuter cet exemple donc, si j'ai fait quelques fautes de frappe aller de l'avant et de se demander si quelque chose ne fonctionne pas. Je voudrais également vous débarrasser de cette "AuthentictionProvider" de votre projet si vous n'en avez pas besoin.

Ici vous avez obtenu de la documentation:http://docs.spring.io/spring-security/site/docs/4.0.0.RC1/reference/htmlsingle/#tech-userdetailsservice

Après les commentaires:
Vous pouvez définir PasswordEncoder dans votre méthode configure (sans trop de tracas juste à faire:

 @Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder);
}
@Bean
public PasswordEncoder passwordEncoder(){
PasswordEncoder encoder = new BCryptPasswordEncoder();
return encoder;
}

Vous pouvez le faire parce que vous obtenez l'accès à AbstractDaoAuthenticationConfigurer retourné à partir de auth.userDetailsService(userDetailsService) et il vous permet de configurer DaoAuthenticationProvider, qui est votre fournisseur de choix lorsque vous choisissez d'utiliser UserDetailsService.
Vous avez raison PasswordEncoder est situé dans AuthenticationProvider mais vous n'avez pas à
mettre en œuvre AuthenticationProvider suffit d'utiliser convineince objet qui est retourné à partir de auth.userDetailsService(userDetailsService) et de définir votre codeur de cet objet qui va passer à AuthenticationPriovider dans votre cas DaoAuthenticationProvider qui a déjà été créée pour vous.
Tout comme roadrunner mentionné dans le commentaire que vous avez rarement besoin de mettre en place votre propre AuthenticationProvider généralement plus de la configuration de l'authentification des ajustements peuvent être effectués avec l'utilisation de AbstractDaoAuthenticationConfigurer qui, comme mentionné ci-dessus est renvoyé à partir de auth.userDetailsService(userDetailsService).

"Et si jamais je voulais ajouter un mot de passe de cryptage. Et si jamais je voulais faire d'autres authentification (comme vérifier si l'utilisateur est verrouillé, active, l'utilisateur est toujours connecté, etc. [à l'exclusion de hachage de mot de passe]) utilisent le AuthenticationProvider."

Pas de ce qui est fait pour vous dans le cadre de la norme mécanisme d'authentification
http://docs.spring.io/autorepo/docs/spring-security/3.2.0.RELEASE/apidocs/org/springframework/security/core/userdetails/UserDetails.html
Si vous regardez l'interface UserDetails vous verrez que si aucune des méthodes ci-dessus renvoie false authentification échoue.
La mise en œuvre de AuthenticationProvider est vraiment nécessaire dans très atypique cas. Tous les trucs standard est assez bien couverts par le cadre .

OriginalL'auteur mariubog

Tout d'abord, je voudrais vous encourager à lire sur Chaîne De Sécurité Des Services De Base.

Une clé dans cette situation est AuthenticationManager qui est responsable de décider si l'utilisateur est authentifié ou non. C'est ce que vous configurez avec AuthenticationManagerBuilder. Principal de la mise en œuvre au Printemps est ProviderManager qui permet de définir plusieurs mécanismes d'authentification dans une seule application. L'utilisation la plus courante est le cas il y en a un, mais il est toujours géré par cette classe. Chacun de ces multiples mécanismes d'authentification est représenté par un autre AuthenticationProvider. ProviderManager prend une liste de AunthenticationProviders un parcourt pour voir si l'un d'eux peut authentifier l'utilisateur.

Ce que vous êtes intéressé est DaoAuthenticationProvider. Comme son nom l'indique, il permet d'utiliser un Objet d'Accès aux Données pour authentifier l'utilisateur. Il utilise une interface standard pour ces DAO - une UserDetailsService. Il y a un défaut de mise en œuvre disponibles au Printemps de Sécurité, mais généralement c'est ce que vous voulez mettre en œuvre vous-même. Tout le reste est fourni.

Aussi, le bit de configuration que vous avez besoin est totalement indépendante de Printemps de Démarrage. C'est comment vous pouvez le faire en XML:

<sec:authentication-manager >
<sec:authentication-provider user-service-ref="myUserDetailsService" />
</sec:authentication-manager>

Et en Java, ce sera:

@Configuration
@EnableWebSecurity
public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {
@Autowired
private UserDetailsService myUserDetailsService;
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.userDetailsService(myUserDetailsService);
}
}

Comme par UserDetails mise en œuvre, généralement celui fourni par Spring Security est assez. Mais vous pouvez également mettre en place votre propre en cas de besoin.

Habituellement, vous voudrez aussi un PasswordEncoder. Un bon, comme BCryptPasswordEncoder:

@Configuration
@EnableWebSecurity
public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {
@Autowired
private UserDetailsService userDetailsService;
@Autowired
private PasswordEncoder passwordEncoder;
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.userDetailsService(userDetailsService)
.passwordEncoder(passwordEncoder);
}
}

Avis que c'est un @Bean, de sorte que vous pouvez @Autowire dans votre UserRepository pour encoder les mots de passe utilisateur que vous enregistrez dans la base de données.

OriginalL'auteur Roadrunner