<beans:beans xmlns="http://www.springframework.org/schema/security"
         xmlns:beans="http://www.springframework.org/schema/beans"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/security
http://www.springframework.org/schema/security/spring-security-4.1.xsd">

<http auto-config="true" use-expressions="true">
    <intercept-url pattern="/admin**" access="isAuthenticated()" />
    <intercept-url pattern="/admin/*" access="isAuthenticated()"/>
    <form-login
            login-page="/login"
            default-target-url="/"
            login-processing-url="/j_spring_security_check"
            authentication-failure-url="/login?error"
            username-parameter="username"
            password-parameter="password" />
    <logout logout-success-url="/login?logout" />
    <!--<csrf/>-->
    <http-basic/>
</http>

<authentication-manager>
    <authentication-provider ref="authenticationProvider"/>
</authentication-manager>

@Component(value = "authenticationProvider")
public class NiceAuthenticationProvider implements AuthenticationProvider {

@Autowired
private IUserService userService;

@Override
public Authentication authenticate(Authentication authentication) throws AuthenticationException{
    String username=authentication.getName();
    String password=(String)authentication.getCredentials();
    User user = userService.getUserByUsername(username);
    if(user==null)
        throw new BadCredentialsException("User not found");
    if(!password.equals(user.getPassword()))
        throw new BadCredentialsException("Wrong password");

    Collection<?extends GrantedAuthority> authorities = user.getRoles();

    return new UsernamePasswordAuthenticationToken(user, password, authorities);

}

@Override
public boolean supports(Class<?> aClass) {
    return true;
}

public void setService(UserService service) {
    this.userService = service;
}

public IUserService getUserService() {
    return userService;
}
}

@Configuration
@EnableWebSecurity
@ComponentScan("com.websystique.springmvc")
@Order(1)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
NiceAuthenticationProvider niceAuthenticationProvider;

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth.authenticationProvider(niceAuthenticationProvider);
}

@Override
protected void configure(HttpSecurity http) throws Exception {
    http
            .authorizeRequests().anyRequest().authenticated()
            .and()
            .httpBasic();
}
}

@Configuration
 @EnableWebMvc
 @ComponentScan(basePackages = "com.websystique.springmvc")


public class AppConfig {

@Bean
public ViewResolver viewResolver() {
    InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
    viewResolver.setViewClass(JstlView.class);
    viewResolver.setPrefix("/WEB-INF/views/");
    viewResolver.setSuffix(".jsp");

    return viewResolver;
}

@Bean
public MessageSource messageSource() {
    ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
    messageSource.setBasename("messages");
    return messageSource;
}
}

@Service("userService")
@Transactional
public class UserService implements IUserService{
@Autowired
private UsersDao usersDao;

public User getUserByUsername(String username){
    return usersDao.findUserByUserName(username);
}

public void setUsersDao(UsersDaoImpl usersDao) {
    this.usersDao = usersDao;
}
}

@Repository("usersDao")
public class UsersDaoImpl extends AbstractDao<Integer, User> implements UserDetailsService, UsersDao {

public User findUserByUserName(String username) throws UsernameNotFoundException {
    Criteria criteria = createEntityCriteria();
    criteria.add(Restrictions.eq("username", username));
    User usr= (User) criteria.uniqueResult();
    if(usr!=null)
        return usr;
    else
        throw new UsernameNotFoundException("USER NOT FOUND");
}
@Override
public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
    return new CustomUserDetails(findUserByUserName(s));
}
}

public abstract class AbstractDao<PK extends Serializable, T> {
private final Class<T> persistentClass;

@SuppressWarnings("unchecked")
public AbstractDao(){
    this.persistentClass =(Class<T>) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[1];
}

@Autowired
private SessionFactory sessionFactory;

protected Session getSession(){
    return sessionFactory.getCurrentSession();
}

@SuppressWarnings("unchecked")
public T getByKey(PK key) {
    return (T) getSession().get(persistentClass, key);
}

public void persist(T entity) {
    getSession().persist(entity);
}

public void delete(T entity) {
    getSession().delete(entity);
}

protected Criteria createEntityCriteria(){
    return getSession().createCriteria(persistentClass);
}

}