Spring和Security整合详解

最新推荐文章于 2024-08-08 23:55:21 发布
最新推荐文章于 2024-08-08 23:55:21 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： Spring之路 文章标签： spring security ajax form 品茗IT
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feiyangtianyao/article/details/86992932
版权

Spring和Security整合详解

一、官方主页

Spring Security

二、概述

Spring 是一个非常流行和成功的 Java 应用开发框架。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方案。一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权（Authorization）两个部分。用户认证指的是验证某个用户是否为系统中的合法主体，也就是说用户能否访问该系统。用户认证一般要求用户提供用户名和密码。系统通过校验用户名和密码来完成认证过程。用户授权指的是验证某个用户是否有权限执行某个操作。在一个系统中，不同用户所具有的权限是不同的。比如对一个文件来说，有的用户只能进行读取，而有的用户可以进行修改。一般来说，系统会为不同的用户分配不同的角色，而每个角色则对应一系列的权限。

Git地址：
Gitee

项目地址：
品茗IT-同步发布

品茗IT 提供在线支持：

一键快速构建Spring项目工具

一键快速构建SpringBoot项目工具

一键快速构建SpringCloud项目工具

一站式Springboot项目生成

如果大家正在寻找一个java的学习环境，或者在开发中遇到困难，可以加入我们的java学习圈，点击即可加入，共同学习，节约学习时间，减少很多在学习中遇到的难题。

三、开始搭建

3.1 依赖Jar包
<?xml version="1.0"?>
<project
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
	xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>cn.pomit</groupId>
		<artifactId>SpringWork</artifactId>
		<version>0.0.1-SNAPSHOT</version>
	</parent>
	<artifactId>Security</artifactId>
	<packaging>jar</packaging>
	<name>Security</name>
	<url>http://maven.apache.org</url>
	<dependencies>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>4.0.0</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-core</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-config</artifactId>
		</dependency>
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
		</dependency>
		<dependency>
			<groupId>cn.pomit</groupId>
			<artifactId>Mybatis</artifactId>
			<version>${project.version}</version>
		</dependency>
	</dependencies>
	<build>
		<finalName>Security</finalName>
	</build>
</project>

父pom管理了所有依赖jar包的版本，地址：
https://www.pomit.cn/spring/SpringWork/pom.xml

3.2 web.xml配置Security

Spring整合Security需要配置Security的安全控制策略，首先需要在web.xml中配置Spring Security的filter。

在web.xml中加入这几行即可：

<!-- 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>
3.3 Security的安全配置

Spring整合Security需要配置Security的安全控制策略，这里先以form登录控制为例，后面文章会讲token系列《Spring和Token整合详解》。

FormSecurityConfig依赖于其他组件，后面会一一列出：

package cn.pomit.springwork.security.config;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationDetailsSource;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.web.authentication.WebAuthenticationDetails;

import cn.pomit.springwork.security.ajax.AjaxAuthFailHandler;
import cn.pomit.springwork.security.ajax.AjaxAuthSuccessHandler;
import cn.pomit.springwork.security.ajax.AjaxLogoutSuccessHandler;
import cn.pomit.springwork.security.ajax.UnauthorizedEntryPoint;
import cn.pomit.springwork.security.service.SimpleAuthenticationProvider;

@EnableWebSecurity
public class FormSecurityConfig {

	@Configuration                                                   
	public static class FormLoginWebSecurityConfigurerAdapter extends WebSecurityConfigurerAdapter {
		@Autowired
		private SimpleAuthenticationProvider simpleAuthenticationProvider;
		
		@Autowired
		@Qualifier("formAuthenticationDetailsSource")
		private AuthenticationDetailsSource<HttpServletRequest, WebAuthenticationDetails> authenticationDetailsSource;
		
		@Autowired
		public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
			auth.authenticationProvider(simpleAuthenticationProvider);
		}

		@Override
		public void configure(HttpSecurity http) throws Exception {
			http.csrf().disable().exceptionHandling()
					.authenticationEntryPoint(new UnauthorizedEntryPoint())
					.and().headers()
					.frameOptions().disable().and().authorizeRequests()
					.antMatchers("/favicon.ico").permitAll()
					.antMatchers("/login").permitAll()
					.antMatchers("/login.html").permitAll()
					.antMatchers("/css/**").permitAll()
					.antMatchers("/pub/**").permitAll()
					.antMatchers("/user/**").hasAnyRole("USER","ADMIN")
					.anyRequest().authenticated()
					.and()
					.formLogin()
				  	.usernameParameter("userName").passwordParameter("userPwd")
				  	.authenticationDetailsSource(authenticationDetailsSource)
					.loginProcessingUrl("/login")
					.successHandler(new AjaxAuthSuccessHandler())
					.failureHandler(new AjaxAuthFailHandler())
					.and()
					.logout()
					.logoutUrl("/logout").logoutSuccessHandler(new AjaxLogoutSuccessHandler());
		}
	}
}

这里面：

  • SimpleAuthenticationProvider 是对安全认证的处理逻辑。校验用户名密码的

  • AuthenticationDetailsSource，其实是不必要的，但是用它我们可以获取除了用户名密码以外的信息，比如验证码之类的。

  • AjaxAuthSuccessHandler 认证成功处理器。

  • AjaxAuthFailHandler 认证失败处理器。

  • AjaxLogoutSuccessHandler 登出处理器。

  • UnauthorizedEntryPoint 未授权处理器。

3.4 Security的校验逻辑

SimpleAuthenticationProvider对form登录校验做了简单的控制：

package cn.pomit.springwork.security.service;

import java.util.Collection;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import cn.pomit.springwork.mybatis.domain.UserInfo;
import cn.pomit.springwork.mybatis.service.UserInfoService;
import cn.pomit.springwork.security.detail.FormAddUserDetails;

@Component
public class SimpleAuthenticationProvider implements AuthenticationProvider {
	@Autowired
	private UserInfoService userInfoService;

	@Override
	public Authentication authenticate(Authentication authentication) throws AuthenticationException {
		// 验证码等校验
		FormAddUserDetails details = (FormAddUserDetails) authentication.getDetails();

		System.out.println(details.getToken() + "+++++++++++++++++" + details.getSessionToken());
		if (StringUtils.isEmpty(details.getSessionToken()) || StringUtils.isEmpty(details.getToken())
				|| !details.getToken().equalsIgnoreCase(details.getSessionToken())) {
			throw new BadCredentialsException("验证码错误。");

		}

		String userName = authentication.getPrincipal().toString();
		UserInfo user = userInfoService.getUserInfoByUserName(userName);

		if (user == null) {
			throw new BadCredentialsException("查无此用户");
		}
		if (user.getPasswd() != null && user.getPasswd().equals(authentication.getCredentials())) {
			Collection<? extends GrantedAuthority> authorities = AuthorityUtils.NO_AUTHORITIES;

			return new UsernamePasswordAuthenticationToken(user.getUserName(), user.getPasswd(), authorities);
		} else {
			throw new BadCredentialsException("用户名或密码错误。");
		}
	}

	@Override
	public boolean supports(Class<?> arg0) {
		return true;
	}

}

这里用到了UserInfoService ，它是个查询数据库的一个service，UserInfoService是依赖包Mybatis项目中定义的一个数据库访问的service,这里就不写了，可以在快速构建Spring项目工具中查看Mybatis组合组件的代码。

很多博文写到Spring的一个接口：UserDetailsService。
这里我们要讲一下：

  • SimpleAuthenticationProvider控制了校验，需要数据库配合查询用户名密码，和前台传过来的用户名密码做对比，因此，需要一个获取用户信息的service。

  • UserDetailsService是spring定义的接口，用来获取用户信息的。

  • UserDetailsService只有在不使用AuthenticationProvider的情况下需要，因为AuthenticationProvider是自定义处理过程，比如我们的SimpleAuthenticationProvider，自己都实现了处理逻辑，还要UserDetailsService个屁啊！

3.5 额外安全信息处理

FormAuthenticationDetailsSource负责将request对象拿到并交给WebAuthenticationDetails，WebAuthenticationDetails是Authentication的一部分，这样我们在AuthenticationProvider的实现类中就能通过authentication.getDetails()拿到额外信息。

FormAuthenticationDetailsSource：

package cn.pomit.springwork.security.service;

import javax.servlet.http.HttpServletRequest;

import org.springframework.security.authentication.AuthenticationDetailsSource;
import org.springframework.security.web.authentication.WebAuthenticationDetails;
import org.springframework.stereotype.Component;

import cn.pomit.springwork.security.detail.FormAddUserDetails;

@Component("formAuthenticationDetailsSource")
public class FormAuthenticationDetailsSource implements AuthenticationDetailsSource<HttpServletRequest, WebAuthenticationDetails> {

    @Override
    public WebAuthenticationDetails buildDetails(HttpServletRequest context) {
        return new FormAddUserDetails(context);
    }


}

FormAddUserDetails：

package cn.pomit.springwork.security.detail;

import javax.servlet.http.HttpServletRequest;

import org.springframework.security.web.authentication.WebAuthenticationDetails;


public class FormAddUserDetails extends WebAuthenticationDetails{
	 /**
     * 
     */
    private static final long serialVersionUID = 6975601077710753878L;
    private final String token;
    private final String sessionToken;
    private final Boolean isAjax;
    public FormAddUserDetails(HttpServletRequest request) {
        super(request);
        isAjax = isAjaxRequest(request);
        token = request.getParameter("imgtoken");
        sessionToken = (String) request.getSession().getAttribute("imgtoken");
    }

    public String getToken() {
        return token;
    }

    public String getSessionToken() {
		return sessionToken;
	}

	public Boolean getIsAjax() {
		return isAjax;
	}

	@Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(super.toString()).append("; Token: ").append(this.getToken());
        return sb.toString();
    }
	
	public static boolean isAjaxRequest(HttpServletRequest request) {
        String ajaxFlag = request.getHeader("X-Requested-With");
        return ajaxFlag != null && "XMLHttpRequest".equals(ajaxFlag);
    }

}

FormAddUserDetails 需要拿到session中存在的验证码，然后把传过来的验证码都保存下来。

3.6 安全控制处理器

FormSecurityConfig中我们配置了很多处理器，有UnauthorizedEntryPoint、AjaxAuthFailHandler、AjaxAuthSuccessHandler、AjaxLogoutSuccessHandler。
顾名思义，这些是分别处理未授权、校验失败、校验成功、登出操作的，我们这里区分下ajax请求和跳转请求。

UnauthorizedEntryPoint：

package cn.pomit.springwork.security.ajax;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;

public class UnauthorizedEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        if(isAjaxRequest(request)){
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED,authException.getMessage());
        }else{
            response.sendRedirect("/login.html");
        }

    }

    public static boolean isAjaxRequest(HttpServletRequest request) {
        String ajaxFlag = request.getHeader("X-Requested-With");
        return ajaxFlag != null && "XMLHttpRequest".equals(ajaxFlag);
    }
}

AjaxAuthFailHandler：

package cn.pomit.springwork.security.ajax;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler;

public class AjaxAuthFailHandler extends SimpleUrlAuthenticationFailureHandler {
    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
        if(isAjaxRequest(request)){
        	response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Authentication failed");
        }else{
        	setDefaultFailureUrl("/login.html");
        	super.onAuthenticationFailure(request, response, exception);
        }
    }
    
    public static boolean isAjaxRequest(HttpServletRequest request) {
        String ajaxFlag = request.getHeader("X-Requested-With");
        return ajaxFlag != null && "XMLHttpRequest".equals(ajaxFlag);
    }
}

AjaxAuthSuccessHandler：

package cn.pomit.springwork.security.ajax;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler;

import com.fasterxml.jackson.databind.ObjectMapper;

import cn.pomit.springwork.security.ResultModel;

public class AjaxAuthSuccessHandler extends SavedRequestAwareAuthenticationSuccessHandler {
	protected final Log logger = LogFactory.getLog(this.getClass());
	
    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
    	request.getSession().setAttribute("userName", authentication.getName());
    	if(isAjaxRequest(request)){
    		ResultModel rm = new ResultModel("ok");
    		ObjectMapper mapper = new ObjectMapper();
    		response.setStatus(HttpStatus.OK.value());
    		response.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE);
    		mapper.writeValue(response.getWriter(), rm);
    	}else{
    		super.onAuthenticationSuccess(request, response, authentication);
        }
    }
    
    public static boolean isAjaxRequest(HttpServletRequest request) {
        String ajaxFlag = request.getHeader("X-Requested-With");
        return ajaxFlag != null && "XMLHttpRequest".equals(ajaxFlag);
    }
}

AjaxLogoutSuccessHandler：

package cn.pomit.springwork.security.ajax;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.logout.SimpleUrlLogoutSuccessHandler;

public class AjaxLogoutSuccessHandler extends SimpleUrlLogoutSuccessHandler{
	public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response,
			Authentication authentication) throws IOException, ServletException {
		if(isAjaxRequest(request)){
    		response.setStatus(HttpServletResponse.SC_OK);
    	}else{
    		super.onLogoutSuccess(request, response, authentication);
        }
	}
	
	public static boolean isAjaxRequest(HttpServletRequest request) {
        String ajaxFlag = request.getHeader("X-Requested-With");
        return ajaxFlag != null && "XMLHttpRequest".equals(ajaxFlag);
    }
}

详细完整及测试代码，可以在《品茗IT-Spring和Security整合详解》中查看，也可以在Spring组件化构建中选择并下载。

快速构建项目

Spring组件化构建
喜欢这篇文章么，喜欢就加入我们一起讨论Spring技术吧！
品茗IT交流群

逍遥天扬
关注
专栏目录
Spring Security-全面详解（学习总结---从入门到深化）
12-01 1946
虽然Spring Security给我们提供了登录页面，但在实际项目中，更 多的是使用自己的登录页面。Spring Security也支持用户自定义登 录页面。用法如下：1、编写登录页面2、在Spring Security配置类自定义登录页面//Spring Security配置@Override// 自定义表单登录.loginPage("/login.html") //自定义登录页面.usernameParameter("username")// 表单中的用户名项。
spring security详解
wumingdu1234的博客
07-15 7029
1.概要 Spring是非常流行和成功的Java应用开发框架，SpringSecurity正是Spring家族中的成员。SpringSecurity基于Spring框架，提供了一套Web应用安全性的完整解决方案。正如你可能知道的关于安全方面的两个主要区域是“认证”和“授权”（或者访问控制），一般来说，Web应用的安全性包括用户认证（Authentication）和用户授权（Authorization）两个部分，这两点也是SpringSecurity重要核心功能。 （1）用户认证指的是：验证某个用户是否为系统
Spring整合SpringSecurity
qq_43676797的博客
07-07 668
自定义登录页面只需要在security配置文件中指定登录页面即可--指定登录页面或登录成功页面等，都在这个标签中可以指定--> < form-login login-page = " /login.jsp " login-processing-url = " /login " authentication-success-forward-url = " /home.jsp " />
SpringSecurity（看这一篇就够了）
最新发布
m0_74436895的博客
08-08 2566
Spring Security是Spring项目组提供的安全服务框架，核心功能包括认证和授权。它为系统提供了声明式安全访问控制功能，减少了为系统安全而编写大量重复代码的工作。认证认证即系统判断用户的身份是否合法，合法可继续访问，不合法则拒绝访问。常见的用户身份认证方式有：用户名密码登录、二维码登录、手机短信登录、脸部识别认证、指纹认证等方式。认证是为了保护系统的隐私数据与资源，用户的身份合法才能访问该系统的资源。授权授权即认证通过后。
springsecurity整合
weixin_44295084的博客
08-21 776
写在前面：仅用于记录自己的学习 SpringSecuritySpringSecurity众筹整合SpringSecurity授权配置-初始简单配置授权配置-首页登录页面静态资源授权配置-登录注销配置csrf防跨站点攻击认证配置-主体创建 SpringSecurity SpringSecurity融合了Spring技术栈，提供javaEE应用的整体安全解决方案，提供全面的安全服务。 目前市面上受欢迎的两个安全框架：Apacho Shiro（市场逐渐减小）, SpringSecurity 用户提交登录请求的时候
手把手带你入门 Spring Security！
weixin_30578677的博客
07-25 603
Spring Security 是 Spring 家族中的一个安全管理框架，实际上，在 Spring Boot 出现之前，Spring Security 就已经发展了多年了，但是使用的并不多，安全管理这个领域，一直是 Shiro 的天下。 相对于 Shiro，在 SSM/SSH 中整合 Spring Security 都是比较麻烦的操作，所以，Spring Security 虽然功能比...
Spring整合SpringSecurity(一)
输入技术、输出想法
07-22 1670
SpringBoot整合SpringSecurity（一）创建项目pomcontrller 创建项目 pom <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <depen
Spring Security详解
jzhf2012的专栏
01-04 1817
简介 Spring Security是一个能够为基于Spring的企业应用系统提供描述性安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC（依赖注入，也称控制反转）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码的工作。 Spring Security 的前身是
详解SpringBoot+SpringSecurity+jwt整合及初体验
08-25
SpringBoot+SpringSecurity+jwt整合详解 SpringBoot是当前最流行的Java框架之一，它提供了便捷的方式来构建基于Web的应用程序。然而，在构建Web应用程序时，安全性是不可忽视的重要方面。因此，本文将详细介绍如何...
Spring Security整合Oauth2实现流程详解
09-07
通过以上步骤，我们可以实现Spring Security与OAuth2的整合，为应用程序提供安全的用户认证和授权功能。理解这些概念和流程对于开发涉及用户身份验证和授权的应用至关重要。希望这篇文章能帮助你更好地理解和应用...
SpringSecurity详解
m0_71012114的博客
10-19 5042
本文详解介绍了security原理、多种方式配置登录、角色和权限访问控制、常用注解、用户注销。
Spring Security OAuth2认证授权示例详解
08-25
Spring Security OAuth2是一个强大的安全框架，它为Web应用程序提供了安全认证和授权的功能。OAuth2则是一种开放标准，允许用户授权第三方应用访问他们存储在另一服务提供商的数据，而无需分享他们的用户名和密码。...
整合Spring Security
Leon_Jinhai_Sun的博客
01-22 519
很多人不懂spring security，觉得这个框架比shiro要难，的确，security更加复杂一点，同时功能也更加强大，我们首先来看一下security的原理 上面这张图一定要好好看，特别清晰，毕竟security是责任链的设计模式，是一堆过滤器链的组合，如果对于这个流程都不清楚，那么你就谈不上理解security。那么针对我们现在的这个系统，我们可以自己设计一个security的认证方案 流程说明： 客户端发起一个请求，进入 Security 过滤器链。 当到 LogoutFilt
Spring Security介绍
W211953332的博客
08-13 459
一、Spring Security介绍 1、框架介绍 Spring 是一个非常流行和成功的 Java 应用开发框架。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方案。一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权（Authorization）两个部分。 （1）用户认证指的是：验证某个用户是否为系统中的合法主体，也就是说用户能否访问该系统。用户认证一般要求用户提供用户名和密码。系统通过校验用户名和密码来完成认证过程。
spring security详解教程
11-28 1065
先来谈一谈Acegi的基础知识，Acegi的架构比较复杂，但是我希望我下面的只言片语能够把它说清楚。大家都知道，如果要对Web资源进行保护，最好的办法莫过于Filter，要想对方法调用进行保护，最好的办法莫过于AOP。Acegi对Web资源的保护，就是靠Filter实现的。如下图：  一般来说，我们的Filter都是配置在web.xml中，但是Acegi不一样，它在web.xml中配置的只是
Spring Security 四种使用方式
热门推荐
张普的专栏
06-29 1万+
spring security使用分类： 如何使用spring security，相信百度过的都知道，总共有四种用法，从简到深为：1、不用数据库，全部数据写在配置文件，这个也是官方文档里面的demo；2、使用数据库，根据spring security默认实现代码设计数据库，也就是说数据库已经固定了，这种方法不灵活，而且那个数据库设计得很简陋，实用性差；3、spring security和Aceg
spring整合springSecurity
yh_zeng2的博客
06-15 573
转载自：spring整合springSecurity
【安全】整合spring security
...
06-30 147
spring security是针对spring项目的安全框架，也是spring boot底层安全模块默认的技术选型。它可以实现强大的web安全控制。对于安全控制，我们仅需引入spring-boot-starter-security模块，进行少量配置，即可实现强大的安全管理。 应用程序的两个主要区域是认证和授权。这两个主要区域是spring security的两个目标。 认证（Authentication），建立一个它声明主体的过程。 授权（Authorization）指确定一个主体是否允许在你的应用程序
OAuth2.0与SpringSecurity整合详解
"SpringSecurity_day04.pdf" Spring Security是一个强大的且高度可定制的身份验证和访问控制框架，用于保护Java应用程序。在本资料中，我们关注的是Spring Security与OAuth2.0的集成，OAuth2.0是一种广泛采用的授权...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值