Die Referenzierung von Spring Security-Konfiguration in Spring 3.1, Java Config

Ich habe vor kurzem wechselte ein Großteil meiner Spring-Konfiguration zu verwenden, die code-basierte Konfiguration in Spring 3.1. Doch jetzt, da habe ich eingeschaltet, meine Spring Security funktioniert nicht richtig und wirft folgende Fehlermeldung auf dem Tomcat-Start:

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

Ich habe immer noch das Spring Security in einer XML-Datei, und wissen, das nicht umgewandelt werden kann, um Java-config im Frühjahr, da es ein benutzerdefinierter namespace, jedoch bin ich auf Sie verweisen, die in meiner Java-config-Datei. Ich habe auch versucht, das verschieben der applicationContext-security.xml Konfiguration Referenz des Java-config zu meinem web.xml ohne Glück.

@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>

Ich aktualisiert meine Antwort mit konkretem Beispiel
Ich fand diese Referenz wirklich gut zu sein. Es wird erklärt, was jede Bohne ist hinter der Security-namespace static.springsource.org/spring-security/site/docs/3.1.x/...

InformationsquelleAutor acvcu | 2012-04-04

Nicht verwenden security namespace-Abkürzungen und migrieren alle spring-Konfiguration von XML zu Java. Es wird die Feinabstimmung Ihrer Sicherheit viel einfacher. Ich werde es tun für unser Projekt bald nach der Migration 3.1.
Finden Sie nicht-triviale fast nur-bean-security XML-config Beispiel hier.

edit:
Fertige config (oben verlinkten) migration. Alle config wurde in eine Methode, bewusst um es kürzer zu machen und zu zeigen, dass Sie nicht brauchen, separate spring bean für jeden filter. Natürlich ist es besser, zu verschieben, komplexe init Teile zu trennen-Methoden (gekennzeichnet @Bean falls erforderlich). Finden Sie arbeiten beispielsweise in der X509AnnotationTest.Config auf den link oben.

@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);
}

Wenn Sie nicht die security.xml, wie legen Sie die <global-method-security pre-post-annotations="enabled" /> mit java nur?
Dies bedeutet, dass es keine web.xml Konfiguration überhaupt richtig?
So, wie die original-Beitrag Hinweise, die custom-Spring Security-Konfiguration braucht, um zu bleiben in XML (bis in das Frühjahr-team ist in der Lage, das zu ändern). Aber ich denke nicht, dass die Rückkehr zu normalen Bohnen ist die Antwort - dieses negiert wird all die Verbesserungen und Vereinfachungen, die die benutzerdefinierten namespace eingeführt und das, was man am Ende mit ist eine viel weniger lesbar security-Konfiguration. Stattdessen wird die XML-config, die ist einfach und auf den Punkt gehalten werden kann und der ursprüngliche Fehler behoben.
Ihre Einnahme einige Freiheiten in Bezug auf "einfach und auf den Punkt". Spring security ist kompliziert wissen, egal wie du es drehst und wendest. Ich benutze den XML-Code und sehen den nutzen aber alle, dass die Magie XML-namespace (custom Fabriken), die Dinge tun, hinter den kulissen... es ist hart, um herauszufinden, was Los ist. Nur die Bestellung der Filter ist sehr verwirrend ist.
Der link zu den security-XML-config-Beispiele, war wirklich hilfreich

InformationsquelleAutor alexkasko

Für diejenigen, die noch auf der Suche nach einem Weg zu verwenden, SpringSecurity XML-Konfiguration mit Java-config-web-Anwendung. Ich habe diese Arbeit mit Spring 3.2.0.RELEASE und SpringSecurity 3.2.0.M1. Hier die wichtigen Teile der Lösung

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

Hinweis, ich hätte zu entfernen die Standard xmlns="..." <Bohnen:Bohnen> definition.

<?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>

Versuchen "classpath:spring-security.xml" - weniger WEB-INF-spezifische...
Ich habe versucht, diese und stecken aufgrund von Abhängigkeiten zwischen java-config und die XML-Datei. Was erlaubt ist, hängt davon ab, was hier? Bin ich im Recht, denken die XML-config muss eigenständig sein und die java-config verwenden kann?

InformationsquelleAutor user2001823

1

Danke an alle für die obigen Hinweise über eine springSecurityFilterChain, wenn die Java-Konfiguration von Spring verwendet. Als ich gearbeitet habe, zusammen, um diese Hinweise, um fix eine vergleichbare Fehler in meinem eigenen code habe ich festgestellt, dass die Spring-Dokumentation für org.springframework.web.WebApplicationInitializer (die Schnittstelle implementiert AbstractAnnotationConfigDispatcherservletinitializer) hat die folgenden relevanten "Nachteil":

web.xml Versionierung

WEB-INF/web.xml und WebApplicationInitializer Nutzung schließen sich nicht gegenseitig aus; zum Beispiel web.xml registrieren kann ein servlet und eine WebApplicationInitializer können ein anderes register. Ein Initialisierer können auch ändern Registrierungen durchgeführt web.xml durch Methoden wie ServletContext.getServletRegistration(String).

Jedoch, wenn WEB-INF/web.xml ist in der Anwendung vorhanden, deren version-Attribut muss gesetzt werden, um "3.0" oder größer, sonst ServletContainerInitializer bootstrapping ignoriert werden von der servlet-container.

Ich betone das, weil ich bemerkte, dass Ihre web.xml die version oben ist noch 2.5.

InformationsquelleAutor Richard Bruskiewich

Ich habe es die Arbeit mit Spring 3.2.3 und Servlet 3.0. Die Zecke ist zu erweitern DelegatingFilterProxy Klasse und benannte es 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 {

}

}

Ich Frage mich, warum Sie das überschreiben dieser Methoden. Sie müssten eine vollständige code-Beispiel ? Ich habe Mühe mit der Konfiguration der Sicherheit mit JavaConfig nur.

InformationsquelleAutor Dario Strelec

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.