gistfile1.java

package org.synergy.service.platform;

/**
 * Created with IntelliJ IDEA.
 * User: Junyan
 * Date: 13-2-6
 * Time: 下午9:08
 */

import org.apache.commons.dbcp.BasicDataSource;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.security.access.AccessDecisionManager;
import org.springframework.security.access.AccessDecisionVoter;
import org.springframework.security.access.ConfigAttribute;
import org.springframework.security.access.SecurityConfig;
import org.springframework.security.access.expression.SecurityExpressionHandler;
import org.springframework.security.access.vote.AffirmativeBased;
import org.springframework.security.access.vote.RoleVoter;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.ProviderManager;
import org.springframework.security.authentication.RememberMeAuthenticationProvider;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
import org.springframework.security.core.session.SessionRegistry;
import org.springframework.security.core.session.SessionRegistryImpl;
import org.springframework.security.core.userdetails.UserDetailsByNameServiceWrapper;
import org.springframework.security.core.userdetails.jdbc.JdbcDaoImpl;
import org.springframework.security.provisioning.JdbcUserDetailsManager;
import org.springframework.security.web.DefaultSecurityFilterChain;
import org.springframework.security.web.FilterChainProxy;
import org.springframework.security.web.FilterInvocation;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.security.web.access.AccessDeniedHandlerImpl;
import org.springframework.security.web.access.ExceptionTranslationFilter;
import org.springframework.security.web.access.expression.DefaultWebSecurityExpressionHandler;
import org.springframework.security.web.access.expression.ExpressionBasedFilterInvocationSecurityMetadataSource;
import org.springframework.security.web.access.expression.WebExpressionVoter;
import org.springframework.security.web.access.intercept.FilterSecurityInterceptor;
import org.springframework.security.web.authentication.*;
import org.springframework.security.web.authentication.preauth.PreAuthenticatedAuthenticationProvider;
import org.springframework.security.web.authentication.preauth.PreAuthenticatedAuthenticationToken;
import org.springframework.security.web.authentication.preauth.x509.X509AuthenticationFilter;
import org.springframework.security.web.authentication.rememberme.RememberMeAuthenticationFilter;
import org.springframework.security.web.authentication.rememberme.TokenBasedRememberMeServices;
import org.springframework.security.web.authentication.session.ConcurrentSessionControlStrategy;
import org.springframework.security.web.authentication.www.BasicAuthenticationEntryPoint;
import org.springframework.security.web.context.HttpSessionSecurityContextRepository;
import org.springframework.security.web.context.SecurityContextPersistenceFilter;
import org.springframework.security.web.savedrequest.RequestCacheAwareFilter;
import org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter;
import org.springframework.security.web.session.ConcurrentSessionFilter;
import org.springframework.security.web.session.SessionManagementFilter;
import org.springframework.security.web.util.AntPathRequestMatcher;
import org.springframework.security.web.util.RequestMatcher;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;

@Configuration
@ComponentScan(basePackages="org.synergy")
@EnableWebMvc
@ImportResource("/WEB-INF/application-context.xml")
public class WebAppConfiguration extends WebMvcConfigurerAdapter {

    public @Value("${WebApp.language}") static AppLanguage language;
    private @Value("${WebMvc.viewResolverPrefix}") String viewResolverPrefix;
    private @Value("${WebMvc.viewResolverSuffix}") String viewResolverSuffix;
    private @Value("${WebMvc.resourcesLocations}") String resourcesLocations;
    private @Value("${WebMvc.cssLocations}") String cssLocations;
    private @Value("${WebMvc.jsLocations}") String jsLocations;
    private @Value("${WebMvc.imgLocations}") String imgLocations;

    private @Value("${dbcp.driverClassName}") String driverClassName;
    private @Value("${dbcp.url}") String url;
    private @Value("${dbcp.username}") String username;
    private @Value("${dbcp.password}") String password;
    private @Value("${dbcp.initialSize}") int initialSize;
    private @Value("${dbcp.maxActive}") int maxActive;
    private @Value("${dbcp.maxIdle}") int maxIdle;
    private @Value("${dbcp.minIdle}") int minIdle;
    private @Value("${dbcp.setDefaultAutoCommit}") boolean setDefaultAutoCommit;


    public enum AppLanguage {ZH, TW, EN}

    private BasicDataSource dataSource = null;
    private JdbcTemplate jdbcTemplate = null;
    private static Logger logger =  Logger.getLogger(WebAppConfiguration.class);

    @Autowired
    private JdbcDaoImpl authUserDetailService;

    @Bean
    public ViewResolver getViewResolver(){
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix(viewResolverPrefix);
        resolver.setSuffix(viewResolverSuffix);
        return resolver;
    }

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler(resourcesLocations+"**").addResourceLocations(resourcesLocations);
        registry.addResourceHandler(cssLocations+"**").addResourceLocations(cssLocations);
        registry.addResourceHandler(jsLocations+"**").addResourceLocations(jsLocations);
        registry.addResourceHandler(imgLocations+"**").addResourceLocations(imgLocations);
    }

    @Bean
    public BasicDataSource  dataSource(){
        BasicDataSource dataSource = new BasicDataSource();

        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setInitialSize(initialSize);
        dataSource.setMaxActive(maxActive);
        dataSource.setMaxIdle(maxIdle);
        dataSource.setMinIdle(minIdle);
        dataSource.setDefaultAutoCommit(setDefaultAutoCommit);
        return dataSource;
    }

    @Bean (name = { "jdbcTemplate", "dao"})
    public JdbcTemplate jdbcTemplate () {
        if (dataSource == null) {
            dataSource = dataSource();
        }

        if (jdbcTemplate == null) {
            jdbcTemplate = new JdbcTemplate(dataSource);
        }

        return jdbcTemplate;
    }

    @Bean
    public JdbcDaoImpl authUserDetailService() {
        JdbcDaoImpl jdbcDaoImpl =  new  JdbcDaoImpl();
        jdbcDaoImpl.setDataSource(dataSource());
        return jdbcDaoImpl;
    }

    @Bean(name = "springSecurityFilterChain")
    public FilterChainProxy springSecurityFilterChain() throws Exception {
        // AuthenticationEntryPoint
        BasicAuthenticationEntryPoint entryPoint = new BasicAuthenticationEntryPoint();
        entryPoint.setRealmName("AppName Realm");
        // accessDecisionManager
        List<AccessDecisionVoter> voters = Arrays.<AccessDecisionVoter>asList(new RoleVoter(), new WebExpressionVoter());
        AccessDecisionManager accessDecisionManager = new AffirmativeBased(voters);
        // SecurityExpressionHandler
        SecurityExpressionHandler<FilterInvocation> securityExpressionHandler = new DefaultWebSecurityExpressionHandler();
        // AuthenticationUserDetailsService
        UserDetailsByNameServiceWrapper<PreAuthenticatedAuthenticationToken> authenticationUserDetailsService = new UserDetailsByNameServiceWrapper<PreAuthenticatedAuthenticationToken>(authUserDetailService);
        authenticationUserDetailsService.afterPropertiesSet();
        // PreAuthenticatedAuthenticationProvider
        PreAuthenticatedAuthenticationProvider preAuthenticatedAuthenticationProvider = new PreAuthenticatedAuthenticationProvider();
        preAuthenticatedAuthenticationProvider.setPreAuthenticatedUserDetailsService(authenticationUserDetailsService);
        preAuthenticatedAuthenticationProvider.afterPropertiesSet();
        // AuthenticationManager
        List<AuthenticationProvider> providers = Arrays.<AuthenticationProvider>asList(preAuthenticatedAuthenticationProvider);
        AuthenticationManager authenticationManager = new ProviderManager(providers);
        // HttpSessionSecurityContextRepository
        HttpSessionSecurityContextRepository httpSessionSecurityContextRepository = new HttpSessionSecurityContextRepository();
        // SessionRegistry
        SessionRegistry sessionRegistry = new SessionRegistryImpl();
        // ConcurrentSessionControlStrategy
        ConcurrentSessionControlStrategy concurrentSessionControlStrategy = new ConcurrentSessionControlStrategy(sessionRegistry);

        // ConcurrentSessionFilter
        ConcurrentSessionFilter concurrentSessionFilter = new ConcurrentSessionFilter(sessionRegistry);
        concurrentSessionFilter.afterPropertiesSet();
        // SecurityContextPersistenceFilter
        SecurityContextPersistenceFilter securityContextPersistenceFilter = new SecurityContextPersistenceFilter(httpSessionSecurityContextRepository);
        // X509AuthenticationFilter
        X509AuthenticationFilter x509AuthenticationFilter = new X509AuthenticationFilter();
        x509AuthenticationFilter.setAuthenticationManager(authenticationManager);
        x509AuthenticationFilter.afterPropertiesSet();
        // RequestCacheAwareFilter
        RequestCacheAwareFilter requestCacheAwareFilter = new RequestCacheAwareFilter();
        // SecurityContextHolderAwareRequestFilter
        SecurityContextHolderAwareRequestFilter securityContextHolderAwareRequestFilter = new SecurityContextHolderAwareRequestFilter();
        // SessionManagementFilter
        SessionManagementFilter sessionManagementFilter = new SessionManagementFilter(httpSessionSecurityContextRepository, concurrentSessionControlStrategy);
        // ExceptionTranslationFilter
        ExceptionTranslationFilter exceptionTranslationFilter = new ExceptionTranslationFilter(entryPoint);
        exceptionTranslationFilter.setAccessDeniedHandler(new AccessDeniedHandlerImpl());
        exceptionTranslationFilter.afterPropertiesSet();
        // FilterSecurityInterceptor
        FilterSecurityInterceptor filterSecurityInterceptor = new FilterSecurityInterceptor();
        filterSecurityInterceptor.setAuthenticationManager(authenticationManager);
        filterSecurityInterceptor.setAccessDecisionManager(accessDecisionManager);
        LinkedHashMap<RequestMatcher, Collection<ConfigAttribute>> map = new LinkedHashMap<RequestMatcher, Collection<ConfigAttribute>>();
        map.put(new AntPathRequestMatcher("/**"), Arrays.<ConfigAttribute>asList(new SecurityConfig("isAuthenticated()")));
        ExpressionBasedFilterInvocationSecurityMetadataSource ms = new ExpressionBasedFilterInvocationSecurityMetadataSource(map, securityExpressionHandler);
        filterSecurityInterceptor.setSecurityMetadataSource(ms);
        filterSecurityInterceptor.afterPropertiesSet();
        // SecurityFilterChain
        SecurityFilterChain chain = new DefaultSecurityFilterChain(new AntPathRequestMatcher("/**"),
                concurrentSessionFilter,
                securityContextPersistenceFilter,
                x509AuthenticationFilter,
                requestCacheAwareFilter,
                securityContextHolderAwareRequestFilter,
                sessionManagementFilter,
                exceptionTranslationFilter,
                filterSecurityInterceptor);
        return new FilterChainProxy(chain);
    }
}