Application de connexion Java Web simple utilise Spring MVC, Spring Security et Spring JDBC

package org.o7planning.socialsecurity.config;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.support.ResourceBundleMessageSource;
import org.springframework.core.env.Environment;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Configuration
@ComponentScan("org.o7planning.socialsecurity.*")
@EnableTransactionManagement
// Load to Environment.
@PropertySource("classpath:datasource-cfg.properties")
public class ApplicationContextConfig {

   // The Environment class serves as the property holder
   // and stores all the properties loaded by the @PropertySource

   // Lưu trữ các giá thuộc tính load bởi @PropertySource.
   @Autowired
   private Environment env;



   @Bean
   public ResourceBundleMessageSource messageSource() {
       ResourceBundleMessageSource rb = new ResourceBundleMessageSource();
       // Load property in message/validator.properties
       rb.setBasenames(new String[] { "messages/validator" });
       return rb;
   }

   @Bean(name = "viewResolver")
   public InternalResourceViewResolver getViewResolver() {
       InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
       viewResolver.setPrefix("/WEB-INF/pages/");
       viewResolver.setSuffix(".jsp");
       return viewResolver;
   }

   @Bean(name = "dataSource")
   public DataSource getDataSource() {
       DriverManagerDataSource dataSource = new DriverManagerDataSource();

       // See: datasouce-cfg.properties
       // Xem: datasouce-cfg.properties
       dataSource.setDriverClassName(env.getProperty("ds.database-driver"));
       dataSource.setUrl(env.getProperty("ds.url"));
       dataSource.setUsername(env.getProperty("ds.username"));
       dataSource.setPassword(env.getProperty("ds.password"));

       System.out.println("## getDataSource: " + dataSource);

       return dataSource;
   }

   // Transaction Manager
   @Autowired
   @Bean(name = "transactionManager")
   public DataSourceTransactionManager getTransactionManager(DataSource dataSource) {
       DataSourceTransactionManager transactionManager = new DataSourceTransactionManager(dataSource);

       return transactionManager;
   }
 
 
}

package org.o7planning.socialsecurity.config;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration;

import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;

public class SpringWebAppInitializer implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        AnnotationConfigWebApplicationContext appContext = new AnnotationConfigWebApplicationContext();
        appContext.register(ApplicationContextConfig.class);

        ServletRegistration.Dynamic dispatcher = servletContext.addServlet("SpringDispatcher",
                new DispatcherServlet(appContext));
        dispatcher.setLoadOnStartup(1);
        dispatcher.addMapping("/");
    }

}

package org.o7planning.socialsecurity.config;

import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.List;

import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcConfigurerAdapter {

  private static final Charset UTF8 = Charset.forName("UTF-8");

  // Config UTF-8 Encoding.
  @Override
  public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
      StringHttpMessageConverter stringConverter = new StringHttpMessageConverter();
      stringConverter.setSupportedMediaTypes(Arrays.asList(new MediaType("text", "plain", UTF8)));
      converters.add(stringConverter);

      // Add other converters ...
  }

  // Static Resource Config
  // equivalents for <mvc:resources/> tags
  @Override
  public void addResourceHandlers(ResourceHandlerRegistry registry) {
      registry.addResourceHandler("/css/**").addResourceLocations("/css/").setCachePeriod(31556926);
      registry.addResourceHandler("/img/**").addResourceLocations("/img/").setCachePeriod(31556926);
      registry.addResourceHandler("/js/**").addResourceLocations("/js/").setCachePeriod(31556926);
  }

  // Equivalent for <mvc:default-servlet-handler/> tag
  @Override
  public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
      configurer.enable();
  }

}

package org.o7planning.socialsecurity.config;

import org.springframework.security.web.context.AbstractSecurityWebApplicationInitializer;

// Config: Spring Security Filter.
public class SpringSecurityInitializer extends AbstractSecurityWebApplicationInitializer {

    // Do nothing

}

package org.o7planning.socialsecurity.config;

import org.o7planning.socialsecurity.service.MyUserDetailsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.social.security.SpringSocialConfigurer;

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

   @Autowired
   private MyUserDetailsService myUserDetailsService;

   @Autowired
   public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {

       // Set Service load Users in Database
       auth.userDetailsService(myUserDetailsService);
   }

   @Override
   protected void configure(HttpSecurity http) throws Exception {

       http.csrf().disable();

       // The pages does not require login
       http.authorizeRequests().antMatchers("/", "/signup", "/login", "/logout").permitAll();

       // /userInfo page requires login as ROLE_USER  
       // If no login, it will redirect to /login page.
       http.authorizeRequests().antMatchers("/userInfo").access("hasRole('ROLE_USER')");

       // Form Login config
       http.authorizeRequests().and().formLogin()//
               // Submit URL of login page.
               .loginProcessingUrl("/j_spring_security_check") // Submit URL
               .loginPage("/login")//
               .defaultSuccessUrl("/userInfo")//
               .failureUrl("/login?error=true")//
               .usernameParameter("username")//
               .passwordParameter("password");

       // Logout Config
       http.authorizeRequests().and().logout().logoutUrl("/logout").logoutSuccessUrl("/");

       // Spring Social Config.
       http.apply(new SpringSocialConfigurer())
               //
               .signupUrl("/signup");

   }
   

   // This bean is load the user specific data when form login is used.
   @Override
   public UserDetailsService userDetailsService() {
       return myUserDetailsService;
   }
   
}

package org.o7planning.socialsecurity.config;

import javax.sql.DataSource;

import org.o7planning.socialsecurity.dao.MyUserAccountDAO;
import org.o7planning.socialsecurity.signup.MyConnectionSignUp;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.security.crypto.encrypt.Encryptors;
import org.springframework.social.UserIdSource;
import org.springframework.social.config.annotation.ConnectionFactoryConfigurer;
import org.springframework.social.config.annotation.EnableSocial;
import org.springframework.social.config.annotation.SocialConfigurer;
import org.springframework.social.connect.ConnectionFactoryLocator;
import org.springframework.social.connect.ConnectionRepository;
import org.springframework.social.connect.ConnectionSignUp;
import org.springframework.social.connect.UsersConnectionRepository;
import org.springframework.social.connect.jdbc.JdbcUsersConnectionRepository;
import org.springframework.social.connect.web.ConnectController;
import org.springframework.social.facebook.connect.FacebookConnectionFactory;
import org.springframework.social.google.connect.GoogleConnectionFactory;
import org.springframework.social.linkedin.connect.LinkedInConnectionFactory;
import org.springframework.social.security.AuthenticationNameUserIdSource;
import org.springframework.social.twitter.connect.TwitterConnectionFactory;

@Configuration
@EnableSocial
// Load to Environment.
@PropertySource("classpath:social-cfg.properties")
public class SocialConfig implements SocialConfigurer {

  private boolean autoSignUp = false;

  @Autowired
  private DataSource dataSource;

  @Autowired
  private MyUserAccountDAO myUserAccountDAO;
 
 

  // @env: Read properties file config by @PropertySource.
  @Override
  public void addConnectionFactories(ConnectionFactoryConfigurer cfConfig, Environment env) {

      // Twitter
      TwitterConnectionFactory tfactory = new TwitterConnectionFactory(//
              env.getProperty("twitter.consumer.key"), //
              env.getProperty("twitter.consumer.secret"));

      // tfactory.setScope(env.getProperty("twitter.scope"));
     
      cfConfig.addConnectionFactory(tfactory);

      // Facebook
      FacebookConnectionFactory ffactory = new FacebookConnectionFactory(//
              env.getProperty("facebook.app.id"), //
              env.getProperty("facebook.app.secret"));
     
     
      ffactory.setScope(env.getProperty("facebook.scope"));
     
      // auth_type=reauthenticate

      cfConfig.addConnectionFactory(ffactory);

      // Linkedin
      LinkedInConnectionFactory lfactory = new LinkedInConnectionFactory(//
              env.getProperty("linkedin.consumer.key"), //
              env.getProperty("linkedin.consumer.secret"));

      lfactory.setScope(env.getProperty("linkedin.scope"));
     
      cfConfig.addConnectionFactory(lfactory);

     
      // Google
      GoogleConnectionFactory gfactory = new GoogleConnectionFactory(//
              env.getProperty("google.client.id"), //
              env.getProperty("google.client.secret"));

      gfactory.setScope(env.getProperty("google.scope"));
     
      cfConfig.addConnectionFactory(gfactory);
  }

  // The UserIdSource determines the userID of the user.
  @Override
  public UserIdSource getUserIdSource() {
      return new AuthenticationNameUserIdSource();
  }

  // Read and insert to USERCONNECTION.
  @Override
  public UsersConnectionRepository getUsersConnectionRepository(ConnectionFactoryLocator connectionFactoryLocator) {

      // org.springframework.social.security.SocialAuthenticationServiceRegistry
      JdbcUsersConnectionRepository usersConnectionRepository = new JdbcUsersConnectionRepository(dataSource,
              connectionFactoryLocator,

              Encryptors.noOpText());

      if (autoSignUp) {
          // Config to:
          // After login to social.
          // Automatically create corresponding USER_ACCOUNT if not already.
          ConnectionSignUp connectionSignUp = new MyConnectionSignUp(myUserAccountDAO);
          usersConnectionRepository.setConnectionSignUp(connectionSignUp);
      } else {
          // Config to:
          // After login to social.
          // If USER_ACCOUNTS does not exists
          // Redirect to register page.
          usersConnectionRepository.setConnectionSignUp(null);
      }
      return usersConnectionRepository;
  }

  // This bean manages the connection flow between the account provider and
  // the example application.
  @Bean
  public ConnectController connectController(ConnectionFactoryLocator connectionFactoryLocator, //
          ConnectionRepository connectionRepository) {
      return new ConnectController(connectionFactoryLocator, connectionRepository);
  }
 
 
}

package org.o7planning.socialsecurity.model;

public class MyUserAccount {

   public static final String ROLE_USER = "ROLE_USER";

   private String id;
   private String email;
   private String userName;

   private String firstName;
   private String lastName;
   private String password;
   private String role;

   public MyUserAccount() {

   }

   public MyUserAccount(String id, String email,String userName, String firstName, //
           String lastName, String password, //
           String role) {
       this.id = id;
       this.email = email;
       this.userName= userName;
       this.firstName = firstName;
       this.lastName = lastName;
       this.password = password;
       this.role = role;
   }

   public String getId() {
       return id;
   }

   public void setId(String id) {
       this.id = id;
   }

   public String getEmail() {
       return email;
   }

   public void setEmail(String email) {
       this.email = email;
   }

   public String getUserName() {
       return userName;
   }

   public void setUserName(String userName) {
       this.userName = userName;
   }

   public String getFirstName() {
       return firstName;
   }

   public void setFirstName(String firstName) {
       this.firstName = firstName;
   }

   public String getLastName() {
       return lastName;
   }

   public void setLastName(String lastName) {
       this.lastName = lastName;
   }

   public String getPassword() {
       return password;
   }

   public void setPassword(String password) {
       this.password = password;
   }

   public String getRole() {
       return role;
   }

   public void setRole(String role) {
       this.role = role;
   }

}

package org.o7planning.socialsecurity.mapper;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.o7planning.socialsecurity.model.MyUserAccount;
import org.springframework.jdbc.core.RowMapper;

public class MyUserAccountMapper implements RowMapper<MyUserAccount> {

    @Override
    public MyUserAccount mapRow(ResultSet rs, int rowNum) throws SQLException {

        String id = rs.getString("id");
 
        String email = rs.getString("email");
        String userName= rs.getString("user_name");
        String firstName = rs.getString("first_name");
        String lastName = rs.getString("last_name");
        String password = rs.getString("password");
        String role = rs.getString("role");

        return new MyUserAccount(id, email,userName, firstName, //
                lastName, password, //
                role );
    }

}

package org.o7planning.socialsecurity.dao;

import java.util.UUID;

import javax.sql.DataSource;

import org.o7planning.socialsecurity.form.MyUserAccountForm;
import org.o7planning.socialsecurity.mapper.MyUserAccountMapper;
import org.o7planning.socialsecurity.model.MyUserAccount;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
import org.springframework.social.connect.Connection;
import org.springframework.social.connect.ConnectionKey;
import org.springframework.social.connect.UserProfile;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

@Repository
@Transactional
public class MyUserAccountDAO extends JdbcDaoSupport {

   @Autowired
   public MyUserAccountDAO(DataSource dataSource) {
       this.setDataSource(dataSource);
   }

   public MyUserAccount findById(String id) {
       String sql = "Select id,email,user_name, first_name,last_name,"//
               + " password,role"//
               + " from User_Accounts u "//
               + " where id = ? ";
       Object[] params = new Object[] { id };
       MyUserAccountMapper mapper = new MyUserAccountMapper();
       try {
           MyUserAccount userInfo = this.getJdbcTemplate().queryForObject(sql, params, mapper);
           return userInfo;
       } catch (EmptyResultDataAccessException e) {
           return null;
       }
   }

   public MyUserAccount findByEmail(String email) {
       String sql = "Select id, email,user_name,first_name,last_name,"//
               + " password,role"//
               + " from User_Accounts u "//
               + " where email = ? ";
       Object[] params = new Object[] { email };
       MyUserAccountMapper mapper = new MyUserAccountMapper();
       try {
           MyUserAccount userInfo = this.getJdbcTemplate().queryForObject(sql, params, mapper);
           return userInfo;
       } catch (EmptyResultDataAccessException e) {
           return null;
       }
   }

   public MyUserAccount findByUserName(String userName) {
       String sql = "Select id, email,user_name,first_name,last_name,"//
               + " password,role"//
               + " from User_Accounts u "//
               + " where user_name = ? ";
       Object[] params = new Object[] { userName };
       MyUserAccountMapper mapper = new MyUserAccountMapper();
       try {
           MyUserAccount userInfo = this.getJdbcTemplate().queryForObject(sql, params, mapper);
           return userInfo;
       } catch (EmptyResultDataAccessException e) {
           return null;
       }
   }

   public MyUserAccount registerNewUserAccount(MyUserAccountForm accountForm) {
       String sql = "Insert into User_Accounts "//
               + " (id, email,user_name,first_name,last_name,password,role) "//
               + " values (?,?,?,?,?,?,?) ";

       // Random string with 36 characters.
       String id = UUID.randomUUID().toString();

       this.getJdbcTemplate().update(sql, id, accountForm.getEmail(), //
               accountForm.getUserName(), //
               accountForm.getFirstName(), accountForm.getLastName(), //
               accountForm.getPassword(), MyUserAccount.ROLE_USER);
       return findById(id);
   }

   // Auto Create USER_ACCOUNTS.
   public MyUserAccount createUserAccount(Connection<?> connection) {

       ConnectionKey key = connection.getKey();
       // (facebook,12345), (google,123) ...

       System.out.println("key= (" + key.getProviderId() + "," + key.getProviderUserId() + ")");

       UserProfile userProfile = connection.fetchUserProfile();

       String email = userProfile.getEmail();
       MyUserAccount account = this.findByEmail(email);
       if (account != null) {
           return account;
       }

       // Create User_Account.
       String sql = "Insert into User_Accounts "//
               + " (id, email,user_name,first_name,last_name,password,role) "//
               + " values (?,?,?,?,?,?,?) ";

       // Random string with 36 characters.
       String id = UUID.randomUUID().toString();
       
       String userName_prefix = userProfile.getFirstName().trim().toLowerCase()//
                           +"_"+ userProfile.getLastName().trim().toLowerCase();
       
       String userName = this.findAvailableUserName(userName_prefix);

       this.getJdbcTemplate().update(sql, id, email, userName, //
               userProfile.getFirstName(), userProfile.getLastName(), //
               "123", MyUserAccount.ROLE_USER);
       return findById(id);
   }

   private String findAvailableUserName(String userName_prefix) {
       MyUserAccount account = this.findByUserName(userName_prefix);
       if (account == null) {
           return userName_prefix;
       }
       int i = 0;
       while (true) {
           String userName = userName_prefix + "_" + i++;
           account = this.findByUserName(userName);
           if (account == null) {
               return userName;
           }
       }
   }

}

package org.o7planning.socialsecurity.user;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.o7planning.socialsecurity.model.MyUserAccount;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.social.security.SocialUserDetails;

public class MySocialUserDetails implements SocialUserDetails {

    private static final long serialVersionUID = -5246117266247684905L;

    private List<GrantedAuthority> list = new ArrayList<GrantedAuthority>();
    private MyUserAccount myUserAccount;

    public MySocialUserDetails(MyUserAccount myUserAccount) {
        this.myUserAccount = myUserAccount;
        String role = myUserAccount.getRole();

        GrantedAuthority grant = new SimpleGrantedAuthority(role);
        this.list.add(grant);
    }

    @Override
    public String getUserId() {
        return this.myUserAccount.getId();
    }

    @Override
    public String getUsername() {
        return myUserAccount.getUserName();
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return list;
    }

    @Override
    public String getPassword() {
        return myUserAccount.getPassword();
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }

}

package org.o7planning.socialsecurity.service;

import org.o7planning.socialsecurity.dao.MyUserAccountDAO;
import org.o7planning.socialsecurity.model.MyUserAccount;
import org.o7planning.socialsecurity.user.MySocialUserDetails;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.social.security.SocialUserDetails;
import org.springframework.stereotype.Service;

// Service to Get user info from Database.
@Service
public class MyUserDetailsService implements UserDetailsService {

  @Autowired
  private MyUserAccountDAO myUserAccountDAO;

  public MyUserDetailsService() {

  }

  // (This method is used by Spring Security API).
  @Override
  public UserDetails loadUserByUsername(String userName) throws UsernameNotFoundException {

      MyUserAccount myUserAccount = myUserAccountDAO.findByUserName(userName);

      if (myUserAccount == null) {
          throw new UsernameNotFoundException("No user found with userName: " + userName);
      }
      // Note: SocialUserDetails extends UserDetails.
      SocialUserDetails principal = new MySocialUserDetails(myUserAccount);

      return principal;
  }

}

package org.o7planning.socialsecurity.service;

import org.o7planning.socialsecurity.dao.MyUserAccountDAO;
import org.o7planning.socialsecurity.model.MyUserAccount;
import org.o7planning.socialsecurity.user.MySocialUserDetails;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.social.security.SocialUserDetails;
import org.springframework.social.security.SocialUserDetailsService;
import org.springframework.stereotype.Service;

@Service
public class MySocialUserDetailsService implements SocialUserDetailsService {
   
   
   @Autowired
   private MyUserAccountDAO myUserAccountDAO;

   // Loads the UserDetails by using the userID of the user.
   // (This method Is used by Spring Security API).
   @Override
   public SocialUserDetails loadUserByUserId(String userId) throws UsernameNotFoundException, DataAccessException {

       MyUserAccount account= myUserAccountDAO.findById(userId);
       
       MySocialUserDetails userDetails= new MySocialUserDetails(account);
       
       return userDetails;
   }

}

package org.o7planning.socialsecurity.signup;

import org.o7planning.socialsecurity.dao.MyUserAccountDAO;
import org.o7planning.socialsecurity.model.MyUserAccount;
import org.springframework.social.connect.Connection;
import org.springframework.social.connect.ConnectionSignUp;

public class MyConnectionSignUp implements ConnectionSignUp {

    private MyUserAccountDAO myUserAccountDAO;

    public MyConnectionSignUp(MyUserAccountDAO myUserAccountDAO) {
        this.myUserAccountDAO = myUserAccountDAO;
    }

    // After login Social.
    // This method is called to create a USER_ACCOUNTS record
    // if it does not exists.
    @Override
    public String execute(Connection<?> connection) {
       

        MyUserAccount account=    myUserAccountDAO.createUserAccount(connection);
        return account.getId();
    }

}

 

package org.o7planning.socialsecurity.validator;

import org.apache.commons.validator.routines.EmailValidator;
import org.o7planning.socialsecurity.dao.MyUserAccountDAO;
import org.o7planning.socialsecurity.form.MyUserAccountForm;
import org.o7planning.socialsecurity.model.MyUserAccount;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;

@Component
public class MyUserAccountValidator implements Validator {

    // common-validator library.
    private EmailValidator emailValidator = EmailValidator.getInstance();

    @Autowired
    private MyUserAccountDAO myUserAccountDAO;

    @Override
    public boolean supports(Class<?> clazz) {
        return clazz == MyUserAccountForm.class;
    }

    @Override
    public void validate(Object target, Errors errors) {
       
        MyUserAccountForm form = (MyUserAccountForm) target;
         
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "email", "", "Email is required");
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "userName", "", "User name is required");
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "firstName", "", "First name is required");
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "lastName", "", "Last name is required");
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "password", "", "Password is required");

        if (errors.hasErrors()) {
            return;
        }

        if (!emailValidator.isValid(form.getEmail())) {
             
            errors.rejectValue("email", "", "Email is not valid");
            return;
        }

        MyUserAccount userAccount = myUserAccountDAO.findByUserName(form.getUserName());
        if (userAccount != null) {
            if (form.getId() == null) {
                errors.rejectValue("userName", "", "User name is not available");
                return;
            } else if (!form.getId().equals(userAccount.getId())) {
                errors.rejectValue("userName", "", "User name is not available");
                return;
            }
        }

        userAccount = myUserAccountDAO.findByEmail(form.getEmail());
        if (userAccount != null) {
            if (form.getId() == null) {
                errors.rejectValue("email", "", "Email is not available");
                return;
            } else if (!form.getId().equals(userAccount.getId())) {
                errors.rejectValue("email", "", "Email is not available");
                return;
            }
        }
    }

}

package org.o7planning.socialsecurity.form;

import org.springframework.social.connect.Connection;
import org.springframework.social.connect.ConnectionKey;
import org.springframework.social.connect.UserProfile;

public class MyUserAccountForm {

    private String id;
    private String email;
    private String userName;

    private String firstName;
    private String lastName;
    private String password;
    private String role;
    private String signInProvider;
    private String providerUserId;

    public MyUserAccountForm() {

    }

    public MyUserAccountForm(Connection<?> connection) {
        UserProfile socialUserProfile = connection.fetchUserProfile();
        this.id = null;
        this.email = socialUserProfile.getEmail();
        this.userName = socialUserProfile.getUsername();
        this.firstName = socialUserProfile.getFirstName();
        this.lastName = socialUserProfile.getLastName();

        ConnectionKey key = connection.getKey();
        // google, facebook, twitter
        this.signInProvider = key.getProviderId();

        // ID of User on google, facebook, twitter.
        // ID của User trên google, facebook, twitter.
        this.providerUserId = key.getProviderUserId();
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getRole() {
        return role;
    }

    public void setRole(String role) {
        this.role = role;
    }

    public String getSignInProvider() {
        return signInProvider;
    }

    public void setSignInProvider(String signInProvider) {
        this.signInProvider = signInProvider;
    }

    public String getProviderUserId() {
        return providerUserId;
    }

    public void setProviderUserId(String providerUserId) {
        this.providerUserId = providerUserId;
    }

}

package org.o7planning.socialsecurity.util;

import org.o7planning.socialsecurity.model.MyUserAccount;
import org.o7planning.socialsecurity.user.MySocialUserDetails;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;

public class SecurityUtil {

   // Auto login.
   public static void logInUser(MyUserAccount user) {

       MySocialUserDetails userDetails = new MySocialUserDetails(user);

       Authentication authentication = new UsernamePasswordAuthenticationToken(userDetails, null,
               userDetails.getAuthorities());
       SecurityContextHolder.getContext().setAuthentication(authentication);
   }
 
}

package org.o7planning.socialsecurity.controller;

import org.o7planning.socialsecurity.dao.MyUserAccountDAO;
import org.o7planning.socialsecurity.form.MyUserAccountForm;
import org.o7planning.socialsecurity.model.MyUserAccount;
import org.o7planning.socialsecurity.util.SecurityUtil;
import org.o7planning.socialsecurity.validator.MyUserAccountValidator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.social.connect.Connection;
import org.springframework.social.connect.ConnectionFactoryLocator;
import org.springframework.social.connect.UsersConnectionRepository;
import org.springframework.social.connect.web.ProviderSignInUtils;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

@Controller
// Need to use RedirectAttributes
@EnableWebMvc
public class MainController {

   @Autowired
   private MyUserAccountDAO myUserAccountDAO;

   @Autowired
   private ConnectionFactoryLocator connectionFactoryLocator;

   @Autowired
   private UsersConnectionRepository connectionRepository;

   @Autowired
   private MyUserAccountValidator myUserAccountValidator;

   // Set a form validator
   @InitBinder
   protected void initBinder(WebDataBinder dataBinder) {
       Object target = dataBinder.getTarget();
       if (target == null) {
           return;
       }
       System.out.println("Target=" + target);

       if (target.getClass() == MyUserAccountForm.class) {
           dataBinder.setValidator(myUserAccountValidator);
       }
   }

   @RequestMapping(value = { "/" }, method = RequestMethod.GET)
   public String homePage(Model model) {
       try {
           UserDetails userDetails = (UserDetails) SecurityContextHolder.getContext().getAuthentication()
                   .getPrincipal();
           if (userDetails != null) {
               System.out.println(userDetails.getPassword());
               System.out.println(userDetails.getUsername());
               System.out.println(userDetails.isEnabled());

               model.addAttribute("userDetails", userDetails);
           }
       } catch (Exception e) {
       }
       return "index";
   }

   @RequestMapping(value = { "/login" }, method = RequestMethod.GET)
   public String welcomePage(Model model) {
       return "login";
   }

   // User login via Social,
   // but not allow access basic info.
   // webapp will redirect to /signin.
   @RequestMapping(value = { "/signin" }, method = RequestMethod.GET)
   public String signInPage(Model model) {
       return "redirect:/login";
   }

   @RequestMapping(value = { "/signup" }, method = RequestMethod.GET)
   public String signupPage(WebRequest request, Model model) {

       ProviderSignInUtils providerSignInUtils //
               = new ProviderSignInUtils(connectionFactoryLocator, connectionRepository);

 
       Connection<?> connection = providerSignInUtils.getConnectionFromSession(request);

       //
       MyUserAccountForm myForm = null;
       //
       if (connection != null) {
           myForm = new MyUserAccountForm(connection);
       } else {
           myForm = new MyUserAccountForm();
       }
       model.addAttribute("myForm", myForm);
       return "signup";
   }

   @RequestMapping(value = { "/signup" }, method = RequestMethod.POST)
   public String signupSave(WebRequest request, //
           Model model, //
           @ModelAttribute("myForm") @Validated MyUserAccountForm accountForm, //
           BindingResult result, //
           final RedirectAttributes redirectAttributes) {

       // If validation has error.
       if (result.hasErrors()) {
           return "signup";
       }

       MyUserAccount registered = null;

       try {
           registered = myUserAccountDAO.registerNewUserAccount(accountForm);
       } catch (Exception ex) {
           ex.printStackTrace();
           model.addAttribute("errorMessage", "Error " + ex.getMessage());
           return "signup";
       }

       if (accountForm.getSignInProvider() != null) {
           ProviderSignInUtils providerSignInUtils //
                   = new ProviderSignInUtils(connectionFactoryLocator, connectionRepository);

           // If the user is signing in by using a social provider, this method
           // call stores the connection to the UserConnection table.
           // Otherwise, this method does not do anything.
           providerSignInUtils.doPostSignUp(registered.getId(), request);
       }
       // After register, Logs the user in.
       SecurityUtil.logInUser(registered);

       return "redirect:/userInfo";
   }

   @RequestMapping(value = { "/userInfo" }, method = RequestMethod.GET)
   public String userInfoPage(WebRequest request, Model model) {
       return "userInfo";
   }

}

@Configuration
@EnableSocial
// Load to Environment.
@PropertySource("classpath:social-cfg.properties")
public class SocialConfig implements SocialConfigurer {
  
    // .....
    private boolean autoSignUp = true;

   .......
}

@Configuration
@EnableSocial
// Load to Environment.
@PropertySource("classpath:social-cfg.properties")
public class SocialConfig implements SocialConfigurer {
  
    // .....
    private boolean autoSignUp = false;

   .......
}