spring Security3.1安全框架完整配置教程

wtsoftware wtsoftware 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 300+累计阅读 313平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄19年
关注
原创 最新推荐文章于 2026-09-21 11:16:35 发布 313 阅读 AI 写同款· GEO 优化 ›

文章转自 ：http://www.dev26.com/blog/article/113/1 <!--EndFra-->

前端时间一直在研究spring Security3.1这个框架,感觉用着还算不错,包括本站也是使用是了这个框架正好利用这个机会学习一下.特地给大家分享一下,希望对大家有所帮助.对这个框架的介绍就不用多说了,网上都有相关的资料.我要介绍的是如何利用数据库来存储所有的权限,这样的话就直接可以通过在数据库中增加记录来扩展权限,不用每次都要在XML中配置权限.

为了测试更加方便我用的是haldb数据库,比较简单.

首先到spring官网把最新版的spring Security安全框架的压缩文件下载下来:

http://www.springsource.org/spring-community-download 


然后在Eclipse中新一个Web工程,在web.xml中加入以下权限过滤器来控制来拦截所有访问

1
2
3
4
5
6
7
8
< 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中引入spring 的bean配置文件:

1
2
3
4
5
6
7
   < context-param >
       < param-name >contextConfigLocation</ param-name >
       < param-value >classpath:applicationContext*.xml</ param-value >
   </ context-param >
< listener >
       < listener-class >org.springframework.web.context.ContextLoaderListener</ listener-class >
   </ listener >

整工程截图如下:


以下是hqldb的初始化脚本,也不用建库只要把hqldb.jar放到工程中则会自动执行.这就是工程的test.script的脚本sql

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
CREATE  SCHEMA  PUBLIC  AUTHORIZATION  DBA
CREATE  MEMORY  TABLE  RESC(ID  BIGINT  GENERATED  BY  DEFAULT  AS  IDENTITY(START  WITH  1)  NOT NULL , NAME  VARCHAR (50),RES_TYPE  VARCHAR (50),RES_STRING  VARCHAR (200),PRIORITY INTEGER ,DESCN  VARCHAR (200), CONSTRAINT  PK_RESC  PRIMARY  KEY (ID))
CREATE  MEMORY  TABLE  ROLE(ID  BIGINT  GENERATED  BY  DEFAULT  AS  IDENTITY(START  WITH  1)  NOT NULL , NAME  VARCHAR (50),DESCN  VARCHAR (200), CONSTRAINT  PK_ROLE  PRIMARY  KEY (ID))
CREATE  MEMORY  TABLE  USER (ID  BIGINT  GENERATED  BY  DEFAULT  AS  IDENTITY(START  WITH  1)  NOT NULL ,USERNAME  VARCHAR (50), PASSWORD  VARCHAR (50),STATUS  INTEGER ,DESCN VARCHAR (200), CONSTRAINT  PK_USER  PRIMARY  KEY (ID))
CREATE  MEMORY  TABLE  RESC_ROLE(RESC_ID  BIGINT  NOT  NULL ,ROLE_ID  BIGINT  NOT NULL , CONSTRAINT  PK_RESC_ROLE  PRIMARY  KEY (RESC_ID,ROLE_ID), CONSTRAINT  FK_RESC_ROLE_RESC FOREIGN  KEY (RESC_ID)  REFERENCES  RESC(ID), CONSTRAINT  FK_RESC_ROLE_ROLE  FOREIGN KEY (ROLE_ID)  REFERENCES  ROLE(ID))
CREATE  MEMORY  TABLE  USER_ROLE(USER_ID  BIGINT  NOT  NULL ,ROLE_ID  BIGINT  NOT NULL , CONSTRAINT  PK_USER_ROLE  PRIMARY  KEY (USER_ID,ROLE_ID), CONSTRAINT  FK_USER_ROLE_USER FOREIGN  KEY (USER_ID)  REFERENCES  USER (ID), CONSTRAINT  FK_USER_ROLE_ROLE  FOREIGN KEY (ROLE_ID)  REFERENCES  ROLE(ID))
ALTER  TABLE  RESC  ALTER  COLUMN  ID RESTART  WITH  3
ALTER  TABLE  ROLE  ALTER  COLUMN  ID RESTART  WITH  3
ALTER  TABLE  USER  ALTER  COLUMN  ID RESTART  WITH  3
CREATE  USER  SA  PASSWORD  ""
GRANT  DBA  TO  SA
SET  WRITE_DELAY 10
SET  SCHEMA  PUBLIC
INSERT  INTO  RESC  VALUES (1, '' , 'URL' , '/admin.jsp' ,1, '' )
INSERT  INTO  RESC  VALUES (2, '' , 'URL' , '/**' ,2, '' )
INSERT  INFO RESC VALUES (3, '' , 'METHOD' , 'com.dev26.springsecuritybook.MessageService.adminMessage' ,3, '' );
INSERT  INTO  ROLE  VALUES (1, 'ROLE_ADMIN' , '\u7ba1\u7406\u5458\u89d2\u8272' )
INSERT  INTO  ROLE  VALUES (2, 'ROLE_USER' , '\u7528\u6237\u89d2\u8272' )
INSERT  INTO  USER  VALUES (1, 'admin' , 'admin' ,1, '\u7ba1\u7406\u5458' )
INSERT  INTO  USER  VALUES (2, 'user' , 'user' ,1, '\u7528\u6237' )
INSERT  INTO  RESC_ROLE  VALUES (1,1)
INSERT  INTO  RESC_ROLE  VALUES (2,1)
INSERT  INTO  RESC_ROLE  VALUES (2,2)
INSERT  INTO  RESC_ROLE  VALUES (3,1)
INSERT  INTO  USER_ROLE  VALUES (1,1)
INSERT  INTO  USER_ROLE  VALUES (1,2)
INSERT  INTO  USER_ROLE  VALUES (2,2)

这些是基本配置文件,然后咱在分析一下spring Security的运行基制,然后在在看另一个applicationContext.xml中的配置就比较容易了.


Spring Security是一个基于角色的权限框架(Role  Based Access Control,RBAC),它通过一系列可配置的组件构建了基于Spring IOC组件装配模式的安全框架.系统中对用于分配角色,而

角色由被授于相应的权限(增加、浏览、删除、更新..),在校验的时候首先要确定用户所属地的角色，然后根据角色来判断当前用户有哪些权限。这只是Spring Security框架的部分功能，其实它比较丰富的配置和扩展比如:(用户组(Group)的配置、ACL权限配置、CAS集成等)。


首先要配置的是一个org.springframework.web.filter.DelegatingFilterProxy的过滤器在webm.xml中这是Spring Security的一个入口，它内部有一个过滤器链。学过Acegi的朋友可能比较了解，这个例子就不深究了。

以下是Secutirity本应的配置，在applicationContext.xml中

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
<? 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/beanshttp://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                         http://www.springframework.org/schema/securityhttp://www.springframework.org/schema/security/spring-security-3.1.xsd">
                   
     < http   auto-config = "true" >
                     
     </ http >
     <!--通过SQL语句关联查询当前用户所拥有的权限  -->
< authentication-manager >
         < authentication-provider >
             < jdbc-user-service  data-source-ref = "dataSource"
                 users-by-username-query="select username,password,status as enabled
                                        from user
                                       where username=?"
                 authorities-by-username-query="select u.username,r.name as authority
                                              from user u
                                              join user_role ur
                                                on  u.id = ur .user_id
                                              join role r
                                                on  r.id = ur .role_id
                                             where u.username=?"  />
         </ authentication-provider >
     </ authentication-manager >
               
     < global-method-security  />
               
<!--更新权限缓存,不用每次重启服务  -->
     < beans:bean  id = "resourceDetailsMonitor"
         class = "com.dev26.springsecuritybook.ResourceDetailsMonitor2"
         autowire = "byType" >
         < beans:property  name = "dataSource"  ref = "dataSource"  />
         < beans:property  name = "accessDecisionManager"  ref = "accessDecisionManager"  />
     </ beans:bean >
<!--数据源  -->
     < beans:bean  id = "dataSource"
         class = "org.springframework.jdbc.datasource.DriverManagerDataSource" >
         < beans:property  name = "driverClassName"  value = "org.hsqldb.jdbcDriver"  />
         < beans:property  name = "url"  value = "jdbc:hsqldb:res:/hsqldb/test"  />
         < beans:property  name = "username"  value = "sa"  />
         < beans:property  name = "password"  value = ""  />
     </ beans:bean >
     <!--决策管理器  -->
     < beans:bean  id = "accessDecisionManager"
         class = "org.springframework.security.access.vote.AffirmativeBased" >
         < beans:property  name = "allowIfAllAbstainDecisions"
             value = "false"  />
         < beans:property  name = "decisionVoters" >
             < beans:list >
             < beans:bean  class = "com.dev26.springsecuritybook.MyRoleVoter"  />
                 < beans:bean
                     class = "org.springframework.security.access.vote.AuthenticatedVoter" />
             </ beans:list >
         </ beans:property >
     </ beans:bean >
     < beans:bean  id = "messageService"
         class = "com.dev26.springsecuritybook.MessageServiceImpl"  />
</ beans:beans >

权限缓存刷新类代码ResourceDetailsMonitor2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
package  com.dev26.springsecuritybook;
         
import  java.util.ArrayList;
import  java.util.Collection;
import  java.util.List;
         
import  javax.sql.DataSource;
         
import  org.springframework.beans.factory.InitializingBean;
import  org.springframework.security.access.AccessDecisionManager;
import  org.springframework.security.access.intercept.aopalliance.MethodSecurityInterceptor;
import  org.springframework.security.access.method.DelegatingMethodSecurityMetadataSource;
import  org.springframework.security.access.method.MethodSecurityMetadataSource;
import org.springframework.security.web.access.intercept.FilterInvocationSecurityMetadataSource;
import  org.springframework.security.web.access.intercept.FilterSecurityInterceptor;
         
import  com.dev26.springsecuritybook.ResourceDetailsBuilder;
         
public  class  ResourceDetailsMonitor2  implements  InitializingBean {
             
       private  String queryUrl =  "select re.res_string,r.name"  +
       "                      from role r"  +
       "                      join resc_role rr"  +
       "                        on r.id=rr.role_id"  +
       "                      join resc re"  +
       "                        on re.id=rr.resc_id"  +
       "                     where re.res_type='URL'"  +
       "                  order by re.priority" ;  private  String queryMethod =
       "select re.res_string,r.name"  +  "                      from role r"  +
       "                      join resc_role rr"  +
       "                        on r.id=rr.role_id"  +
       "                      join resc re"  +
       "                        on re.id=rr.resc_id"  +
       "                     where re.res_type='METHOD'"  +
       "                  order by re.priority" ;
              
     private  DataSource dataSource;
     private  FilterSecurityInterceptor filterSecurityInterceptor;
     private  org.springframework.security.access.method.DelegatingMethodSecurityMetadataSource delegatingMethodDefinitionSource;
     private  AccessDecisionManager accessDecisionManager;
     private  ResourceDetailsBuilder resourceDetailsBuilder;
     private  MethodSecurityInterceptor methodSecurityInterceptor;
     private  Collection hasMethodAttribute;
     private  Collection hasUrlAttribut;
         
     public  void  setQueryUrl(String queryUrl) {
         this .queryUrl = queryUrl;
     }
         
     public  void  setQueryMethod(String queryMethod) {
         this .queryMethod = queryMethod;
     }
         
     public  void  setDataSource(DataSource dataSource) {
         this .dataSource = dataSource;
     }
         
     public  FilterSecurityInterceptor getFilterSecurityInterceptor() {
         return  filterSecurityInterceptor;
     }
         
     public  void  setFilterSecurityInterceptor(
             FilterSecurityInterceptor filterSecurityInterceptor) {
         this .filterSecurityInterceptor = filterSecurityInterceptor;
     }
         
     public  org.springframework.security.access.method.DelegatingMethodSecurityMetadataSource getDelegatingMethodDefinitionSource() {
         return  delegatingMethodDefinitionSource;
     }
         
     public  void  setDelegatingMethodDefinitionSource(
             org.springframework.security.access.method.DelegatingMethodSecurityMetadataSource delegatingMethodDefinitionSource) {
         this .delegatingMethodDefinitionSource = delegatingMethodDefinitionSource;
     }
         
     public  ResourceDetailsBuilder getResourceDetailsBuilder() {
         return  resourceDetailsBuilder;
     }
         
     public  void  setResourceDetailsBuilder(
             ResourceDetailsBuilder resourceDetailsBuilder) {
         this .resourceDetailsBuilder = resourceDetailsBuilder;
     }
         
     public  String getQueryUrl() {
         return  queryUrl;
     }
         
     public  String getQueryMethod() {
         return  queryMethod;
     }
         
     public  DataSource getDataSource() {
         return  dataSource;
     }
         
     public  void  afterPropertiesSet() {
         resourceDetailsBuilder =  new  ResourceDetailsBuilder(dataSource);
         filterSecurityInterceptor
                 .setAccessDecisionManager(accessDecisionManager);
         this .hasMethodAttribute = delegatingMethodDefinitionSource
                 .getAllConfigAttributes();
         this .hasUrlAttribut = filterSecurityInterceptor
                 .getSecurityMetadataSource().getAllConfigAttributes();
         refresh();
     }
         
     public  void  refresh() {
         if  (filterSecurityInterceptor !=  null ) {
             FilterInvocationSecurityMetadataSource source = resourceDetailsBuilder
                     .createUrlSource(queryUrl);
             source.getAllConfigAttributes().addAll(hasUrlAttribut);
             filterSecurityInterceptor.setSecurityMetadataSource(source);
         }
         if  (delegatingMethodDefinitionSource !=  null ) {
             MethodSecurityMetadataSource source = resourceDetailsBuilder
                     .createMethodSource(queryMethod);
             delegatingMethodDefinitionSource.getMethodSecurityMetadataSources()
                     .clear();
             delegatingMethodDefinitionSource.getMethodSecurityMetadataSources()
                     .add(source);
             List<MethodSecurityMetadataSource> list =  new ArrayList<MethodSecurityMetadataSource>();
             source.getAllConfigAttributes().addAll(hasMethodAttribute);
             list.add(source);
             delegatingMethodDefinitionSource =  new  DelegatingMethodSecurityMetadataSource(
                     list);
             ;
             methodSecurityInterceptor
                     .setSecurityMetadataSource(delegatingMethodDefinitionSource);
             try  {
                 // methodSecurityInterceptor.afterPropertiesSet();
             }  catch  (Exception e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         }
         
         System.out.println( "-------------------------refresh" );
     }
         
     public  AccessDecisionManager getAccessDecisionManager() {
         return  accessDecisionManager;
     }
         
     public  void  setAccessDecisionManager(
             AccessDecisionManager accessDecisionManager) {
         this .accessDecisionManager = accessDecisionManager;
     }
         
     public  MethodSecurityInterceptor getMethodSecurityInterceptor() {
         return  methodSecurityInterceptor;
     }
         
     public  void  setMethodSecurityInterceptor(
             MethodSecurityInterceptor methodSecurityInterceptor) {
         this .methodSecurityInterceptor = methodSecurityInterceptor;
     }
         
}




扩展决策机制，如果用户有多个角色，只要有一个决色拥有权限则通过校验.MyRoleVoter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
package  com.dev26.springsecuritybook;
             
import  java.util.Collection;
             
import  org.springframework.security.access.AccessDecisionVoter;
import  org.springframework.security.access.ConfigAttribute;
import  org.springframework.security.core.Authentication;
import  org.springframework.security.core.GrantedAuthority;
             
public  class  MyRoleVoter  implements  AccessDecisionVoter<Object> {
     private  String rolePrefix =  "ROLE_" ;
             
     public  String getRolePrefix() {
         return  rolePrefix;
     }
             
     public  void  setRolePrefix(String rolePrefix) {
         this .rolePrefix = rolePrefix;
     }
             
     public  boolean  supports(ConfigAttribute attribute) {
         if  ((attribute.getAttribute() !=  null )
                 && attribute.getAttribute().startsWith(getRolePrefix())) {
             return  true ;
         }  else  {
             return  false ;
         }
     }
             
     /**
      * This implementation supports any type of class, because it does not query
      * the presented secure object.
      *
      * @param clazz
      *            the secure object
      *
      * @return always <code>true</code>
      */
     public  boolean  supports(Class<?> clazz) {
         return  true ;
     }
             
     public  int  vote(Authentication authentication, Object object,
             Collection<ConfigAttribute> attributes) {
         int  result = ACCESS_ABSTAIN;
         Collection<?  extends  GrantedAuthority> authorities = extractAuthorities(authentication);
         for  (ConfigAttribute attribute : attributes) {
             if  ( this .supports(attribute)) {
                 result = ACCESS_DENIED;
                 // Attempt to find a matching granted authority
                 for  (GrantedAuthority authority : authorities) {
                     String[] roles = attribute.getAttribute().split( "," );
                     for  (String string : roles) {
                         if  (string.equals(authority.getAuthority())) {
                             return  ACCESS_GRANTED;
                         }
                     }
             
                 }
             }
         }
         return  result;
     }
             
     Collection<?  extends  GrantedAuthority> extractAuthorities(
             Authentication authentication) {
         return  authentication.getAuthorities();
     }
             
}


以下是业务类，被保护的方法已经在上面的SQL脚本中进行了初始化:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package  com.dev26.springsecuritybook;
             
public  class  MessageServiceImpl  implements  MessageService {
     public  String adminMessage() {
         return  "admin message" ;
     }
             
     public  String adminDate() {
         return  "admin "  + System.currentTimeMillis();
     }
             
     public  String userMessage() {
         return  "user message" ;
     }
             
     public  String userDate() {
         return  "user "  + System.currentTimeMillis();
     }
}


让我来验证一下，首先要编写一个登录页面:login.jsp

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page pageEncoding="UTF-8" %>
           
< html >
   < head >
     < title >Login</ title >
   </ head >
           
   < body  onload = "document.f.j_username.focus();" >
     < h1 >Login</ h1 >
           
     < p >Valid users:
     < p >
     < p >username < b >rod</ b >, password < b >koala</ b >
     < p >username < b >dianne</ b >, password < b >emu</ b >
     < p >username < b >scott</ b >, password < b >wombat</ b >
     < p >username < b >peter</ b >, password < b >opal</ b > (user disabled)
     < p >username < b >bill</ b >, password < b >wombat</ b >
     < p >username < b >bob</ b >, password < b >wombat</ b >
     < p >username < b >jane</ b >, password < b >wombat</ b >
     < p >
           
     < p >Locale is: <%= request.getLocale() %></ p >
     <%-- this form-login-page form is also used as the
          form-error-page to ask for a login again.
          --%>
     < c:if  test = "${not empty param.login_error}" >
       < font  color = "red" >
         Your login attempt was not successful, try again.< br />< br />
         Reason: < c:out  value = "${SPRING_SECURITY_LAST_EXCEPTION.message}" />.
       </ font >
     </ c:if >
           
     < form  name = "f"  action="<c:url  value = 'j_spring_security_check' />" method="POST">
       < table >
         < tr >< td >User:</ td >< td >< input  type = 'text'  name = 'j_username'  value='<c:if test = "${not empty param.login_error}" >< c:out value = "${SPRING_SECURITY_LAST_USERNAME}" /></ c:if >'/></ td ></ tr >
         < tr >< td >Password:</ td >< td >< input  type = 'password'  name = 'j_password' ></ td ></ tr >
         < tr >< td >< input  type = "checkbox"  name = "_spring_security_remember_me" ></ td >< td >Don't ask for my password for two weeks</ td ></ tr >
           
         < tr >< td  colspan = '2' >< input  name = "submit"  type = "submit" ></ td ></ tr >
         < tr >< td  colspan = '2' >< input  name = "reset"  type = "reset" ></ td ></ tr >
       </ table >
           
     </ form >
           
   </ body >
</ html >

如果通过校验则进入idnex.jsp

 

1
2
3
4
5
6
7
8
9
10
<%@ taglib prefix="security" uri="http://www.springframework.org/security/tags" %>
< div >username :< security:authentication  property = "principal.username" /></ div >
< hr >
< a  href = "admin.jsp" >admin.jsp</ a >
|
< a  href = "admin-method.jsp" >admin-method.jsp</ a >
|
< a  href = "user-method.jsp" >user-method.jsp</ a >
|
< a  href = "j_spring_security_logout" >logout</ a >

如果你是用普通户登录的，如果进行admin-method.jsp则会被拦截,user-method.jsp则可以访问，如果有物是admin的角色由都可以进行访问.






如果点击admin.jsp



收录于
JAVA框架知识

当前文章被收录于：

JAVA框架知识
4 篇文章 0 人学习
订阅专栏 查看详情
标签
#java #数据库 #前端 #ViewUI
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
基于Spring家族的Spring Security安全框架 一、Spring Security介绍 spring security 是基于 spring 的安全框架。它提供全面的安全性解决方案，同时在 Web 请求级和方法调用级处理身份确认和授权。在 Spring Framework 基础上，spring security 充分利用了依赖注入（DI）和面向切面编程（AOP）功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码的工作。是一个轻量级的安全框架。它与 Spring MVC 有很好地集成. 核心功能：认证、验证 原理： 阅读详情

相关推荐

Spring Boot 3 集成 Spring Security（1）认证

Spring Security的重要核心功能功能是“认证”和“授权”，即**用户认证（Authentication）和用户授权（Authorization）**两部分：（1）用户认证：验证某个用户是否为系统中的合法主体，也就是说用户能否访问该系统。用户认证一般要求提供用户名和密码，系统通过校验用户名和密码来完成认证过程。（2）用户授权：验证某个用户是否有权限执行某个操作。在一个系统中，不同用户所具有的权限是不同的。比如对一个文件来说，有的用户只能进行读取，而有的用户可以进行修改。

Harry的博客 1962

Spring boot 3 (3.1.5) Spring Security 设置一

api/welcome 直接就能看到内容， /api/admin 则返回401。创建两个路由 /api/welcome 和 /api/admin。JWTFilter.java代码见下期，还没整明白。JsonResult代码。

HOOLOO的专栏 959

SpringBoot——Spring Security 框架_spring boot自带的安全框架(1)

还有兄弟不知道网络安全面试可以提前刷题吗？费时一周整理的160+网络安全面试题，金九银十，做网络安全面试里的显眼包！王岚嵚工程师面试题（附答案），只能帮兄弟们到这儿了！如果你能答对70%，找一个安全工作，问题不大。对于有1-3年工作经验，想要跳槽的朋友来说，也是很好的温习资料！【完整版领取方式在文末！！内容实在太多，不一一截图了。

m0_54903333的博客 1437

Spring Security配置

2.LoginSuccessHandler（登录成功处理器）六、创建handler（处理器）与config（配置）层。1.LoginFailHandler（登录失败处理器）1.SecurityApplication（主方法）3.NoLoginHandler（未登录处理器）4.NoAuthHandler（无权限处理器）1.CorsConfig（处理跨域申请）四、配置.xml文件（维护SQL语句）七、配置handler（处理器）层。t_user（用户信息表）t_anth （角色表）八、配置congfig层。

qq_46005551的博客 2680

Spring Boot 安全框架 Spring Security & Shiro

1、 Spring Security 1.1、概述 Spring Security 是一个能够为基于 Spring 的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在 Spring 应用上下文中配置的 Bean ，充分利用了 Spring IoC ， DI （控制反转 Inversion of Control, DI:Dependency Injection 依赖注入）和 AOP （面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码

陌尘吖的博客 629

Spring Security 6.x 系列【1】基础篇之概述及入门案例

是Spring组织提供的一个开源安全框架，目前最新的版本为6.0.2，基于Spring开发，所以非常适合在中使用。提供认证、授权、抵御常见攻击等功能，将认证与授权分离，并提供了扩展点。对保护命令式（Spring MVC）和响应式（）应用程序有一流的支持，是保护基于Spring开发的应用程序的事实标准。认证为身份验证提供了全面的支持，身份验证是验证进行访问的主体身份。常用方法是要求用户输入用户名和密码。一旦执行身份验证，就知道身份并可以执行授权。授权授权指的是验证某个用户是否有权限执行某个操作。

记录知识、锤炼自我 1万+

Spring Security3.1 最新配置实例

这几天学习了一下Spring Security3.1，从官网下载了Spring Security3.1版本进行练习，经过多次尝试才摸清了其中的一些原理。本人不才，希望能帮助大家。还有，这次我第二次写博客啊，文体不是很行。希望能让观看者不产生疲惫的感觉，我已经心满意足了。 一、数据库结构      先来看一下数据库结构，采用的是基于角色-资源-用户的权限管理设计。(MySql数据库)

1547

全面掌握Spring Security 3.1.4安全框架

Spring Security是一个功能强大且高度可定制的身份验证和访问控制框架，它是为Java应用程序提供的安全性解决方案。Spring Security 3.1.4是该框架的一个经典版本，广泛应用于各种Java EE应用程序中。在本章节，我们会对Spring Security进行概述，为接下来深入分析其核心组件奠定基础。Spring Security通过一套完整的安全机制，确保应用程序的数据安全和业务逻辑安全。

weixin_42502040的博客 614

【springboot3.1.5，security配置】

【代码】【springboot3.1.5，security配置】

ZR116118的博客 678

spring security reference 3.1.6 使用指南

spring security reference 3.1.6 使用指南，pdf格式。

Spring Security 3 安全权限管理手册(最新)

Spring Security 3 安全权限管理手册(最新) Spring Security 3 安全权限管理手册(最新)

Spring Security3.1 最新配置实例（spring权限管理）

这几天学习了一下Spring Security3.1，从官网下载了Spring Security3.1版本进行练习，经过多次尝试才摸清了其中的一些原理。本人不才，希望能帮助大家。还有，这次我第二次写博客啊，文体不是很行。希望能让观看者不产生疲惫的感觉，我已经心满意足了。 一、数据库结构 先来看一下数据库结构，采用的是基于角色-资源-用户的权限管理设计。(MySql数据库)     为了节省篇

ilovejava_2010的专栏 1221

灯塔问题：贪心与动态规划算法解析

区间覆盖问题是算法设计中的经典案例，常用于理解贪心算法与动态规划的核心差异。贪心算法通过局部最优选择逐步构建全局解，具有O(n log n)的高效时间复杂度，特别适合处理一维区间覆盖场景。动态规划则采用自底向上的填表法，虽然通用性更强但复杂度较高。在实际工程中，这类算法广泛应用于无线基站部署、监控设备布置等资源优化场景。通过分析灯塔问题的两种解法，可以深入掌握算法选择的关键因素，如问题规模、性能要求和实现复杂度。

weixin_28720573的博客 259

最新Spring Security实战教程（一）初识Spring Security安全框架

随着Web应用和微服务架构的普及，作为JAVA开发者如何保证系统免受各种安全威胁（如未经授权的访问、数据泄露、跨站请求伪造等）成为一个我们必须要解决的问题。作为Spring生态系统中的核心组件，通过提供认证（）与授权（）和针对常见攻击等一系列安全功能，为开发者构建安全稳定的应用提供了强有力的支持。是一个基于Spring认证（Authentication）： 确定访问者身份的过程。Spring Security通过多种方式（如表单登录、Basic认证、OAuth2等）实现用户身份验证。

Micro麦可乐的博客 7459

TLSv1.0与TLSv1.1安全漏洞深度解析与实战修复指南

本文深度解析TLSv1.0与TLSv1.1的安全漏洞，包括POODLE和BEAST攻击原理，并提供实战修复指南。通过禁用老旧协议、配置安全加密套件和网络层防护措施，有效提升系统安全性。文章还针对无法立即升级的场景，给出了补偿性防御方案，帮助管理员全面应对传输层安全风险。

weixin_29322855的博客 206

”COMSOL“竟然如此简单！我悟了！！

COMSOL Multiphysics具有强大的多物理场全耦合仿真分析功能、高效的计算性能，可以保证数值仿真的高度精确，已被广泛应用于各个学科领域，近年来运用COMSOL来解决电化学实际工程问题也越来越普遍。

C1012562281的博客 3447

Spring Security安全框架入门篇

一、Spring Security相关概念1.1.、Spring Security介绍：Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架（简单说是对访问权限进行控制嘛）。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC，DI（控制反转Inversion of Control ,DI:Depend

小宝鸽 1万+

从入门到精通：MediaGo跨平台部署全攻略，Docker+NAS实战案例深度拆解！

本篇将深入解析开源媒体处理工具MediaGo的运作机制，该软件具备跨平台兼容性，支持Windows、MacOS及Linux三大主流操作系统。其核心创新在于采用模块化架构设计，用户无需额外依赖任何插件即可完成快速部署。作为GitHub平台上的开源项目，该工具特别注重用户体验设计，通过Docker容器化方案可无缝接入各类网络存储设备，显著优化系统资源占用并提升数据处理效率。以飞牛云NAS系统为实施案例，本文将详细展示本地化部署全流程。

Yawesh的博客 1954

SpringSecurity 入门 - 什么是安全框架和 Spring Security - 配置 Spring Security - Web 安全配置类 - HttpSecurity

是一个基于Spring框架的安全性框架，可用于对Java应用程序进行身份验证、授权和其他安全性功能的添加。它不仅可以对Web应用程序进行保护，还可以保护非Web环境下的应用程序，如远程服务和命令行应用程序等。提供了一系列可插拔的安全性特性，如基于标记的身份验证、权限控制、单点登录、密码加密等。它还支持多种安全性协议和标准，如OAuthSAMLOpenID等，可与各种身份提供商集成。在文件中配置自定义用户名和密码。spring:security:user:配置完成之后，请重启服务进行测试。是。

qq_73126462的博客 1486

人工智能学习之机器人路径规划优化

A* AStar 人工智能 机器人路径规划优化

RongLin02的博客 7073

企业多部门网络隔离实战：用华为交换机VLAN+Trunk实现行政/技术部安全隔离

本文详细介绍了如何利用华为交换机的VLAN划分与Trunk链路技术，实现企业行政与技术部门间的网络逻辑隔离。通过具体的配置案例，阐述了Access与Trunk端口的工作原理、单交换机与多交换机环境下的部署策略，并延伸至三层网关部署与ACL访问控制，为企业构建安全、高效的核心网络提供实战指导。

p4q5r6s7t的博客 577

spring security 使用教程

Spring Security 是一个功能强大且高度可定制的安全框架，专为基于 Spring 的应用程序设计。它提供了一套全面的安全解决方案，包括身份验证、授权、防止跨站请求伪造等功能。通过利用 Spring 的依赖注入（DI）和面向切面编程（AOP）特性，Spring Security 能够以声明式方式管理安全策略，从而减少开发者的工作量并提高代码的可维护性。Spring Security 是保护 Spring 应用程序的理想选择，它不仅提供了丰富的安全特性，还允许开发者根据具体需求进行定制。

xinshou1_0的博客 1990

chromium通信系统-ipcz系统(二)-ipcz系统代码实现-同Node通信

在chromium通信系统-mojo系统(一)-ipcz系统基本概念一文中我们介绍了ipcz的基本概念。 本章我们来通过代码分析它的实现。 handle系统 为了不对上层api暴露太多细节，实现解耦，也方便于传输，ipcz系统使用handle表示一个对象，handle类似于文件描述符，用IpczHandle类型表示ipcz系统内的一个对象。一个可以用IpczHandle 句柄表示的对象必须是APIObject子类。APIObject数据结构如下 class APIObject : public RefCou

woai110120130的专栏 1775

Spring Security：Java 应用的安全框架

Spring Security 是一个专注于认证和授权的安全框架，它为 Java 应用提供了多种安全功能，尤其适用于 Web 应用。认证：验证用户的身份。授权：控制用户的访问权限。防止跨站请求伪造（CSRF）攻击。防止会话固定攻击。支持 OAuth、JWT 等现代身份验证机制。它支持多种认证方式，包括基于表单的认证、HTTP 基本认证、LDAP、OAuth 2.0 等。你可以通过实现。

一名热衷于技术的全栈开发者，专注于前端与后端的全面技术探索。在这里，我将分享我在技术领域的学习与成长，助力更多开发者的进步。 1219

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

老版QQ原生表情gif动态

这是老版的QQ表情，不过全是动态的的，Windows照片查看器是不会动的，可以右击用浏览器打开查看，再说一遍是老版的，只是分享给宁愿用老版也要动态的人。

Spring Security 3.1配置与使用

1、使用maven 添加Spring Security的jar 包，在pom.xml中加入： org.springframework.security spring-security-core 3.1.3.RELEASE org.springframework.security spring-security-w

yhhazr的专栏 2万+

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android：LinePhone3.2.7(最新版本)，官网地址：http://www.linphone.org/
上一篇： 基本概念
下一篇： 编程之美-电梯问题-java版
点赞 1
评论 0
书签 书签 0
wtsoftware
wtsoftware
博客等级 码龄19年 12粉丝 31原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值