Springboot+Security（一）自定义验证

最新推荐文章于 2024-04-10 10:40:43 发布

any3321

最新推荐文章于 2024-04-10 10:40:43 发布

阅读量1k

点赞数

分类专栏： Springboot运用文章标签： spring spring boot java 数据库

本文链接：https://blog.csdn.net/weixin_43606226/article/details/103608539

版权

Springboot运用专栏收录该内容

19 篇文章 4 订阅

订阅专栏

Springboot+Security（一）自定义验证

使用springboot+springsecurity+mybatis 实现数据库动态的管理：用户-角色-权限

1.数据库表：

在这里插入图片描述

2.验证授权

2.1 实体类

User.Java

User这个实体类需要实现接口UserDetails 其他实体类直接创建

public class User implements UserDetails {
    private int id;
    private String username;
    private String password;
    private String nickname;
    private boolean enabled;
    private List<Role> roles;
    private String email;
    private String userface;
    private Date regtime;
    private List<GrantedAuthority> authorities;

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

    public void setAuthorities(List<GrantedAuthority> authorities) {
        this.authorities = authorities;
    }

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

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

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return enabled;
    }
    //get和set...
 }

2.2 Dao层

PermissionMapper.java

PermissionMapper实现用户所拥有的权限的查询和获取所有权限列表

@Repository
public interface  PermissionMapper {
	//通过用户的ID查找到用户所拥有的权限
    List<Permission> findByUserid(@Param("userId") int userId);
    //获得所有的权限即权限列表
    List<Permission> findAll();
}

在src/resources/sqlmapper下创建对应的mapper.xml文件

PermissionMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.example.springsecurity.dao.PermissionMapper" >
  <resultMap id="BaseResultMap" type="com.example.springsecurity.Pojo.Permission" >
    <id column="id" property="id" jdbcType="INTEGER" />
    <result column="name" property="name" jdbcType="VARCHAR" />
    <result column="descritpion" property="descritpion" jdbcType="VARCHAR" />
    <result column="url" property="url" jdbcType="VARCHAR" />
    <result column="pid" property="pid" jdbcType="INTEGER" />
  </resultMap>
  <select id="findByUserid" resultMap="BaseResultMap">
 select p.*
        from user u
        LEFT JOIN user_role sru on u.id= sru.u_id
        LEFT JOIN role r on sru.r_id=r.id
        LEFT JOIN permission_role spr on spr.r_id=r.id
        LEFT JOIN permission p on p.id =spr.permission_id
          where u.id=#{userId}
  </select>
<select id="findAll" resultMap="BaseResultMap">
  select * from permission
</select>
</mapper>

之后在service层完成对dao层的调用，然后实际使用service层中的类和方法。

2.3 创建自定义的Handler

在这里只创建了两个自定的Handler，一个是登录成功，一个是登录失败。而且这里的Handler是返回的JSON数据。

MyAuthenticationFailHandler.java（登录失败）

//登录失败执行的操作  这里 是返回JSON数据给前端
@Component
public class MyAuthenticationFailHandler extends SimpleUrlAuthenticationFailureHandler {
    @Autowired
    private ObjectMapper objectMapper;
    private Logger logger = LoggerFactory.getLogger(getClass());
    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
                                        AuthenticationException exception) throws IOException, ServletException {
        // TODO Auto-generated method stub
        logger.info("登录失败");
        //以Json格式返回
        Map<String,String> map=new HashMap<>();
        map.put("code", "201");
        map.put("msg", "登录失败");
        response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
        response.setContentType("application/json");
        response.setCharacterEncoding("UTF-8");
        response.getWriter().write(objectMapper.writeValueAsString(map));

    }
}

MyAuthenticationSuccessHandler.java（登陆成功）

//登录成功执行的操作  这里 是返回JSON数据给前端
@Component
public class MyAuthenticationSuccessHandler extends SavedRequestAwareAuthenticationSuccessHandler {
    @Autowired
    private ObjectMapper objectMapper;
    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication)
            throws IOException, ServletException {
        //什么都不做的话，那就直接调用父类的方法
        //super.onAuthenticationSuccess(request, response, authentication);

        //这里可以根据实际情况，来确定是跳转到页面或者json格式。
        //如果是返回json格式，那么这么写
        Map<String,String> map=new HashMap<>();
        map.put("code", "200");
        map.put("msg", "登录成功");
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().write(objectMapper.writeValueAsString(map));
        
        //如果是要跳转到某个页面的   "/index" 表示跳转到index页面
        //new DefaultRedirectStrategy().sendRedirect(request, response, "/index"); 

    }
}

2.4 实现UserDetailsService接口，返回用户数据给自定义AuthenticationProvider来对用户验证授权

实质是AuthenticationManager来验证，AuthenticationManager是一个接口，只有一个authenticate()方法。
这个接口的常见的实现是ProviderManager，而ProviderManger它不自己处理验证，而是委托给所配置的AuthenticationProvider列表来验证。

依次调用列表中的AuthenticationProvider验证，只要有一个AuthenticationProvider验证成功，就不再验证，直接以该验证的成果作为ProviderManager的验证结果

MyUserDetailsService.java（实现UserDetailsService接口）

// 返回用户信息给 AuthenticationProvider 去验证
@Component
public class MyUserDetailsService implements UserDetailsService {
    @Autowired
    private UserService userService;
    @Autowired
    private PermissionService permissionService;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    	//通过用户名找到用户的信息
        User user=userService.selectbyname(username);
        if(user!=null) {
        	//通过用户的ID获得用户所拥有的权限
           List<Permission> permissions= permissionService.findByUserid(user.getId());
           List<GrantedAuthority> grantedAuthorities=new ArrayList<>();
            for (Permission permission : permissions) {
                if (permission != null && permission.getName()!=null) {
                    GrantedAuthority grantedAuthority = new SimpleGrantedAuthority(permission.getName());
                    //将权限信息添加到 GrantedAuthority 对象中，在后面进行全权限验证时会使用GrantedAuthority 对象。
                    grantedAuthorities.add(grantedAuthority);
                }
            }
            //把用户的权限加入用户的信息中
            user.setAuthorities(grantedAuthorities);
            //把用户信息返回给AuthenticationProvider
            return user;
        }
        return null;
    }
}

MyAuthenticationProvider.java（自定义AuthenticationProvider）

在方法中调用UserDetailsService中的loadUserByUsername 获取用户信息然后验证，验证成功就把用户的详细信息放入spring的全局缓存SecurityContextHolder中，以便在后面访问资源时候方便调用用户信息。


//认证授权
// AuthenticationManager 将验证工作交给ProviderManager   而ProviderManager委托所配置的AuthenticationProvider列表 来验证
//验证用户通过后 授予用户权限  把用户信息保存在spring的全局缓存SecurityContextHolder  好让后面访问资源时 能够调用（比如访问资源时候鉴权）
@Component
public class MyAuthenticationProvider implements AuthenticationProvider {
    @Autowired
    private MyUserDetailsService userDetailService;
    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        // TODO Auto-generated method stub
        String userName = authentication.getName();// 这个获取表单输入中返回的用户名;
        String password = (String)authentication.getCredentials();// 这个是表单中输入的密码；
        // 这里构建来判断用户是否存在和密码是否正确
        User userInfo = (User) userDetailService.loadUserByUsername(userName); // 这里调用我们的自己写的获取用户的方法；
        if (userInfo == null) {
            throw new BadCredentialsException("用户名不存在");
        }
        if (!passwordEncoder.matches(password,userInfo.getPassword())) {
            throw new BadCredentialsException("密码不正确");
        }
        Collection<? extends GrantedAuthority> authorities = userInfo.getAuthorities();
        //getAuthorities()是获取权限信息的方法
        // 构建返回的用户登录成功的token
            return new UsernamePasswordAuthenticationToken(userInfo, password, authorities);
    }
    @Override
    public boolean supports(Class<?> aClass) {
        return true;
    }
}

3.完成securityConfig的配置

securityConfig.java

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private AuthenticationProvider provider;  //注入我们自己的AuthenticationProvider
    @Autowired
    private MyAuthenticationSuccessHandler myAuthenticationSuccessHandler;
    @Autowired
    private MyAuthenticationFailHandler myAuthenticationFailHandler;
    @Autowired
    private MyFilterSecurityInterceptor myFilterSecurityInterceptor;

        @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.
                authorizeRequests()
                    .antMatchers("/").hasAnyRole("USER","ADMIN")
                    .antMatchers("/admin/**").hasRole("ADMIN")
                    .anyRequest().authenticated()
                        .and()
                .formLogin()
                    .and()
                    .csrf().disable()
                    .formLogin().loginPage("/login").permitAll()
                    .loginProcessingUrl("/form")
                    .successHandler(myAuthenticationSuccessHandler)
                    .failureHandler(myAuthenticationFailHandler);
        }

    //配置我们自定义的验证授权  让 spring security使用我们自定义的验证器 而不是默认的验证器  也就是MyAuthenticationProvider
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // TODO Auto-generated method stub
        //注册一个自定义的 AuthenticationProvider
        auth.authenticationProvider(provider);
        //再注册一个基于内存的 AuthenticationProvider
//        auth
//        .inMemoryAuthentication()
//            .withUser("admin").password("123456").roles("USER")
//            .and()
//            .withUser("test").password("test123").roles("ADMIN");
    }

//定义了密码的加密方式 这里用了BCrypt加密
    @Bean
   public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

4.创建测试用的控制器和页面

4.1控制器创建

TestController.java

@Controller
public class TestController  {
    @RequestMapping("/")
    public String index(Model model){
        return "index";
    }
    @RequestMapping("/admin")
    @ResponseBody
    public String hello(){
        return "hello admin，拥有admin权限";
    }
    @RequestMapping("/whoim")
    @ResponseBody
    public Object whoIm() {
        return SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    }
}

4.2 创建测试页面

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
</head>
<body>
   <h5>
       访问到了首页
   </h5>
</body>
</html>

login.html

<!DOCTYPE html>
<html id="ng-app" ng-app="app"  xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8"/>
    <title>home</title>
</head>
<body>
<form  class="form-signin" action="/form" method="post">
    <h2 class="form-signin-heading">用户登录</h2>
    <table>
        <tr>
            <td>用户名:</td>
            <td><input type="text" name="username"  class="form-control"  placeholder="请输入用户名"/></td>
        </tr>
        <tr>
            <td>密码:</td>
            <td><input type="password" name="password"  class="form-control" placeholder="请输入密码" /></td>
        </tr>
        <tr>

            <td colspan="2">
                <button type="submit"  class="btn btn-lg btn-primary btn-block" >登录</button>
            </td>
        </tr>
    </table>
</form>
</body>
</html>

5.测试

5.1 先创建测试数据

user表（用户表）自己创建两个用户密码记得要用BCrypt加密也就是在SecurityConfig中的PasswordEncoder Bean来加密密码。这里插入用户最好用mybatis来创建，能够在方法中调用PasswordEncoder Bean实现密码的加密。
在这里插入图片描述
role表（角色表）创建两个角色一个ADMIN,一个USER

user_role表（用户角色关系表）用户ID 1 拥有普通用户角色用户ID 2拥有管理员的角色

role表（权限表）也设置两个权限一个用户权限，一个管理员权限。
在这里插入图片描述
permission_role表（权限角色关系表）管理员角色拥有用户权限和管理员权限，用户角色只拥有管理员权限

5.2 开始测试

直接访问localhost:8080 会跳转到localhost:8080/login 也就是登录页面

在这里插入图片描述
然后先用普通用户登录
登录成功的页面

再访问localhost:8080 就能成功访问到首页了因为是普通用户角色拥有Role_USER权限

访问localhost:8080/whoim 可以看到自己拥有的权限

接着访问localhost:8080/admin会发现报403的错误表示没有访问这个资源的权限
在这里插入图片描述
然后登陆用户2 拥有管理员角色的再访问localhost:8080/admin

访问 localhost:8080/whoim 查看自己拥有的权限

6.认证过程总结

1.用户输入账号密码登录

2.spring security 把获取到的用户的账号密码封装成一个 Authentication 接口的实现类，比如常用的 UsernamePasswordAuthenticationToken。

3.上面产生的 Authentication 的对象传给 AuthenticationManager(接口) 的实现类 ProviderManager 进行认证

4. ProviderManager 依次调用委托列表中的各个 AuthenticationProvider 进行认证，认证成功后返回了一个封装了用户权限信息的 Authentication 对象

5.把 AuthenticationManager(接口) 返回的 Authentication 对象赋予当前的 SecurityContext 即放入 SecurityContextHolder

any3321

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Springboot+Security（一）自定义验证

Springboot+Security验证授权，访问资源鉴权1.数据库表：2.验证授权2.1 实体类User.Java2.2 Dao层PermissionMapper.javaPermissionMapper.xml2.3 实现UserDetailsService接口，返回用户数据给自定义AuthenticationProvider来对用户验证授权MyUserDetailsService（实现Us...
复制链接

扫一扫