SpringSecurity（01）——快速入门

已于 2024-09-08 21:04:20 修改
阅读量584 收藏 7
点赞数 9
分类专栏： SpringSecurity 文章标签： spring java
于 2024-01-13 00:57:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/peng_gx/article/details/135564416
版权

简单配置

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
    <version>2.3.12.RELEASE</version>
</dependency>

@Controller
public class UserController {

    @GetMapping("/test")
    @ResponseBody
    public String test(){
        return "hello";
    }
}

注意：导入依赖之后，访问localhost:8080请求地址会自动跳转到/login中，出现一个表单，用户名为user，密码在控制台出现

将表单请求转换为弹出框请求

/**
 * 定制用户认证管理器来实现用户认证
 *  1. 提供用户认证所需信息（用户名、密码、当前用户的资源权）
 *  2. 可采用内存存储方式，也可能采用数据库方式
 */
void configure(AuthenticationManagerBuilder auth);

/**
 * 定制基于 HTTP 请求的用户访问控制
 *  1. 配置拦截的哪一些资源
 *  2. 配置资源所对应的角色权限
 *  3. 定义认证方式：HttpBasic、HttpForm
 *  4. 定制登录页面、登录请求地址、错误处理方式
 *  5. 自定义 Spring Security 过滤器等
 */
void configure(HttpSecurity http);

/**
 * 定制一些全局性的安全配置，例如：不拦截静态资源的访问
 */
void configure(WebSecurity web);

@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        /**
         * fromLogin()：表单认证
         * httpBasic()：弹出框认证
         * authorizeRequests()：身份认证请求
         * anyRequest()：所有请求
         * authenticated()：身份认证
         */
        http.httpBasic()
                .and()
                .authorizeRequests()
                // 其它任何请求访问都需要先通过认证
                .anyRequest()
                .authenticated();
    }
}

访问地址，例如：localhost:8080/hello

自定义用户信息

配置文件自定义用户名和密码

spring:
  security:
    user:
      name: root    #通过配置文件，设置静态用户名
      password: root    #配置文件，设置静态登录密码

基于内存存储认证信息

  1. 在 Spring Security 5.0 版本前，加密的 PasswordEncoder 接口默认实现类为 NoOpPasswordEncoder ，这个是可以不用加密的，直接使用明文密码存储。当前已经标注过时了。
  2. 在 Spring Security 5.0 版本后 ，默认实现类改为了 DelegatingPasswordEncoder ，这个实现类要求我们必须对加密后存储。
@Configuration
@Slf4j
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    /**
     * 密码编码器，密码不能明文存储
     */
    @Bean
    public PasswordEncoder passwordEncoder() {
        // 设置默认的加密方式，使用 BCryptPasswordEncoder 密码编码器，
        // 该编码器会将随机产生的 salt 混入最终生成的密文中
        return new BCryptPasswordEncoder();
    }
    
    /**
     * 定制基于 HTTP 请求的用户访问控制
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        /**
         * fromLogin()：表单认证
         * httpBasic()：弹出框认证
         * authorizeRequests()：身份认证请求
         * anyRequest()：所有请求
         * authenticated()：身份认证
         */
        http.httpBasic()
                .and()
                .authorizeRequests()
                // 其它任何请求访问都需要先通过认证
                .anyRequest()
                .authenticated();
    }

    /**
    * 认证管理器：
    * 1、认证信息提供方式（用户名、密码、当前用户的资源权限）
    * 2、可采用内存存储方式，也可能采用数据库方式等
    */
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 用户信息存储在内存中
        String password = passwordEncoder().encode("1234");
        logger.info("加密之后存储的密码：" + password);
        auth.inMemoryAuthentication()
            .withUser("admin")
            .password(password)
            .authorities("ADMIN");
    }
    
    /**
     * 定制一些全局性的安全配置，例如：不拦截静态资源的访问
     */
    @Override
    public void configure(WebSecurity web) throws Exception {
        // 静态资源的访问不需要拦截，直接放行
        web.ignoring().antMatchers("/**/*.css", "/**/*.js", "/**/*.png", "/**/*.jpg", "/**/*.jpeg");
    }
}

UserDetailsService自定义登录请求

在实际开发中，Spring Security应该动态的从数据库中获取信息进行自定义身份认证，采用数据库方式进行身份认证一般需要实现两个核心接口 UserDetailsService 和 UserDetails

UserDetailService接口

该接口只有一个方法 loadUserByUsername()，用于定义从数据库中获取指定用户信息的逻辑。如果未获取到用户信息，则需要手动抛出 UsernameNotFoundException 异常；如果获取到用户信息，则将该用户信息封装到 UserDetails 接口的实现类中并返回

public interface UserDetailsService {
    // 输入参数 username 是前端传入的用户名
    UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;
}

UserDetails接口

UserDetails接口定义了用于描述用户信息的方法

public interface UserDetails extends Serializable {
    // 返回用户权限集合
    Collection<? extends GrantedAuthority> getAuthorities();

    // 返回用户的密码
    String getPassword();

    // 返回用户的用户名
    String getUsername();

    // 账户是否未过期（true 未过期, false 过期）
    boolean isAccountNonExpired();

    // 账户是否未锁定（true 未锁定, false 锁定）
    // 用户账户可能会被封锁，达到一定要求可恢复
    boolean isAccountNonLocked();

    // 密码是否未过期（true 未过期, false 过期）
    // 一些安全级别高的系统，可能要求 30 天更换一次密码
    boolean isCredentialsNonExpired();

    // 账户是否可用（true 可用, false 不可用）
    // 系统一般不会真正的删除用户信息，而是假删除，通过一个状态码标志用户是否被删除
    boolean isEnabled();
}

用户登录逻辑处理

@Slf4j
@Component
public class UserDetailServiceImpl implements UserDetailsService {

    /**
     * Spring Security接收login请求调用UserDetailService这个接口中的loadUserByUsername
     * loadUserByUsername根据传进来的用户名进行校验工作，
	 * 最后将查询到的用户信息封装到UserDetails这个接口的实现类中
     */
    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
        log.info("登录用户名：{}",s);
        //根据用户名查询用户数据
        return new User(s,"123456", AuthorityUtils.commaSeparatedStringToAuthorityList("admin"));
    }
}

在使用了Spring Security-5.x版本，需要手动提供一个PasswordEncoder实现类，进行密码校验，PasswordEncoder是SpringSecurity的密码解析器，用户密码校验、加密，自定义登录逻辑时要求必须给容器注入PasswordEncoder的bean对象

@Component
public class PasswordEncoderImpl implements PasswordEncoder {

    @Override
    public String encode(CharSequence charSequence) {
        return charSequence.toString();
    }

    @Override
    public boolean matches(CharSequence charSequence, String s) {
        return s.equals(charSequence.toString());
    }
}

@Configuration
@Slf4j
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

	@Resource
    private PasswordEncoder passwordEncoder;
	@Resource
    private UserDetailsService userDetailsService;
    
    /**
     * 定制基于 HTTP 请求的用户访问控制
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        /**
         * fromLogin()：表单认证
         * httpBasic()：弹出框认证
         * authorizeRequests()：身份认证请求
         * anyRequest()：所有请求
         * authenticated()：身份认证
         */
        http.httpBasic()
                .and()
                .authorizeRequests()
            	// 其它任何请求访问都需要先通过认证
                .anyRequest()
                .authenticated();
    }

    /**
    * 认证管理器：
    * 1、认证信息提供方式（用户名、密码、当前用户的资源权限）
    * 2、可采用内存存储方式，也可能采用数据库方式等
    */
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 不再使用内存方式存储用户认证信息，而是动态从数据库中获取
        auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder);
    }
    
    /**
     * 定制一些全局性的安全配置，例如：不拦截静态资源的访问
     */
    @Override
    public void configure(WebSecurity web) throws Exception {
        // 静态资源的访问不需要拦截，直接放行
        web.ignoring().antMatchers("/**/*.css", "/**/*.js", "/**/*.png", "/**/*.jpg", "/**/*.jpeg");
    }
}

注意

上面自定义的密码解析器密码加密后与原来的一致，如果使用其他的密码解析器密码加密后与原来的不一致时，采用以下方式：

/**
 * 密码编码器，密码不能明文存储
 */
@Bean
public BCryptPasswordEncoder passwordEncoder() {
    // 使用 BCryptPasswordEncoder 密码编码器，该编码器会将随机产生的 salt 混入最终生成的密文中
    return new BCryptPasswordEncoder();
}


@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth.userDetailsService(userDetailService).passwordEncoder(passwordEncoder());
}

@Slf4j
@Component
public class UserDetailServiceImpl implements UserDetailsService {

    @Resource
    private PasswordEncoder passwordEncoder;

    /**
     * Spring Security接收login请求调用UserDetailService这个接口中的loadUserByUsername
     * loadUserByUsername根据传进来的用户名进行校验工作，
	 * 最后将查询到的用户信息封装到UserDetails这个接口的实现类中
     */
    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
        log.info("登录用户名：{}",s);
        //根据用户名查询用户数据
        return new User(s, passwordEncoder.encode("123456"), AuthorityUtils.commaSeparatedStringToAuthorityList("admin"));
    }
}

自定义返回UserDetails信息

public class AccountUser implements UserDetails {

    private Long userId;

    private static final long serialVersionUID = 540L;
    private static final Log logger = LogFactory.getLog(User.class);
    private String password;
    private final String username;
    private final Collection<? extends GrantedAuthority> authorities;
    private final boolean accountNonExpired;
    private final boolean accountNonLocked;
    private final boolean credentialsNonExpired;
    private final boolean enabled;

    public AccountUser(Long userId, String username, String password, Collection<? extends GrantedAuthority> authorities) {
        this(userId, username, password, true, true, true, true, authorities);
    }

    public AccountUser(Long userId, String username, String password, boolean enabled, boolean accountNonExpired, boolean credentialsNonExpired, boolean accountNonLocked, Collection<? extends GrantedAuthority> authorities) {
        Assert.isTrue(username != null && !"".equals(username) && password != null, "Cannot pass null or empty values to constructor");
        this.userId = userId;
        this.username = username;
        this.password = password;
        this.enabled = enabled;
        this.accountNonExpired = accountNonExpired;
        this.credentialsNonExpired = credentialsNonExpired;
        this.accountNonLocked = accountNonLocked;
        this.authorities = authorities;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return this.authorities;
    }

    @Override
    public String getPassword() {
        return this.password;
    }

    @Override
    public String getUsername() {
        return this.username;
    }

    @Override
    public boolean isAccountNonExpired() {
        return this.accountNonExpired;
    }

    @Override
    public boolean isAccountNonLocked() {
        return this.accountNonLocked;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return this.credentialsNonExpired;
    }

    @Override
    public boolean isEnabled() {
        return this.enabled;
    }
}

@Component
public class UserDetailServiceImpl implements UserDetailsService {

    @Resource
    private PasswordEncoder passwordEncoder;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        if ("admin".equals(username)) {
            return new AccountUser(12L, "admin", passwordEncoder.encode("123"), AuthorityUtils.NO_AUTHORITIES);
        }
        return null;
    }
}

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Resource
    private UserDetailServiceImpl userDetailService;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.formLogin()
                .and()
                .authorizeRequests()
                .anyRequest()
                .authenticated();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailService);
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

PasswordEncoder（密码解析器）

工作流程

public interface PasswordEncoder {
    //加密
    String encode(CharSequence var1);
	//比较密码
    boolean matches(CharSequence var1, String var2);
	
    default boolean upgradeEncoding(String encodedPassword) {
        return false;
    }
}

DaoAuthenticationProvider在additionalAuthenticationChecks方法中会获取Spring容器中的PasswordEncoder来对用户输入的密码进行比较

BCryptPasswordEncoder密码匹配流程

/**
* 参数一：原密码，参数二：加密后保存在数据库的密码
*/
public boolean matches(CharSequence rawPassword, String encodedPassword) {
    if (encodedPassword == null || encodedPassword.length() == 0) {
        logger.warn("Empty encoded password");
        return false;
    }
 
    if (!BCRYPT_PATTERN.matcher(encodedPassword).matches()) {
        logger.warn("Encoded password does not look like BCrypt");
        return false;
    }
 
    return BCrypt.checkpw(rawPassword.toString(), encodedPassword);
}

从数据库得到的“密码”（参数： salt ）进行一系列校验（长度校验等）并截取“密码”中相应的密码盐，利用这个密码盐进行同样的一系列计算 Hash 操作和 Base64 编码拼接一些标识符生成所谓的“密码”，最后 equalsNoEarlyReturn 方法对同一个密码盐生成的两个“密码”进行匹配

  1. 每次使用 BCryptPasswordEncoder 编码同一个密码都是不一样的，因为用到的随机密码盐每次都是不一样的，同一个密码和不同的密码盐组合计算出来的 Hash 值肯定不一样
  2. BCryptPasswordEncoder 编码同一个密码后结果都不一样，怎么进行匹配？因为密码盐是随机生成的，但是可以根据数据库查询出来的“密码”拿到密码盐，同一个密码盐+原密码计算 Hash 结果值是能匹配的

自定义密码解析器

/**
 * 凭证匹配器，用于做认证流程的凭证校验使用的类型
 * 其中有2个核心方法
 * 1. encode - 把明文密码，加密成密文密码
 * 2. matches - 校验明文和密文是否匹配
 * */
public class MyMD5PasswordEncoder implements PasswordEncoder {

    /**
     * 加密
     * @param charSequence  明文字符串
     */
    @Override
    public String encode(CharSequence charSequence) {
        try {
            MessageDigest digest = MessageDigest.getInstance("MD5");
            return toHexString(digest.digest(charSequence.toString().getBytes()));
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            return "";
        }
    }

    /**
     * 密码校验
     * @param charSequence 明文，页面收集密码
     * @param s 密文 ，数据库中存放密码
     */
    @Override
    public boolean matches(CharSequence charSequence, String s) {
        return s.equals(encode(charSequence));
    }

    /**
     * @param tmp 转16进制字节数组
     * @return 饭回16进制字符串
     */
    private String toHexString(byte [] tmp){
        StringBuilder builder = new StringBuilder();
        for (byte b :tmp){
            String s = Integer.toHexString(b & 0xFF);
            if (s.length()==1){
                builder.append("0");
            }
            builder.append(s);
        }
        return builder.toString();
    }
}

@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Bean
    public PasswordEncoder passwordEncoder(){
        //return new BCryptPasswordEncoder(); //自带的
        return new MyMD5PasswordEncoder();
    }
}

@Slf4j
@Component
public class UserDetailServiceImpl implements UserDetailsService {

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
        String password = passwordEncoder.encode("123");
        log.info("登录用户：{}，密码：{}", s, password);
        return new User(s, password, AuthorityUtils.commaSeparatedStringToAuthorityList("admin"));
    }
}

路径匹配器

PathMatcher

匹配规则

  1. /a：仅匹配路径/a
  2. /a/*：操作符会替换一个路径名。在这种情况下，它将匹配/a/b或/a/c，而不是/a/b/c
  3. /a/**：操作符会替换多个路径名。在这种情况下，/a以及/a/b和/a/b/c都是这个表达式的匹配项
  4. /a/{param}：这个表达式适用于具有给定路径参数的路径/a
  5. /a/{param:regex}：只有当参数的值与给定正则表达式匹配时，此表达式才应用于具有给定路径参数的路径/a

使用案例

  1. 单个请求无请求方法匹配
http.authorizeRequests() 
    .mvcMatchers("/hello_user").hasRole("USER") 
    .mvcMatchers("/hello_admin").hasRole("ADMIN");

如果使用角色为“USER”的用户来访问“/hello_admin”端点，那么会出现禁止访问的情况，因为“/hello_admin”端点只有角色为“ADMIN”的用户才能访问

注意：没有被 MVC 匹配器所匹配的端点，其访问不受任何的限制，效果相当于如下所示的配置

http.authorizeRequests() 
    .mvcMatchers("/hello_user").hasRole("USER") 
    .mvcMatchers("/hello_admin").hasRole("ADMIN");
    .anyRequest().permitAll();
  1. 单个请求有请求方法匹配

如果一个 Controller 中存在两个路径完全一样的 HTTP 端点，可以把 HTTP 方法作为一个访问的维度进行控制

http.authorizeRequests() 
    .mvcMatchers(HttpMethod.POST, "/hello").authenticated() 
    .mvcMatchers(HttpMethod.GET, "/hello").permitAll() 
    .anyRequest().denyAll();
  1. 多个路径匹配
.mvcMatchers("/test/xiao","/test/giao","/test/a","/test/a/b").hasRole("ADMIN")
//可以简化为以下方式
.mvcMatchers("/test/**").hasRole("ADMIN")
  1. 带有路径变量匹配
@GetMapping("/product/{code}")
public String productCode(@PathVariable String code){
    return code;
}

.mvcMatchers("/product/{code:^[0-9]*$}").permitAll()

此时调用端点，假设code=1234a，不符合全部都是数字，报401；然后再次调用端点，code=12345，发现调用通过

AntPathMatcher

Ant 匹配器的表现形式和使用方法与前面介绍的 MVC 匹配器非常相似

使用方法：

  1. antMatchers(String patterns)
  2. antMatchers(HttpMethod method)
  3. antMatchers(HttpMethod method, String patterns)

mvc与ant匹配器的区别

  1. antMatchers(“/secured”)仅仅匹配 /secured
  2. mvcMatchers(“/secured”)匹配 /secured 之余还匹配 /secured/，/secured.html，/secured.xyz

因此 mvcMatcher 更加通用且容错性更高

正则表达式

使用方法：

  1. regexMatchers(HttpMethod method, String regex)
  2. regexMatchers(String regex)

使用这一匹配器的主要优势在于它能够基于复杂的正则表达式对请求地址进行匹配，这是 MVC 匹配器和 Ant 匹配器无法实现的

//只有输入的请求是一个合法的邮箱地址才能允许访问
.regexMatchers("/email/{email:.*(.+@.+\\.com)}")
Spring Security 6.x 系列（1）—— 初识Spring Security
gmHappy
10-05 2万+
`Spring Security`作为一个功能完善的安全框架，具有以下特性： - **认证（Authentication）**：解决 "你是谁" 的问题，验证系统中是否有这个“用户”(用户/设备/系统)，也就是我们常说的“登录”。 - **授权（Authorization）**：权限控制/鉴别，解决的是系统中某个用户能够访问哪些资源，即“你能干什么”的问题。`Spring Security` 支持基于 `URL` 的请求授权、方法访问授权、对象访问授权。
SpringSecurity入门Demo实例
10-15
按照教程https://blog.youkuaiyun.com/ryo1060732496/article/details/78848205 编写的demo程序
Spring Security(1)快速入门
愤怒的菜鸟博客
02-23 298
基本介绍 Spring Security 的前身是 Acegi Security，在被收纳为Spring子项目后正式更名为Spring Security。 是一个比较常用的权限框架，主要的功能是认证和授权。同时对oauth2 也有很好的支持; 认证：认证是否是本系统的用户 授权：判断已经认证了的用户是否有某个操作的权限 官网文档: https://docs.spring.io/spring-security/reference/servlet/getting-started.html 中文文档: https
springboot3整合SpringSecurity实现登录校验与权限认证（万字超详细讲解）
最新发布
m0_74825409的博客
02-28 1469
用户提交登录请求Spring Security 将请求交给 UsernamePasswordAuthenticationFilter 过滤器处理。UsernamePasswordAuthenticationFilter 获取请求中的用户名和密码，并生成一个 AuthenticationToken 对象，将其交给 AuthenticationManager 进行认证。
spring security快速入门 （无多余额外功能）
目标架构师
08-04 298
spring security快速入门 （无多余额外功能） 学不会你来打死我
Spring Security快速入门（一）
蜗牛君
07-24 145
 Spring Security官方文档 一. 简介   Spring Security是一个功能强大且高度可定制的身份验证和访问控制框架，致力于为Java应用程序提供身份验证和授权。 认证 （你是谁） 授权 （你的权限大小） 攻击防护 （防止身份伪造和网络攻击）   Spring Security采用的是责任链的设计模式，它有一条很长的过滤器链，项目启动后将会自动配置。最核心的是 Basic Authentication Filter 来认证用户的身份。 二. Spring Security入门 快
springsecurity快速入门
qq_45541846的博客
07-19 278
springsecurity快速入门
SpringSecurity系列——用户名密码登录day3-1（源于官网5.7.2版本）
qq_51553982的博客
07-20 1144
源于官方最新5.7.2文档，若你觉得官方文档阅读起来很枯燥，内容复杂，我提供了解析概括在每个部分的结尾，我对官方文档的内容做了一些改变，实例代码我会在后续进行更新，请查看如SpringSecurity系列——认证架构实例代码的文章但是如果你有能力，还是推荐直接阅读官方文档//...}...
SpringSecurity实战入门——认证
GSON的博客
06-19 464
是 Spring 家族中的一个安全管理框架。相比与另外一个安全框架，它提供了更丰富的功能，社区资源也比Shiro丰富。一般来说中大型的项目都是使用来做安全框架。小项目有Shiro的比较多，因为相比与SpringSecurity，Shiro的上手更加的简单。一般Web应用的需要进行和。而认证和授权也是SpringSecurity作为安全框架的核心功能。
SpringSecurity系列——简单配置上手day4-3（源于官网5.7.2版本）
qq_51553982的博客
07-23 1111
本片开启SpringSecurity入门上手实例，基于官方5.7.2的最新稳定版，springboot2.7.2版，jdk17，我对官方实例进行了一定程度上的修改，增加了其他一些实例代码。
Spring Security 3系列文章——入门篇(一)
04-02
**Spring Security 3 系列文章——入门篇(一)** Spring Security 是一个强大的和高度可定制的身份验证和访问控制框架，广泛应用于Java企业级应用和Spring Boot项目中。本篇将作为Spring Security 3的入门介绍，帮助...
Spring Security 快速入门(1)
qq_56769991的博客
02-10 2526
文章目录一.背景：1.授权与认证的理解：二.入门案例1.spring依赖导入：2.创建index.html3.配置web.xml (整合spring security、加载spring配置文件)4.创建spring-security配置文件（配置认证、授权等关系） 一.背景： 在一个项目中，我们有很多功能，例如增删改查等基本功能，还有很多额外的扩展功能。在生产环境下我们如果不登录后台系统就可以完成这些功能操作吗？案显然是否定的，要操作这些功能必须首先登录到系统才可以。：是不是所有用户，只要登录成功就都
Spring Security的快速入门
qq_43299794的博客
10-16 223
Spring Security的快速入门欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导...
Spring Security --- 快速入门
汤键的博客
04-11 677
Spring Security --- 快速入门
品优购第四天
编程之心的博客
11-22 573
品优购 第4天 学习目标 目标1：实现SpringSecurity入门小Demo 目标2：完成运营商登陆与安全控制功能 目标3：完成商家入驻 目标4：完成商家审核 目标5：完成商家系统登陆与安全控制功能 目标6：完成商家异步登录 第1章 Spring Security框架入门 1.1 Spring Security简介 Spring Security是一个能够为基于Spring的企业应用系统提供声...
SpringSecurity快速入门
xiaoyixiao_的博客
05-07 462
目录springsecurity基本使用springsecurity基本原理 springsecurity基本使用 引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> 编写controller @RestC
Spring Security快速入门
susjj663的博客
07-23 1154
当设置完自定义的登录页面之后，可以解决两个问题，第一个是访问速度会更快，第二个，自定义的登录页也更美观，下面我们可以自定义页面来设置为登录页将当天资料目录中的登录页面拷贝到我们的项目中的resource 目录下的 static目录。
Spring Security教程：简化配置与快速入门指南
本文件集合提供了一个关于Spring Security的快速入门教程，重点介绍了如何通过命名空间配置方式简化Spring Security的配置过程。教程中可能包括了如何配置过滤器，即安全过滤器链，这是Spring Security安全体系中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值