spring security的简单使用

最新推荐文章于 2024-07-27 17:13:32 发布
最新推荐文章于 2024-07-27 17:13:32 发布
阅读量1.7k 收藏 1
点赞数
分类专栏： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ang_dd/article/details/12680463
版权

       做权限管理的时候学习了security的使用，包括官方的使用配置示例，学习新东西的时候最好参照官方的使用文档，英文的也好，纵使英文不好，慢慢阅读，养成好习惯，自己的英文水平也会慢慢提高，搞开发英文水平也是很重要的。

     首先引入security所需的包，工程使用maven构建,控制某个用户是否有对资源的访问权限

<!--security-->
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-core</artifactId>
            <version>3.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-web</artifactId>
            <version>3.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-config</artifactId>
            <version>3.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-cas</artifactId>
            <version>3.1.3.RELEASE</version>
        </dependency>

在web.xml中配置过滤器，引入security的配置文件，配置过滤器时注意名字springSecurityFilterChain

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:/spring/applicationContext.xml,classpath:/spring/application-security.xml</param-value>
</context-param>
<!-- 权限 -->
<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>

在applicationContext-security.xml使用命名空间配置 

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/security"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:beans="http://www.springframework.org/schema/beans"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
	http://www.springframework.org/schema/security 
	http://www.springframework.org/schema/security/spring-security-3.2.xsd">
<intercept-url pattern="/login.jsp" filters="none"/>//默认login.jsp不拦截
<form-login login-page="/login.jsp" authentication-failure-url="/403.jsp" default-target-url="/index.jsp"/>//自定义登录界面
<http-basic/>
<logout logout-success-url="/login.jsp"/>
<http pattern="/js/**" security="none"/>
<http pattern="/css/**" security="none"></http>
<http pattern="/login.jsp" security="none"/>
<http use-expressions="true" entry-point-ref="authenticationProcessingFilterEntryPoint">
<logout/>
<remember-me />
        <session-management invalid-session-url="/timeout.jsp">
            <concurrency-control max-sessions="30" error-if-maximum-exceeded="true" />
        </session-management>
<custom-filter ref="loginFilter" position="FORM_LOGIN_FILTER"  />
<custom-filter ref="myFilter" before="FILTER_SECURITY_INTERCEPTOR"/><!-- 自定义filter在默认过滤器之前 -->
</http>
<beans:bean id="loginFilter"
		class="com.amplesky.security.MyUsernamePasswordAuthenticationFilter">
		<!-- 处理登录 -->
		<beans:property name="filterProcessesUrl" value="/j_spring_security_check"></beans:property>
		<beans:property name="authenticationSuccessHandler" ref="loginLogAuthenticationSuccessHandler"></beans:property>
		<beans:property name="authenticationFailureHandler" ref="simpleUrlAuthenticationFailureHandler"></beans:property>
		<beans:property name="authenticationManager" ref="myAuthenticationManager"></beans:property>
</beans:bean>
<beans:bean id="loginLogAuthenticationSuccessHandler"
		class="org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler">
		<beans:property name="defaultTargetUrl" value="/index.jsp"></beans:property>
</beans:bean>
<beans:bean id="simpleUrlAuthenticationFailureHandler"
		class="org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler">
		<beans:property name="defaultFailureUrl" value="/login.jsp"></beans:property>
</beans:bean>

 <!-- 用户自定义filter必须包含三个属性 -->
<beans:bean id="myFilter" class="com.amplesky.security.MySecurityFilter">
 <!-- 用户拥有的权限 -->
 <beans:property name="authenticationManager" ref="myAuthenticationManager"/>
 <!-- 用户是否用户访问资源的权限-->
 <beans:property name="accessDecisionManager" ref="myAccessDecisionManager"/>
  <!-- 资源与权限的关系-->
 <beans:property name="securityMedataSource" ref="mySecurityMetadataSource"/>
</beans:bean>
<!-- 认证管理器，实现UsersDetailsService接口 -->
<authentication-manager alias="myAuthenticationManager">
  <authentication-provider user-service-ref="myUserDetailServiceImpl"/>
</authentication-manager>					 
<!-- 访问决策层，决定某个用户具有的角色，是否有足够角色访问某个资源 -->
<beans:bean id="myAccessDecisionManager" class="com.amplesky.security.MyAccessDecisionManager">
</beans:bean>
<!-- 资源数据定义，定义某一资源能被那些角色访问 -->
<beans:bean id="mySecurityMetadataSource" class="com.amplesky.security.MySecurityMetadataSource" init-method="loadResourceDefine">
</beans:bean>
<!-- service -->
<beans:bean id="myUserDetailServiceImpl" class="com.amplesky.security.MyUserDetailServiceImpl">
</beans:bean>
<!-- 未登录的切入点 -->
<beans:bean id="authenticationProcessingFilterEntryPoint" class="org.springframework.security.web.authentication.LoginUrlAuthenticationEntryPoint">
<beans:property name="loginFormUrl" value="/login.jsp"></beans:property>
</beans:bean>
</beans:beans>
定义三个对象，五张表

User.java   Role.java   Resource.java

T_User表

用于存放用户信息，此处只存放基础信息


T_Role表

用于存放系统角色信息

T_User_Role表

用于存放系统用户与角色的匹配关系


T_Resource表

用于存放资源表

T_Role_Resource表

存放角色对应的资源表


 登录页面form提交的路径

 <form action="j_spring_security_check" method="post">

登录处理的filter
public class MyUsernamePasswordAuthenticationFilter extends UsernamePasswordAuthenticationFilter{
	public static final String VALIDATE_CODE = "validateCode";
	public static final String USERNAME = "username";
	public static final String PASSWORD = "password";
	@Resource
	private LoginDao loginDao;
	@Override
	public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
		if (!request.getMethod().equals("POST")) {
			throw new AuthenticationServiceException("Authentication method not supported: " + request.getMethod());
		}		
		String username = request.getParameter("username");
		String password = request.getParameter("password");
		
		//验证用户账号与密码是否对应
		username = username.trim();	
		Users users = this.loginDao.findByName(username);	
		if(users == null || !users.getPassword().equals(password)) {
	/* 
		if (forwardToDestination) {
            request.setAttribute(WebAttributes.AUTHENTICATION_EXCEPTION, exception);
        } else {
            HttpSession session = request.getSession(false);

            if (session != null || allowSessionCreation) {
                request.getSession().setAttribute(WebAttributes.AUTHENTICATION_EXCEPTION, exception);
            }
        }
	 */
			throw new AuthenticationServiceException("password or username is notEquals"); 
		}
		
		//UsernamePasswordAuthenticationToken实现 Authentication
		UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(username, password);
		// Place the last username attempted into HttpSession for views
		
		// 允许子类设置详细属性
        setDetails(request, authRequest);
		
        // 运行UserDetailsService的loadUserByUsername 再次封装Authentication
		return this.getAuthenticationManager().authenticate(authRequest);
	}
	
	}
MyUserDetailServiceIMpl.java 

public class MyUserDetailServiceImpl implements UserDetailsService{
   @Resource
   private LoginDao loginDao;
	@Override
	public UserDetails loadUserByUsername(String usersname) {
		// TODO Auto-generated method stub
		System.out.println("Usersname is:"+usersname);
		Users Users=this.loginDao.findByName(usersname);
		Collection<GrantedAuthority> grantedAuths=obtionGrantedAuthorities(this.loginDao.findByName(usersname));
		boolean enables = true;  
       		boolean accountNonExpired = true;  
     		boolean credentialsNonExpired = true;  
      		boolean accountNonLocked = true;  
       		User Usersdetail=new User(Users.getLoginId(),Users.getPassword(),enables, accountNonExpired, credentialsNonExpired, accountNonLocked, grantedAuths);
		return Usersdetail;
	}
	//取得用户权限
	public Set<GrantedAuthority> obtionGrantedAuthorities(Users user){
		  Set<GrantedAuthority> authSet = new HashSet<GrantedAuthority>();  
		         Set<Role> roles = loginDao.findRoleByUsers(user); //根据用户取得用户的角色 	           
		         for(Role role : roles) {  
		            	 authSet.add(new GrantedAuthorityImpl(role.getRoleName()));  
		            }      
		
		        return authSet;  
		     }  
	}
MySecurityMetadaSource.java //加载所有的资源和权限关系
public class MySecurityMetadataSource implements FilterInvocationSecurityMetadataSource{
    @Resource(name="resourceDao")
    private ResourceDao resourceDao;
    public void setResourceDao(ResourceDao resourceDao){
    	this.resourceDao=resourceDao;
    }
	private static Map<String,Collection<ConfigAttribute>> resourceMap=null;
   //加载所有的资源和权限关系
	public  void loadResourceDefine(){
    	if(resourceMap==null){
    		resourceMap=new HashMap<String,Collection<ConfigAttribute>>();
    		List<Resource> list=resourceDao.getResourceAll();
    		for(Resource functionTree:list){
    			Collection<ConfigAttribute> configAttributes=new ArrayList<ConfigAttribute>();
    			List<Role> roles=resourceDao.getRoleByFunc(functionTree);//根据资源得到需要的角色
    			for(Role role:roles){
    				ConfigAttribute configAttribute=new SecurityConfig(role.getRoleName());
    				configAttributes.add(configAttribute);
    			}
    			resourceMap.put(functionTree.getUrl(), configAttributes);			
    		}
    	}  	
    	  Set<Map.Entry<String, Collection<ConfigAttribute>>> resourceSet = resourceMap.entrySet();  
    	  Iterator<Map.Entry<String, Collection<ConfigAttribute>>> iterator = resourceSet.iterator(); 
    }
	@Override
	public Collection<ConfigAttribute> getAllConfigAttributes() {
		// TODO Auto-generated method stub
		return null;
	}
//返回请求资源所需的权限
	@Override
	public Collection<ConfigAttribute> getAttributes(Object object)
			throws IllegalArgumentException {
		// TODO Auto-generated method stub
		String requestUrl=((FilterInvocation)object).getRequestUrl();
		System.out.println("request url is"+requestUrl);
		if(resourceMap==null){
			loadResourceDefine();
		}
		return resourceMap.get(requestUrl);
	}

	@Override
	public boolean supports(Class<?> arg0) {
		// TODO Auto-generated method stub
		return true;
	}
	public static Map<String,Collection<ConfigAttribute>> getResourceMap() {
		return resourceMap;
	}
	public static void setResourceMap(Map<String,Collection<ConfigAttribute>> resourceMap) {
		MySecurityMetadataSource.resourceMap = resourceMap;
	}

}
MyAccessDecisionManager.java  //访问决策层，决定某个用户具有的角色，是否有足够角色访问某个资源 

public class MyAccessDecisionManager implements AccessDecisionManager{

	@Override
	public void decide(Authentication authentication, Object object,
			Collection<ConfigAttribute> configAttribute) throws AccessDeniedException,
			InsufficientAuthenticationException {
		// TODO Auto-generated method stub
			if(configAttribute==null){
				return;
			}
			Iterator<ConfigAttribute> iterator=configAttribute.iterator();
			while(iterator.hasNext()){
				ConfigAttribute configAttr=iterator.next();
				String needPermission=configAttr.getAttribute();
				System.out.println(needPermission+">>>>>>");
				for(GrantedAuthority ga:authentication.getAuthorities()){
					if(needPermission.equals(ga.getAuthority())){//判断需要的角色名是否和用户的角色名相同，否则没有权限
						return;
					}
				}
			}
	        throw new AccessDeniedException(" 没有权限访问！ ");  
			
	}

	@Override
	public boolean supports(ConfigAttribute arg0) {
		// TODO Auto-generated method stub
		return true;
	}

	@Override
	public boolean supports(Class<?> arg0) {
		// TODO Auto-generated method stub
		return true;
	}	
}

MySecurityFilter.java //用户自定义filter 

public class MySecurityFilter extends AbstractSecurityInterceptor implements Filter{
	
	private FilterInvocationSecurityMetadataSource securityMedataSource;
	public void setSecurityMedataSource(
			FilterInvocationSecurityMetadataSource securityMedataSource) {
		this.securityMedataSource = securityMedataSource;
	}

	@Override
	public Class<? extends Object> getSecureObjectClass() {
		// TODO Auto-generated method stub
		return FilterInvocation.class;
	}

	@Override
	public SecurityMetadataSource obtainSecurityMetadataSource() {
		// TODO Auto-generated method stub
		return this.securityMedataSource;
	}
	private void invoke(FilterInvocation fi){
		InterceptorStatusToken token=super.beforeInvocation(fi);
		try{
			fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			super.afterInvocation(token, null);
		}	
	}
	@Override
	public void destroy() {
		// TODO Auto-generated method stub
		
	}
	@Override
	public void doFilter(ServletRequest request, ServletResponse response,
			FilterChain chain) throws IOException, ServletException {
		// TODO Auto-generated method stub
		FilterInvocation fi=new FilterInvocation(request,response,chain);
		invoke(fi);
	}

	@Override
	public void init(FilterConfig arg0) throws ServletException {
		// TODO Auto-generated method stub
		
	}	

}
  至此，简单的权限控制完成了，判断用户是否对某个资源具有访问权限，否则提示没有权限访问。





        


 

Ang_DD
关注
专栏目录
spring security原理和机制 | Spring Boot 35
学Java，找哪吒
06-25 5万+
一、SpringSecurity 框架简介 Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的 成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方 案。 正如你可能知道的关于安全方面的两个主要区域是“认证”和“授权”（或者访问控 制），一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权 （Authorization）两个部分，这两点也是 Spring
SpringSecurity详解
m0_71012114的博客
10-19 5081
本文详解介绍了security原理、多种方式配置登录、角色和权限访问控制、常用注解、用户注销。
狂神说SpringBoot18：集成SpringSecurity
热门推荐
狂神说
03-29 1万+
狂神说SpringBoot系列连载课程，通俗易懂，基于SpringBoot2.2.5版本，欢迎各位狂粉转发关注学习。未经作者授权，禁止转载SpringSecurity安全简介在 Web ...
Spring Security
qq_53432338的博客
06-20 2131
1、简介 2、入门 3、内存配置 4、角色控制 5、连接数据库 6、动态权限pring Security是一个功能强大、可高度定制的身份验证和访问控制框架。它是保护基于Spring的应用程序的事实标准。Spring Security是一个面向Java应用程序提供身份验证和安全性的框架。与所有Spring项目一样，Spring Security的真正威力在于它可以轻松地扩展以满足定制需求。springsecurity底层实现为一条过滤器链，就是用户请求进来，判断有没有请求的权限，抛出异常，重定向跳转。1、导入
SpringSecurity
weixin_45450412的博客
02-01 397
Spring Security 一、 Spring Security 简介 1 概括 Spring Security 是一个高度自定义的 安全框架。利用 Spring IoC/DI和 AOP 功能，为系统提供了声明式安全访问控制功能，减少了为系统安全而编写大量重复代码的工作。 使用 Spring Secruity 的原因有很多，但大部分都是发现了 javaEE的 Servlet 规范或 EJB 规范中的安全功能缺乏典型企业应用场景。同时认识到他们在 WAR 或 EAR 级别无法移植。因此如果你更换服务器环
spring security
weixin_43060721的博客
01-07 674
spring security工作原理简介 spring security和springmvc配合使用可以提供安全性，可以通过注册org.springframework.web.filter.DelegatingFilterProxy这个filter进行安全管理，也可以扩展AbstractSecurityWebApplicationInitializer类进行java方式的配置，AbstractS...
SpringSecurity(安全)
weixin_45723046的博客
04-19 1264
SpringSecurity(安全) 官网： https://docs.spring.io/spring-security/reference/index.html SpringSecurity(安全) 一、简介 Spring Security 是针对Spring项目的安全框架，也是Spring Boot底层安全模块默认的技术选型，他可以实现强大的Web安全控制，对于安全控制，我们仅需要引入spring-boot-starter-security模块，进行少量的配置，即可实现强大的安全管理! 记住几.
Spring Security如何使用URL地址进行权限控制
08-25
Spring Security如何使用URL地址进行权限控制 Spring Security是一个功能强大且广泛应用的Java安全框架，它提供了许多功能，包括身份验证、授权、加密等。其中，权限控制是Spring Security的一个重要组件，它允许...
springsecurity使用demo
03-03
在本示例中，我们将探讨如何使用 SpringSecurity 构建一个基本的认证和授权流程。 首先，Spring Security 的核心组件包括认证（Authentication）和授权（Authorization）。认证涉及识别用户身份，而授权则是确定...
spring security 官方文档
10-08
10. **与其他Spring框架的集成**：Spring Security与Spring Boot、Spring MVC、Spring Data等其他Spring组件无缝集成，使得构建安全应用变得更加简单。 在Spring Security的官方文档中，包含了详细的配置指南、API...
grpc-spring-security-demo：基于Spring Boot的gRPC服务器，具有受Spring Security保护的gRPC端点
01-31
该项目演示了如何使用Spring Security的基于方法的安全性机制来保护gRPC服务。 这是一个用Java编写并基于Spring Boot构建的gRPC服务器。 它使用gRPC拦截器与Spring Security集成，并支持两种身份验证机制：...
权限控制与安全认证 Spring Security
张锦的博客
06-11 923
仅为个人学习使用。
Security初步使用
Wulawuba的博客
04-03 2927
1.添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> 2.启动时会提供一个默认密码 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SH8php0b-1648975626290)(C
Springboot使用SpringSecurity
丝凉意的博客
04-10 115
springsecurity的简单实用 加入Spring Security pom.xml导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> 加入spring security安全配置 @EnableWebSecuri
spring security 入门
码农的世界你们不懂
11-28 850
1.spring security基本原理 SpringSecurity 最核心的东西----过滤器链，即一组Filter 所有发送的请求都会经过Filter链，同样响应也会经过Filter链，在系统启动的时候springboot会自动的把他们配置进去； 2. 自定义用户认证逻辑 通过UserDetailsService处理用户信息获取的逻辑；通过UserDetails处理用户校验逻辑；通过Pa...
Spring Security 详解
阿水的博客
03-28 1412
Spring Security 是 Spring家族中的一个安全管理框架。相比与另外一个安全框架Shiro，它提供了更丰富的功能，社区资源也比Shiro丰富。
关于SpringBoot整合Security认证授权的使用和介绍；
最新发布
gzx233的博客
07-27 788
整合Security的旧版和新版的区别和使用,密码加密器,自定义账号密码,多用户,修改登录页,获取当前用户信息等..
springsecurity简单使用
09-12
以下是一个简单的示例，演示了如何在 Spring Security 中进行基本配置和使用。 首先，在 pom.xml 文件中添加 Spring Security 的依赖： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值