Printemps de Démarrage de Sécurité avec Vaadin de Connexion

Après une semaine de lutte et de recherche, j'ai été en mesure d'obtenir ce travail. C'était très fatigant parce qu'il ya beaucoup d'informations et de solutions sur internet, la plupart d'entre eux à l'aide de xml de configuration basée sur une JSP ou à base de formulaire de connexion, jusqu'à maintenant, je ne pouvais pas trouver une autre solution sans un fichier de configuration xml en utilisant le framework Vaadin pour créer une page de connexion personnalisée.

Je ne peux pas garantir que c'est le meilleur de la pratique ou de la solution la plus simple. De plus je n'ai pas d'évaluer chaque partie, le mécanisme de connexion fonctionne aussi loin que je peux voir, mais peut-être il pourrait y avoir quelques problèmes que je n'ai pas encore découvert.

Peut-être que ça va aider quelqu'un qui font face au même problème, donc je vais poster ma réponse ici.

Tout d'abord, mes securityConfig:

@Resource(name = "authService")
private UserDetailsService userDetailsService;

@Override
protected void configure(HttpSecurity http) throws Exception {
                http.csrf().disable().
                        exceptionHandling().authenticationEntryPoint(new LoginUrlAuthenticationEntryPoint("/login")).accessDeniedPage("/accessDenied")
                        .and().authorizeRequests()
                        .antMatchers("/VAADIN/**", "/PUSH/**", "/UIDL/**", "/login", "/login/**", "/error/**", "/accessDenied/**", "/vaadinServlet/**").permitAll()
                        .antMatchers("/authorized", "/**").fullyAuthenticated();
            }

            @Bean
            public DaoAuthenticationProvider createDaoAuthenticationProvider() {
                DaoAuthenticationProvider provider = new DaoAuthenticationProvider();

                provider.setUserDetailsService(userDetailsService);
                provider.setPasswordEncoder(passwordEncoder());
                return provider;
            }

            @Bean
            public BCryptPasswordEncoder passwordEncoder() {
                return new BCryptPasswordEncoder();
            }

Vous devez désactiver le fscc, mais c'est pas un problème, vaadin a son propre fscc protection.

En outre, vous devez permettre à certaines URIs afin de vaadin peut accéder à ses ressources: /VAADIN/** est absolument nécessaire, je voudrais également recommandons pour permettre /vaadinServlet/**, /PUSH/** et /HEARTBEAT/**, mais cela dépend de ce que les parties de Vaadin vous utilisez.

Deuxième mon UserDetailsService:

@Service("authService")
public class AuthService implements UserDetailsService {

        @Autowired
        CustomUserRepository userRepository;

        @Override
        public UserDetails loadUserByUsername(String userName) throws UsernameNotFoundException {
            CustomUser user = userRepository.findCustomUserByUserName(userName);

            return user;
        }

}

La DaoAuthenticationProvider utilise le UserDetails' loadUserByUserName méthode pour obtenir un objet d'une classe qui implémente l' UserDetails interface. Sachez que chaque attribut est décrit dans le UserDetailsInterface ne doit pas être nul, sinon vous obtiendrez un NullPointerException jeté par la DaoAuthenticationProvider plus tard.

J'ai créé une Entité JPA qui met en œuvre la UserDetails interface:

@Entity
public class CustomUser implements UserDetails {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
Long id;
@ManyToMany(fetch = FetchType.EAGER)
Collection<Authorities> authorities;
String password;
String userName;
Boolean accountNonExpired;
Boolean accountNonLocked;
Boolean credentialsNonExpired;
Boolean enabled;
@Autowired
@Transient
BCryptPasswordEncoder passwordEncoder;
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
return authorities;
}
@Override
public String getPassword() {
return password;
}
@Override
public String getUsername() {
return userName;
}
@Override
public boolean isAccountNonExpired() {
return accountNonExpired;
}
@Override
public boolean isAccountNonLocked() {
return accountNonLocked;
}
@Override
public boolean isCredentialsNonExpired() {
return credentialsNonExpired;
}
@Override
public boolean isEnabled() {
return enabled;
}
public void setId(Long id) {
this.id = id;
}
public void setAuthorities(Collection<Authorities> authorities) {
this.authorities = authorities;
}
public void setPassword(String password) {
this.password = passwordEncoder.encode(password);
}
public void setUserName(String userName) {
this.userName = userName;
}
public void setAccountNonExpired(Boolean accountNonExpired) {
this.accountNonExpired = accountNonExpired;
}
public void setAccountNonLocked(Boolean accountNonLocked) {
this.accountNonLocked = accountNonLocked;
}
public void setCredentialsNonExpired(Boolean credentialsNonExpired) {
this.credentialsNonExpired = credentialsNonExpired;
}
public void setEnabled(Boolean enabled) {
this.enabled = enabled;
}
}

Plus les Autorités de l'Entité:

@Entity
public class Authorities implements GrantedAuthority {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
Long id;
String authority;
@Override
public String getAuthority() {
return authority;
}
public void setAuthority(String authority) {
this.authority = authority;
}
}

Évidemment, vous aurez à stocker les données de l'utilisateur dans la base de données avant que l'authentification fonctionne.

Dans Vaadin je ne pouvais pas sortir, il a travaillé en utilisant une INTERFACE utilisateur avec différents points de vue, je me suis donc retrouvé à l'aide de deux Isu un login et un autre pour l'application principale.

Dans Vaadin je pourrais définir le chemin de l'URI dans la classe d'annotation:

@SpringUI(path = "/login")
@Title("LoginPage")
@Theme("valo")
public class LoginUI extends UI {
//...
}

Avec cette configuration de mon écran de connexion est disponible à localhost:port/login
et ma principale de l'application à localhost:port/main.

Je de connexion de l'utilisateur par programme à l'intérieur d'un bouton.cliquez sur la méthode dans mon loginUI:

Authentication auth = new UsernamePasswordAuthenticationToken(userName.getValue(),password.getValue());
Authentication authenticated = daoAuthenticationProvider.authenticate(auth);
SecurityContextHolder.getContext().setAuthentication(authenticated);
//redirect to main application
getPage().setLocation("/main");

J'espère que cela a aidé certains d'entre vous.

OriginalL'auteur J. S.