spring-security-5.0版本的xml基本配置

最新推荐文章于 2023-05-22 11:35:30 发布
最新推荐文章于 2023-05-22 11:35:30 发布
阅读量1.7k 收藏 2
点赞数
分类专栏： java 
<?xml version="1.0" encoding="UTF-8"?>
<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.xsd
             http://www.springframework.org/schema/security
             http://www.springframework.org/schema/security/spring-security.xsd">
    <beans:description>SpringSecurity安全配置</beans:description>
    <!-- http安全配置 -->
    <http use-expressions="true" auto-config="false"
        entry-point-ref="authenticationEntryPoint" name="empire"
        authentication-manager-ref="authenticationManager">
        <!-- session过滤器 -->
        <custom-filter position="CONCURRENT_SESSION_FILTER" ref="concurrencyFilter" />
        <!-- <intercept-url pattern="/static/**" access="permitAll" /> -->
        <intercept-url pattern="/**/*.jpg" access="permitAll" />
        <intercept-url pattern="/**/*.png" access="permitAll" />
        <intercept-url pattern="/**/*.gif" access="permitAll" />
        <intercept-url pattern="/**/*.css" access="permitAll" />
        <intercept-url pattern="/**/*.js" access="permitAll" />
        <!-- 尝试访问没有权限的页面时跳转的页面 -->
        <access-denied-handler error-page="/static/403.html" />
        <custom-filter ref="myFilter" before="FILTER_SECURITY_INTERCEPTOR" />
        <!-- ajax登录过滤器 -->
        <!-- <custom-filter before="FORM_LOGIN_FILTER" ref="ajaxLoginFilter" /> -->
        <custom-filter position="FORM_LOGIN_FILTER" ref="adminAjaxLoginFilter" />
        <!-- <custom-filter after="FORM_LOGIN_FILTER" ref="loginFilter" /> -->
        <headers>
            <frame-options policy="SAMEORIGIN"></frame-options>
        </headers>
        <!-- 只cache get,避免ajax post 被cache -->
        <request-cache ref="httpSessionRequestCache" />
        <session-management
            session-authentication-strategy-ref="sessionAuthenticationStrategy" />
        <!-- 注销过滤器 -->
        <!-- <logout invalidate-session="true" logout-success-url="/admin/login.html?logout=true" 
            logout-url="/j_spring_security_logout" /> -->
        <!-- 启用安全策略 -->
        <csrf disabled="false" token-repository-ref="csrfTokenRepository"
            request-matcher-ref="csrfSecurityRequestMatcher" />
        <custom-filter ref="rememberMeFilter" position="REMEMBER_ME_FILTER" />
        <custom-filter ref="logoutFilter" position="LOGOUT_FILTER" />
        <access-denied-handler ref="accessDeniedHandler" />
    </http>
    <beans:bean id="csrfSecurityRequestMatcher"
        class="pn.empire.security.handler.CsrfSecurityRequestMatcher">
        <beans:property name="execludeUrls">
            <beans:list>
                <beans:value>/workorder/adminuploadattachment.html</beans:value>
                <beans:value>/face/</beans:value>
            </beans:list>
        </beans:property>
    </beans:bean>
    <!-- -->
    <beans:bean id="accessDeniedHandler"
        class="pn.empire.security.handler.AccessDeniedHandlerImpl">
        <beans:property name="errorPage" value="/static/405.html"></beans:property>
    </beans:bean>
    <!--remember-me拦截器 -->
    <beans:bean id="rememberMeFilter"
        class="org.springframework.security.web.authentication.rememberme.RememberMeAuthenticationFilter">
        <beans:constructor-arg ref="authenticationManager" />
        <beans:constructor-arg ref="rememberMeServices" />
    </beans:bean>
    <beans:bean id="rememberMeServices"
        class="org.springframework.security.web.authentication.rememberme.PersistentTokenBasedRememberMeServices">
        <beans:constructor-arg value="key" />
        <beans:constructor-arg ref="userDetailsService" />
        <beans:constructor-arg ref="tokenRepository" />
        <beans:property name="tokenValiditySeconds" value="604800" />
    </beans:bean>

    <beans:bean id="tokenRepository"
        class="org.springframework.security.web.authentication.rememberme.JdbcTokenRepositoryImpl">
        <beans:property name="dataSource" ref="dataSourceMysql" />
        <!-- <beans:property name="createTableOnStartup" value="true"/> --> <!-- 是否在系统启动时创建持久化token的数据库表 -->
    </beans:bean>

    <beans:bean id="rememberMeAuthenticationProvider"
        class="org.springframework.security.authentication.RememberMeAuthenticationProvider">
        <beans:constructor-arg value="key" />
    </beans:bean>
    <!--remember-me拦截器 end -->
    <!--登出拦截器 -->
    <beans:bean id="logoutFilter"
        class="org.springframework.security.web.authentication.logout.LogoutFilter">
        <beans:constructor-arg value="/admin/unlogin.html?logout=true" />
        <beans:property name="filterProcessesUrl" value="/j_spring_security_logout" />
        <beans:constructor-arg>
            <beans:list>
                <beans:ref bean="rememberMeServices" />
                <beans:bean
                    class="org.springframework.security.web.csrf.CsrfLogoutHandler">
                    <beans:constructor-arg ref="csrfTokenRepository" />
                </beans:bean>
                <beans:bean
                    class="org.springframework.security.web.authentication.logout.CookieClearingLogoutHandler">
                    <beans:constructor-arg index="0">
                        <beans:array>
                            <beans:value>JSESSIONID</beans:value>
                            <beans:value>remember-me</beans:value>
                        </beans:array>
                    </beans:constructor-arg>
                </beans:bean>
                <beans:bean
                    class="org.springframework.security.web.authentication.logout.SecurityContextLogoutHandler" />
            </beans:list>
        </beans:constructor-arg>
    </beans:bean>
    <beans:bean id="csrfTokenRepository"
        class="org.springframework.security.web.csrf.HttpSessionCsrfTokenRepository" />



    <!-- session 控制 -->
    <beans:bean id="concurrencyFilter"
        class="pn.empire.security.filter.ConcurrentSessionFilter">
        <beans:constructor-arg ref="sessionRegistry" />
        <beans:constructor-arg value="/static/406.html" />
    </beans:bean>
    <beans:bean id="sessionAuthenticationStrategy"
        class="org.springframework.security.web.authentication.session.CompositeSessionAuthenticationStrategy">
        <beans:constructor-arg>
            <beans:list>
                <beans:bean
                    class="org.springframework.security.web.authentication.session.ConcurrentSessionControlAuthenticationStrategy">
                    <beans:constructor-arg ref="sessionRegistry" />
                    <beans:property name="maximumSessions" value="1" />
                    <beans:property name="exceptionIfMaximumExceeded"
                        value="false" />
                </beans:bean>
                <beans:bean
                    class="org.springframework.security.web.authentication.session.SessionFixationProtectionStrategy" />
                <beans:bean
                    class="org.springframework.security.web.authentication.session.RegisterSessionAuthenticationStrategy">
                    <beans:constructor-arg ref="sessionRegistry" />
                </beans:bean>
            </beans:list>
        </beans:constructor-arg>
    </beans:bean>
    <beans:bean id="sessionRegistry"
        class="org.springframework.security.core.session.SessionRegistryImpl" />
    <!-- session 控制 end -->
    <!-- 一个自定义的filter，必须包含authenticationManager,accessDecisionManager,securityMetadataSource三个属性， 
        我们的所有控制将在这三个类中实现，解释详见具体配置 -->
    <beans:bean id="myFilter"
        class="pn.empire.security.filter.SecurityInterceptorFilter">
        <beans:property name="authenticationManager" ref="authenticationManager" />
        <beans:property name="accessDecisionManager" ref="accessDecisionManager" />
        <beans:property name="securityMetadataSource" ref="securityMetadataSource" />
    </beans:bean>
    <beans:bean id="authSuccess"
        class="pn.empire.security.handler.AuthenticationSuccessHandler" />
    <beans:bean id="logoutSuccessHandler"
        class="pn.empire.security.handler.LogoutSuccessHandler" />
    <!-- 验证配置 ， 认证管理器，实现用户认证的入口，主要实现UserDetailsService接口即可 -->
    <authentication-manager alias="authenticationManager"
        erase-credentials="false">
        <authentication-provider user-service-ref="userDetailsService">
            <!-- 登入 密码 采用MD5加密 -->
            <password-encoder ref="passwordEncoder"/>
        </authentication-provider>
        <authentication-provider ref="rememberMeAuthenticationProvider" />
    </authentication-manager>
    <beans:bean id="passwordEncoder" class="pn.empire.security.handler.PwdEncodeHandler" />
    <!-- 项目实现的用户查询服务,将用户信息查询出来 -->
    <beans:bean id="userDetailsService"
        class="pn.empire.security.service.impl.UserDetailServiceImpl" />
    <!-- 访问决策器，决定某个用户具有的角色，是否有足够的权限去访问某个资源 -->
    <beans:bean id="accessDecisionManager"
        class="pn.empire.security.service.impl.AccessDecisionManager" />
    <!-- 资源源数据定义，将所有的资源和权限对应关系建立起来，即定义某一资源可以被哪些角色访问 -->
    <beans:bean id="securityMetadataSource"
        class="pn.empire.security.service.impl.InvocationSecurityMetadataSource" />

    <beans:bean id="messageSource"
        class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
        <beans:property name="basename"
            value="classpath:org/springframework/security/messages_zh_CN" />
    </beans:bean>
    <beans:bean id="authenticationEntryPoint"
        class="pn.empire.security.service.impl.AuthenticationEntryPoint">
        <beans:constructor-arg name="loginFormUrl"
            value="/admin/unlogin.html?entrypoint" />
    </beans:bean>
    <!-- 验证ajax请求 -->
    <beans:bean id="ajaxLoginFilter"
        class="pn.empire.security.filter.UsernamePasswordFilter">
        <beans:property name="authenticationManager" ref="authenticationManager" />
        <beans:property name="authenticationFailureHandler"
            ref="ajaxFailureHandler" />
        <beans:property name="authenticationSuccessHandler"
            ref="ajaxSuccessHandler" />
        <beans:property name="filterProcessesUrl" value="/ajaxLoginProcess" />
        <beans:property name="sessionAuthenticationStrategy"
            ref="sessionAuthenticationStrategy" />
    </beans:bean>
    <beans:bean id="ajaxFailureHandler"
        class="pn.empire.security.handler.AjaxAuthenticationFailureHandler">
    </beans:bean>
    <beans:bean id="ajaxSuccessHandler"
        class="pn.empire.security.handler.AjaxAuthenticationSuccessHandler">
    </beans:bean>
    <!-- 验证admin ajax请求 -->
    <beans:bean id="adminAjaxLoginFilter"
        class="pn.empire.security.filter.UsernamePasswordFilter">
        <beans:property name="authenticationManager" ref="authenticationManager" />
        <beans:property name="authenticationFailureHandler"
            ref="adminAjaxFailureHandler" />
        <beans:property name="authenticationSuccessHandler"
            ref="adminAjaxSuccessHandler" />
        <beans:property name="filterProcessesUrl" value="/adminAjaxLoginProcess" />
        <beans:property name="sessionAuthenticationStrategy"
            ref="sessionAuthenticationStrategy" />
        <beans:property name="rememberMeServices" ref="rememberMeServices" />
    </beans:bean>
    <beans:bean id="adminAjaxFailureHandler"
        class="pn.empire.security.handler.AdminAjaxAuthenticationFailureHandler">
    </beans:bean>
    <beans:bean id="adminAjaxSuccessHandler"
        class="pn.empire.security.handler.AdminAjaxAuthenticationSuccessHandler">
    </beans:bean>
    <!-- 验证普通用户 -->
    <beans:bean id="loginFilter"
        class="pn.empire.security.filter.UsernamePasswordFilter">
        <beans:property name="authenticationManager" ref="authenticationManager" />
        <beans:property name="authenticationFailureHandler"
            ref="failureHandler" />
        <beans:property name="authenticationSuccessHandler"
            ref="authSuccess" /> <!-- ref="successHandler"/> -->
        <beans:property name="filterProcessesUrl" value="/loginProcess" />
        <beans:property name="sessionAuthenticationStrategy"
            ref="sessionAuthenticationStrategy" />
    </beans:bean>

    <beans:bean id="failureHandler"
        class="org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler">
        <beans:property name="defaultFailureUrl" value="/admin/login.html?login_error=1" />
    </beans:bean>

    <beans:bean id="successHandler"
        class="org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler">
        <beans:property name="alwaysUseDefaultTargetUrl" value="false" />
        <beans:property name="defaultTargetUrl" value="/" />
    </beans:bean>
    <beans:bean id="httpSessionRequestCache"
        class="org.springframework.security.web.savedrequest.HttpSessionRequestCache">
    </beans:bean>
</beans:beans>

首先来说http配置：
1.use-expressions：是否启用intercept-url元素的access属性对Spring EL表达式的支持，但是在配置中并没有使用到。
2.auto-config：是否启用默认配置，在配置中设置为false，基本都采用自定义配置。

  1. entry-point-ref：第三方登录入口，认证不通过则抛出一个异常给ExceptionTranslationFilter，由它进行通过entry-point-ref设置的入口点进行处理，通过此配置可以重定向到其他页面。
    4.authentication-manager-ref：引用的AuthenticationManager,指定身份验证bean，我觉得可以算作核心了。
    5.session过滤器，代码如下：
  <custom-filter position="CONCURRENT_SESSION_FILTER" ref="concurrencyFilter" />

主要功能为当用户session过期用户却继续访问时，系统会跳转至指定路径。
6.access-denied-handler:访问失败才会进AccessDeniedHandler，如果是未登录或者会话超时等，不会触发AccessDeniedHandler，而是会直接跳转到登录页面
7.custom-filter：自定义登录登出记住我过滤器。
8.开启csrf，csrf生成的token是存储在cookies中，防止跨域攻击，所以并不能防止重复提交。
9.为了页面中可以使用iframe，配置header：

<headers>
            <frame-options policy="SAMEORIGIN"></frame-options>
</headers>

下面说一下注册的bean
1.csrfSecurityRequestMatcher：这个bean控制了那些路径不需要csrf限制，比如说一些接口、富文本编辑之类。

    private Pattern allowedMethods = Pattern.compile("^(GET|HEAD|TRACE|OPTIONS)$");
    private RegexRequestMatcher unprotectedMatcher = new RegexRequestMatcher("/unprotected", null);
    @Override
    public boolean matches(HttpServletRequest request) {
        if (execludeUrls != null && execludeUrls.size() > 0) {
            String servletPath = request.getServletPath();
            for (String url : execludeUrls) {
                if (servletPath.contains(url)) {
                    return false;
                }
            }
        }
        if (allowedMethods.matcher(request.getMethod()).matches()) {
            return false;
        }
        return !unprotectedMatcher.matches(request);
    }

可以看一下代码，除了指定路径外，还对GET、HEAD、TRACE、OPTIONS免除了csrf过滤，主要是针对post请求进行过滤。

2.accessDeniedHandler:访问失败才会进AccessDeniedHandler，如果是未登录或者会话超时等，不会触发AccessDeniedHandler，而是会直接跳转到登录页面。
3.rememberMeFilter:配置的记住我过滤器，注入身份验证bean以及rememberMeServices。
4.rememberMeServices：注入userDetailsService和token存储。
5.tokenRepository：token处理方式，在配置中选择在数据库中进行存储
6.rememberMeAuthenticationProvider:token的处理类，key要一致，官方说明如下：

This implementation supports the simpler approach described in [Section 18.2, “Simple Hash-Based Token Approach”](https://docs.spring.io/spring-security/site/docs/5.0.0.RELEASE/reference/htmlsingle/#remember-me-hash-token "18.2 Simple Hash-Based Token Approach"). `TokenBasedRememberMeServices` generates a `RememberMeAuthenticationToken`, which is processed by `RememberMeAuthenticationProvider`. A `key` is shared between this authentication provider and the `TokenBasedRememberMeServices`. In addition, `TokenBasedRememberMeServices` requires A UserDetailsService from which it can retrieve the username and password for signature comparison purposes, and generate the `RememberMeAuthenticationToken` to contain the correct `GrantedAuthority` s. Some sort of logout command should be provided by the application that invalidates the cookie if the user requests this. `TokenBasedRememberMeServices` also implements Spring Security’s `LogoutHandler` interface so can be used with `LogoutFilter` to have the cookie cleared automatically.

The beans required in an application context to enable remember-me services are as follows:

<pre class="programlisting" style="line-height: 1.4; color: black; font-size: 15px; padding: 6px 10px; background-color: rgb(248, 248, 248); border: 1px solid rgb(204, 204, 204); border-radius: 3px; clear: both; overflow: auto; font-family: Consolas, &quot;Liberation Mono&quot;, Courier, monospace; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;"><bean id="rememberMeFilter" class=
"org.springframework.security.web.authentication.rememberme.RememberMeAuthenticationFilter">
<property name="rememberMeServices" ref="rememberMeServices"/>
<property name="authenticationManager" ref="theAuthenticationManager" />
</bean>

<bean id="rememberMeServices" class=
"org.springframework.security.web.authentication.rememberme.TokenBasedRememberMeServices">
<property name="userDetailsService" ref="myUserDetailsService"/>
<property name="key" value="springRocks"/>
</bean>

<bean id="rememberMeAuthenticationProvider" class=
"org.springframework.security.authentication.RememberMeAuthenticationProvider">
<property name="key" value="springRocks"/>
</bean></pre>

Don’t forget to add your `RememberMeServices` implementation to your `UsernamePasswordAuthenticationFilter.setRememberMeServices()` property, include the `RememberMeAuthenticationProvider` in your `AuthenticationManager.setProviders()` list, and add `RememberMeAuthenticationFilter` into your `FilterChainProxy` (typically immediately after your `UsernamePasswordAuthenticationFilter`).

7.logoutFilter:自定义登出过滤器，之所以配置这么复杂是为了配合remember-me功能、以及用户只能在一处登录的功能、csrf过滤用能使用。
8.csrfTokenRepository：csrfToken仓库，用户访问后会生成csrf token存在用户浏览器的cookies中，会对用户每次符合验证规则的请求进行token校验，防止跨域攻击，但是不能防止重复提交。在一个会话中，token是一致的。
9.myFilter:继承AbstractSecurityInterceptor，负责处理HTTP资源的安全性。整个过程需要依赖AuthenticationManager、AccessDecisionManager和FilterInvocationSecurityMetadataSource。
10.authSuccess:自定义的表单登录成功处理器。
11.logoutSuccessHandler：登出成功处理器
12.authenticationManager：用户信息认证管理器。
13.passwordEncoder：根据自定义加密方式进行比对
14.userDetailsService：自定义用户信息类。
15.accessDecisionManager：访问决策器，定义了资源可以被哪些角色访问。
16.securityMetadataSource：资源-角色对应关系。
17.messageSource:security的国际化加载
18.authenticationEntryPoint：第三方登录入口，自定义该bean主要是为了ajax登录。
19.ajaxLoginFilter：ajax登录过滤器。
20.ajaxFailureHandler：ajax登录失败处理器
21.ajaxSuccessHandler：ajax登录成功处理器
下面就类似了，当初定义了三个登录不同的界面，所以写才的如此麻烦。
httpSessionRequestCache：可以理解为缓存控制。



作者：Mr_加菲
链接：https://www.jianshu.com/p/8a1312c7b1d0
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

haogexiaole
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
安全认证服务框架Spring Security及Spring-Security.xml配置
u011918475的博客
10-28 543
Spring Security是 Spring提供的安全认证服务的框架。 使用Spring Security可以帮助我们来简化认证和授权的过程。常用的权限框架除了Spring Security，还有Apache的shiro框架。 构建思路： 创建子模块health_security,使用webapp骨架 初始化模块资源 pom文件（依赖health_common、spring-webmvc、security-web、security-config、tomcat7(6080)） 初始化目录结构（java(
学习笔记七-AuthenticationProvider
热门推荐
云智禅师的专栏
12-13 3万+
AuthenticationProvider 认证是由 AuthenticationManager 来管理的，但是真正进行认证的是 AuthenticationManager 中定义的 AuthenticationProvider。AuthenticationManager 中可以定义有多个 AuthenticationProvider。当我们使用 authentication-provid
Spring-MVC头文件
qq_42516774的博客
09-18 693
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.spri...
spring security 5 (5)-自定义认证
JAVA博客
03-10 5445
第3篇讲过，用户登录时，系统会读取用户的UserDetails对其认证，认证过程是由系统自动完成的，主要是检查用户密码。而在现实中，登录方式并不一定是检查密码，也可能是验证码或其他，此时就需要自定义认证。 AuthenticationProvider 自定义认证逻辑在AuthenticationProvider的authenticate方法中完成，第4篇讲过，认证的入参是一个未认证Authen...
maven配置spring security5新手简单入门配置
qq_37099009的博客
09-23 1350
1.pom依赖 <!-- Spring Security--> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-web</artifactId> <...
Spring Security（2）案例：包含spring-security.xml等配置
учёба
11-08 973
底层是基于过滤器的 第一步：工程搭建 创建maven工程，打包方式为war <!-- Spring --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version&gt
Spring Security 配置实例XML文件
06-13
Spring Security 配置实例XML文件
Spring Security配置AuthenticationManager
qq_44113347的博客
05-22 1600
Override总结一旦通过 configure 方法自定义 AuthenticationManager 实现 就回将工厂中自动配置 AuthenticationManager 进行覆盖一旦通过 configure 方法自定义 AuthenticationManager 实现 需要在实现中指定认证数据源对象 UserDetaiService 实例。
SpringSecurity系列 - 09 SpringSecurity 自定义认证数据源实现用户认证
你今天真好看呀
09-14 1289
// 自定义AuthenticationManager:并没有在工厂中暴露出来 @Override protected void configure(AuthenticationManagerBuilder builder) throws Exception {} }① 创建数据库表② 插入数据BEGIN;COMMIT;BEGIN;INSERT INTO ` role ` VALUES(1 , 'ROLE_product' , '商品管理员');
spring-security.xml配置文件（自用）
c_2333的博客
08-15 500
代码】spring-security.xml配置文件（自用）
单点登录sso-shiro-cas-maven
10-19
最后我们还需要在/spring-node-1/src/main/webapp/WEB-INF/web.xml 文件中配置相关的过滤器拦截全部请求 ``` xml <filter-name>shiroFilter</filter-name> <filter-class>org.springframework.web.filter....
asp.net知识库
06-18
XCodeFactory3.0完全攻略－－基本思想 XCodeFactory3.0完全攻略－－简单示例 XCodeFactory3.0完全攻略－－IDBAccesser XCodeFactory2.0完全手册（中） XCodeFactory2.0完全手册（上） XCodeFactory3.0Beta1推出 ! ...
psecurity配置
aikong3218的博客
08-26 172
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:security="http://www.springframework.org/schema/security" xmlns:xsi="ht...
SpringSecurity框架(一)xml方式
暖阳阳
05-20 7775
Spring Security 简介 　　　Spring Security 是一个能够为基于 Spring 的企业应用系统提供声明式的安全访问控制解 决方案的安全框架。它提供了一组可以在 Spring 应用上下文中配置的 Bean，充分利用了 Spring IoC，DI（控制反转 Inversion of Control ,DI:Dependency Injection 依赖注入）和 AOP...
SpringSecurity安全框架（xml版）
武汉小喽啰
02-04 1042
1. 简介 Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC，DI（控制反转Inversion of Control ,DI:Dependency Injection 依赖注入）和AOP（面向切面编程）功能，为应用系统提供声明...
spring security xml配置详解
Nancy_8_的博客
10-20 629
 spring security xml配置详解(拷贝大神)    security 3.x &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans:beans xmlns="http://www.springframework.org/schema/security" xmlns:beans="http://www.sp...
springsecurity+oauth2+springmvc+hibernate
cai_chinasoft的专栏
06-01 5421
springsecurity+oauth+springmvc+hibernate+bootstrap 后台基础框架
编码技巧——HTTP接口安全防范CSRF攻击
娜娜米的博客
04-19 3398
​ 上一篇《编码技巧——HTTP接口安全防范CORS攻击》介绍了同源策略、跨域、CORS，本篇介绍下CRSF漏洞及常用服务端解决方案； 思考一个问题：如果你说 同源策略SOP 就是“禁止跨域请求”，这也不完全准确，因为本质上 SOP 并不是禁止跨域请求，而是在请求后拦截了请求的回应。因此——这就会引起CSRF漏洞，即被恶意网站模拟的、带上了cookies（虽然由于SOP策略读不到cookies信息）的、非用户预期的请求，已经打到了服务端的接口上！
前18大旋转修整器企业占据全球87%的市场份额.docx
最新发布
05-06
前18大旋转修整器企业占据全球87%的市场份额
spring-security-jwt 版本对照表
09-18
spring-security-jwt 是一个基于 Spring Security 的 JSON Web Token（JWT）集成库。它将 JWT 的认证和授权过程与 Spring Security 进行了深度集成，方便开发人员使用 JWT 进行身份验证和权限控制。 以下是 spring-security-jwt 的版本对照表： - 版本1.0.0：最初发布的版本，提供了基本的 JWT 支持，包括 JWT 的生成、解析和校验。 - 版本1.1.0：在1.0.0版本的基础上进行了一些改进，增加了对 JWT 的加密和解密功能，提供了更加安全的身份验证和授权机制。 - 版本1.2.0：引入了一些新的特性，包括对 JWT 的刷新和延长过期时间的支持，使得 JWT 的使用更加灵活和方便。 - 版本2.0.0：在1.x 版本的基础上进行了重构，提供了更加简洁和易用的 API 接口，优化了性能和稳定性。 - 版本2.1.0：在2.0.0版本的基础上增加了对 OAuth2 的支持，使得开发人员可以更方便地集成第三方身份验证和授权服务。 以上是针对 spring-security-jwt 的一些常见版本，每个版本都有不同的功能和改进。开发人员可以根据自己的需求选择合适的版本，并且可以从官方文档中获取更详细的版本说明和用法示例。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值