Recientemente he cambiado la mayor parte de mi Primavera de configuración para utilizar el código de configuración en la Primavera de 3.1. Sin embargo, ahora que me cambié, mi Primavera Seguridad no está funcionando correctamente y se produce el siguiente error en Tomcat inicio:

SEVERE: Exception starting filter springSecurityFilterChain
org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named     'springSecurityFilterChain' is defined

Todavía tengo la Primavera de Seguridad en un archivo XML, y saber que esto no puede ser convertido a Java config en la Primavera, ya que es un espacio de nombres personalizado, sin embargo, estoy de referencia dentro de mis Java archivo de configuración. También traté de mover el applicationContext-security.xml referencia de la configuración de Java en config para mi web.xml sin suerte.

@Configuration
@EnableWebMvc
@Import(ServicesConfig.class)
@ImportResource({ "classpath:applicationContext-security.xml",
"classpath:dataSources.xml" })
@ComponentScan(basePackages = "com.foobar")
public class WebConfig {
   //left out Beans for clarity
}

applicationContext-security.xml:

<b:beans xmlns="http://www.springframework.org/schema/security"
xmlns:b="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p" xmlns:c="http://www.springframework.org/schema/c"
xmlns:oauth2="http://www.springframework.org/schema/security/oauth2"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/security
http://www.springframework.org/schema/security/spring-security-3.1.xsd
http://www.springframework.org/schema/security/oauth2
http://www.springframework.org/schema/security/spring-security-oauth2.xsd">
<!-- Security configuration -->
<global-method-security pre-post-annotations="enabled" />
<http use-expressions="true" access-denied-page="/error/accessDenied" 
entry-point-ref="casEntryPoint">
<intercept-url pattern="/**" access="isAuthenticated()" />
<custom-filter position="CAS_FILTER" ref="casFilter" />
</http>
<authentication-manager alias="authenticationManager">
<authentication-provider ref="casAuthenticationProvider" />
</authentication-manager>
<!-- Bean definitions -->
<b:bean id="casAuthenticationProvider"
class="org.springframework.security.cas.authentication.CasAuthenticationProvider"
p:serviceProperties-ref="serviceProperties" p:key="1234"
p:authenticationUserDetailsService-ref="userDetailsByNameServiceWrapper"
p:ticketValidator-ref="cas20ServiceTicketValidator" />
<b:bean id="userDetailsByNameServiceWrapper"
class="org.springframework.security.core.userdetails.UserDetailsByNameServiceWrapper"
c:userDetailsService-ref="userDetailsService" />
<b:bean id="userDetailsService" class="foobar.MyUserDetailsService" />
<b:bean id="cas20ServiceTicketValidator" 
class="org.jasig.cas.client.validation.Cas20ServiceTicketValidator"
c:casServerUrlPrefix="https://mycasserver/cas" />
<b:bean id="casFilter"
class="org.springframework.security.cas.web.CasAuthenticationFilter"
p:authenticationManager-ref="authenticationManager" />
<b:bean id="casEntryPoint"
class="org.springframework.security.cas.web.CasAuthenticationEntryPoint"
p:loginUrl="https://mycasserver/cas/login" 
p:serviceProperties-ref="serviceProperties" />
<b:bean id="serviceProperties" class="org.springframework.security.cas.ServiceProperties"
p:service="https://foobar.com/services/j_spring_cas_security_check"
p:sendRenew="false" />
</b:beans>

web.xml:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<description>My App</description>
<!-- Context Params -->
<context-param>
<param-name>contextClass</param-name>
<param-value>
org.springframework.web.context.support.AnnotationConfigWebApplicationContext
</param-value>
</context-param>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>foobar.WebConfig</param-value>
</context-param>
<!-- Filters --> 
<filter>
<filter-name>springSecurityFilterChain</filter-name>
<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
</filter>
<filter-mapping>
<filter-name>springSecurityFilterChain</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- Listeners -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- Servlets -->
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextClass</param-name>
<param-value>
org.springframework.web.context.support.AnnotationConfigWebApplicationContext
</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>
He actualizado mi respuesta con un ejemplo concreto
He encontrado esta referencia a ser realmente bueno. Se explica lo que cada grano está detrás de la Seguridad de espacio de nombres static.springsource.org/spring-security/site/docs/3.1.x/…

OriginalEl autor acvcu | 2012-04-04

4 Comentarios

  1. 8

    No utilice security espacio de nombres de los accesos directos y migrar toda la primavera de configuración XML en Java. Va a hacer el ajuste fino de su seguridad mucho más fácil. Yo lo voy a hacer para nuestro proyecto poco después de la migración a 3.1.
    Usted puede encontrar no-trivial, casi llano-bean de seguridad de configuración XML ejemplo aquí.

    edición:
    Terminado config (enlazado más arriba) de la migración. Todos config se puso en un método deliberadamente para hacer que sea más corto y demostrar que no necesitas separar la primavera de frijol por cada filtro. Por supuesto, es mejor moverse en el complejo init piezas de diferentes métodos (marcado @Bean si es necesario). Usted puede encontrar ejemplo de trabajo en el X509AnnotationTest.Config en el enlace de arriba.

    @Bean
    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);
    }
    Si usted no utiliza el security.xml, ¿cómo se establece el <global-method-security pre-post-annotations="enabled" /> el uso de java?
    Esto significa que no hay ningún web.xml configuración en todo derecho?
    Así que, como el post original de las notas, la costumbre de la Primavera de la configuración de Seguridad que necesita para permanecer en XML (hasta la Primavera de equipo es capaz de cambiar eso). Sin embargo, no creo que volver de nuevo a la llanura de los frijoles es la respuesta – esto va a negar todos los avances y simplificaciones que el espacio de nombres personalizado introducido y lo que usted termina con un mucho menos legible de la configuración de seguridad. En su lugar, el XML de configuración, que es simple y al punto, puede ser guardado y el error original resuelto.
    Su toma algunas libertades en «simple y al punto». Spring security es complicado saber importa que la veas. Yo uso el XML y ver el beneficio, sino todo lo que la magia de espacio de nombres XML (personalizado fábricas) haciendo cosas detrás de las escenas… es difícil de averiguar lo que está pasando. Justo orden de los filtros es bastante confuso.
    El enlace a la seguridad de configuración XML ejemplos fue realmente útil

    OriginalEl autor alexkasko

  2. 7

    Para aquellos que todavía buscan la manera de utilizar las SpringSecurity de configuración XML con Java config de la aplicación web. Tengo este trabajo mediante la Primavera 3.2.0.LIBERACIÓN y SpringSecurity 3.2.0.M1. Aquí está la parte importante de la solución

    WebAppConfig.java

    package com.foo.webapp;
    @Configuration
    @ComponentScan(basePackages = { "com.foo" })
    @ImportResource(value = { "/WEB-INF/spring-security.xml" })
    public class WebAppConfig {
    //other beans go here
    }

    spring-security.xml

    Nota que tuve que eliminar el defecto xmlns=»…» de la <frijoles:los frijoles> definición.

    <?xml version="1.0" encoding="UTF-8"?>
    <beans:beans
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:beans="http://www.springframework.org/schema/beans"
    xmlns:security="http://www.springframework.org/schema/security"
    xsi:schemaLocation="
    http://www.springframework.org/schema/security
    http://www.springframework.org/schema/security/spring-security-3.1.xsd
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">
    <security:http auto-config="true">
    <security:intercept-url pattern="/secured/**" access="ROLE_USER" />
    <security:form-login login-page="/login" default-target-url="/main"
    authentication-failure-url="/loginfailed" />
    <security:logout logout-success-url="/logout" />
    </security:http>
    <security:authentication-manager>
    <security:authentication-provider>
    <security:user-service>
    <security:user name="user" password="user" authorities="ROLE_USER" />
    </security:user-service>
    </security:authentication-provider>
    </security:authentication-manager>
    </beans:beans>

    web.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
    http://java.sun.com/xml/ns/j2ee
    http://java.sun.com/xml/ns/j2ee/web-app_2_5.xsd">
    <context-param>
    <param-name>contextClass</param-name>
    <param-value>
    org.springframework.web.context.support.AnnotationConfigWebApplicationContext
    </param-value>
    </context-param>
    <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>com.foo.webapp.WebAppConfig</param-value>
    </context-param>
    <!-- Spring Security -->
    <filter>
    <filter-name>springSecurityFilterChain</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    </filter>
    <filter-mapping>
    <filter-name>springSecurityFilterChain</filter-name>
    <url-pattern>/*</url-pattern>
    </filter-mapping>
    <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <servlet>
    <servlet-name>foo</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
    <servlet-name>foo</servlet-name>
    <url-pattern>/</url-pattern>
    </servlet-mapping>
    </web-app>
    Intentar «classpath:spring-security.xml» – menos de WEB-INF…
    He intentado esto y se quedó atascado debido a las dependencias entre el java config y el archivo XML. Lo que está permitido a depender de lo que aquí? Yo estoy en lo correcto pensar en el XML de configuración debe ser auto-contenida y la config java puede utilizar?

    OriginalEl autor user2001823

  3. 1

    Gracias a todos por las anteriores sugerencias sobre un springSecurityFilterChain cuando la configuración de Java de la Primavera se utiliza. He trabajado a lo largo de aplicar estas sugerencias para solucionar un comparables error en mi código, he observado que en la Primavera de documentación para org.springframework.web.WebApplicationInitializer (la interfaz implementada por AbstractAnnotationConfigDispatcherservletinitializer) tiene los siguientes «Advertencia»:

    web.xml el control de versiones de

    WEB-INF/web.xml y WebApplicationInitializer uso no son mutuamente excluyentes; por ejemplo, web.xml puede registrar un servlet, y un WebApplicationInitializer puede registrar otro. Un inicializador puede incluso modificar los registros realizados en web.xml a través de métodos tales como ServletContext.getServletRegistration(Cadena).

    Sin embargo, si WEB-INF/web.xml está presente en la aplicación, en su versión atributo debe estar ajustado a «3.0» o mayor, de lo contrario ServletContainerInitializer de arranque será ignorado por el contenedor de servlets.

    Señalo esto porque me di cuenta de que su web.xml versión ha señalado antes, es todavía 2.5.

    OriginalEl autor Richard Bruskiewich

  4. 0

    Tengo que trabajar con Spring 3.2.3 y el Servlet 3.0. La garrapata es extender DelegatingFilterProxy clase y la llamó SpringSecurityFilterChain.

    public class ServiceInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected Class<?>[] getRootConfigClasses() {
    return new Class<?>[] { ApplicationConfig.class };
    }
    @Override
    protected Class<?>[] getServletConfigClasses() {
    return new Class<?>[] { WebConfig.class };
    }
    @Override
    protected String[] getServletMappings() {
    return new String[] { "/" };
    }
    @Override
    protected Filter[] getServletFilters() {
    return new Filter[] { new OpenEntityManagerInViewFilter(), new SpringSecurityFilterChain() };
    }
    public class SpringSecurityFilterChain extends DelegatingFilterProxy {
    }

    }

    Me pregunto por qué va a reemplazar todos estos métodos. Usted tendría una más completo ejemplo de código ? Yo estoy luchando con la configuración de la seguridad con JavaConfig sólo.

    OriginalEl autor Dario Strelec

Dejar respuesta

Please enter your comment!
Please enter your name here