五、整合redis+restful接前后端分离进行登录验证和url鉴权

使用jwt token来认证和鉴权

<!--jwt配置文件-->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.0</version>
</dependency>
(jwt也可,只需要将userDto的信息使用jwt来保存即可返回时,返回jwt的字符串,我这是将用户信息保存在了redis中)

1、配置security文件


/**
 * SpringSecurity的配置
 * Created by wenye on 2021/4/12.
 */
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled=true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private RestfulAccessDeniedHandler restfulAccessDeniedHandler;
    @Autowired
    private RestAuthenticationEntryPoint restAuthenticationEntryPoint;
    // 上面是登录认证相关  下面为url权限相关 - ========================================================================================

    /**
     * 获取访问url所需要的角色信息
     */
    @Autowired
    private  UrlFilterInvocationSecurityMetadataSource urlFilterInvocationSecurityMetadataSource;
    /**
     * 认证权限处理 - 将上面所获得角色权限与当前登录用户的角色做对比,如果包含其中一个角色即可正常访问
     */
    @Autowired
    private  UrlAccessDecisionManager urlAccessDecisionManager;
    /**
     * 自定义访问无权限接口时403响应内容
     */
    @Autowired
    private  UrlAccessDeniedHandler urlAccessDeniedHandler;
    
    @Autowired
    private MyuserDetailsService userDetailsService;

    //请求权限配置
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                .antMatchers("/login/user/employee/login", "/login/user/employee/register")// 对登录注册要允许匿名访问
                .permitAll()
                .antMatchers(HttpMethod.OPTIONS)//跨域请求会先进行一次options请求
                .permitAll()
                .authenticated();
        ExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry registry = http.authorizeRequests();
        registry.withObjectPostProcessor(new ObjectPostProcessor<FilterSecurityInterceptor>() {
                                             @Override
                                             public <O extends FilterSecurityInterceptor> O postProcess(O o) {
                                                 o.setSecurityMetadataSource(urlFilterInvocationSecurityMetadataSource);
                                                 o.setAccessDecisionManager(urlAccessDecisionManager);
                                                 return o;
                                             }
                                         });
        // 添加JWT filter
        http.addFilterBefore(jwtAuthenticationTokenFilter(), UsernamePasswordAuthenticationFilter.class);
        //添加自定义未授权和未登录结果返回
        http.exceptionHandling()
                .accessDeniedHandler(restfulAccessDeniedHandler)
                .authenticationEntryPoint(restAuthenticationEntryPoint);
    }

    @Bean
    public JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter() {
        return new JwtAuthenticationTokenFilter();
    }

/*  可以不要哦
    @Override
    public void configure(WebSecurity web) throws Exception {
        // 设置拦截忽略文件夹,可以对静态资源放行
        web.ignoring().antMatchers("/css/**", "/js/**");
    }*/
}

2、usercontroller

@RestController
@RequestMapping("/login/user")
@Api(tags = "用户体系")
public class SysUserController {
    @Autowired
    private ITbSysEmployeeService tbSysEmployeeService;
    
    @Autowired
    private RedisToolCache redisToolCache;
    
    @Autowired
    private RedisTemplate redisTemplate;
    /**
     * 员工登录
     * @param dto
     * @return
     */
    @RequestMapping("/employee/login")
    public RespMessage employeelogin(@RequestBody LoginDto dto){
        //数据校验@Valid
        RespMessage respMessage = tbSysEmployeeService.employeelogin(dto, TokenChannelEnum.WEB.getValue());
        try {
            beanLife();
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (ObjectUtils.isEmpty(respMessage)){
            return RespHandler.failure("账户名密码错误");
        }
        return respMessage;
    }
}

3、UserDot 存储中转用户信息

@Data
public class UserDto implements Serializable {
    private String phone;
    private String userId;
    private String passwd;
    private String validCode;
    private String module;//登陆的模块
    private String userName;//登录用户名
    private Long rentId;//租户ID(指定租户ID登录)
    private String appType;//应用类型:1Android,2IOS,
    private String newPasswd;
    private Integer channel;
    private String token;
    private List<String> roles;
    private String avatar;
}

4、userserviceImpl

@Service
public class TbSysEmployeeServiceImpl extends ServiceImpl<TbSysEmployeeDao, TbSysEmployeeEntity> implements ITbSysEmployeeService {
    @Autowired
    private TbSysEmployeeDao tbSysEmployeeDao;
    
    @Autowired
    private TokenManager tokenManager;
    @Override
    public RespMessage  employeelogin(LoginDto dto, int channel) {
        if (ObjectUtils.isEmpty(dto)) {
            return null;
        }
        TbSysEmployeeEntity employee1 = tbSysEmployeeDao.employeeOne(dto.getUserName());
        if (ObjectUtils.isEmpty(employee1)) {
            return null;
        }
        //校验密码
        String pwd = "";
        try {
            pwd = EncryptionUtil.SHA1(EncryptionUtil.SHA1(dto.getPassword()+employee1.getSalt()));
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (! pwd.equals( employee1.getPassword())) {
            return null;
        }
    //生成token、存储日志
        UserDto userDto = new UserDto();
        userDto.setUserId(employee1.getId());
        userDto.setModule(String.valueOf(channel));
        userDto.setUserName(employee1.getNickName());
        userDto.setPhone(employee1.getPhone());
        List<Integer> list = CommonUtils.intToIntegerList(employee1.getRole());
        List<String> roles = new ArrayList<>();
        for (Integer i : list) {
            if (i == 1) {
                roles.add("admin");
            }else {
                roles.add("");
            }
        }
        userDto.setRoles(roles);
        userDto.setAvatar(employee1.getAvatar());
        //生成token
        String token = tokenManager.createToken(userDto);
        TbSysLoginLogEntity entity = new TbSysLoginLogEntity();
        entity.setUserName(employee1.getName());
        entity.setPhone(employee1.getPhone());
        entity.setOperateType(1);
        entity.setDeviceType(1);
        tbSysLoginLogService.save(entity);
        userDto.setToken(token);
        return RespHandler.success(userDto);
    }
}

5、tokenmanger
就是reids的创建,获取,校验,返回1个32位的UUID字符串就行

6、ITbSysEmployeeService 员工信息查询

public class TbSysEmployeeImpl extends ServiceImpl<TbSysEmployeeDao, TbSysEmployeeEntity> implements ITbSysEmployeeService {

    @Autowired
    private TbSysEmployeeDao tbSysEmployeeDao;

    @Override
    public TbSysEmployeeEntity selectByUsername(String username) {


        TbSysEmployeeEntity entity = null;
        try {
            entity = tbSysEmployeeDao.employeeOne(username);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return entity;
    }
}

对应的sql 只要获取用户名称,密码,权限列表就ok了,这里nick_name为用户名,

SELECT
se.id,
se.name,
se.phone,
se.card,
se.password,
se.status,
se.nick_name,
se.code,
se.address,
se.create_name,
se.create_time,
se.update_time,
se.salt,
se.avatar,
sr.ROLETYPE_ID role
FROM tb_sys_employee se
left join tb_sys_user_role sur on sur.USER_ID = se.id
left join tb_sys_role sr on sr.id = sur.role_id
WHERE  1 = 1
<if test="userName != null and userName != ''">
    and se.nick_name = #{userName}
</if>

7、JwtAuthenticationTokenFilter token过滤器
我这只是通过token去redis中查询用户信息,如果用jwt可直接解析字符串中用户信息

public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {

    @Autowired
    private MyuserDetailsService userDetailsService;

    @Autowired
    private TokenManager tokenManager;

    @Autowired
    private JwtTokenUtil jwtTokenUtil;
//    @Value("${jwt.tokenHeader}")
    private String tokenHeader = "Authorization";
//    @Value("${jwt.tokenHead}")
    private String tokenHead = "Bearer";

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain chain) throws ServletException, IOException {
        //获取token
        String authHeader = request.getHeader(this.tokenHeader);
        //解析token
        if (authHeader != null && tokenManager.checkToken(authHeader)) {
            //解析token获取用户名称
            UserDto userDto = (UserDto) tokenManager.getToken(authHeader);
            String userName = userDto.getUserName();
            Authentication authentication1 = SecurityContextHolder.getContext().getAuthentication();
            if (userName != null && SecurityContextHolder.getContext().getAuthentication() == null) {
                //返回security用户授权对象
                UserDetails userDetails = this.userDetailsService.loadUserByUsername(userName);
                //判断token是否失效
                if (tokenManager.checkToken(authHeader)) {
                    UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                    //资源 的来源存储
                    authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                    //Authentication 对象加入到上下文中等待ProviderManager 去去处理验收信息
                    SecurityContextHolder.getContext().setAuthentication(authentication);
                }
            }
        }
        //转发给过滤器链上下一个对象。这里的下一个指的是下一个filter,
        chain.doFilter(request, response);
    }
}

8、通过用户名称获取用户信息和权限

/**
 * @author :wenye
 * @date :Created in 2021/4/7 11:49
 * @description:校验身份
 * @version: 1.0.0$
 */
@Component
public class MyuserDetailsService implements UserDetailsService {

    private Logger logger = LoggerFactory.getLogger(MyuserDetailsService.class);

    @Autowired
    private ITbSysEmployeeService tbSysEmployeeService;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

        TbSysEmployeeEntity entity = tbSysEmployeeService.selectByUsername(username);
        //校验密码
        if (ObjectUtils.isEmpty(entity)) {
            throw new BadCredentialsException("请输入正确用户名");

        }
        //生成token、存储日志
        UserDto userDto = new UserDto();
        userDto.setUserId(entity.getId());
        userDto.setUserName(entity.getNickName());
        userDto.setPhone(entity.getPhone());
        userDto.setPasswd(entity.getPassword());
        //注意这里要改造,骚操作需要更改,此处获取数据库中的用户权限,
        //我数据库中存的是组成的二进制组合相加如符合 1 2 4 8各自代表一个权限 如:7 就是由 1 2 4 组成然后对应判断权限
        不过太难顶了(维护起来)。
        Lis\t<Integer> list = CommonUtils.intToIntegerList(entity.getRole());
        List<String> roles = new ArrayList<>();
        for (Integer i : list) {
            if (i == 1) {
                roles.add("admin");
            }else {
                roles.add("");
            }
        }
        userDto.setRoles(roles);
        userDto.setAvatar(entity.getAvatar());
        //据用户名查找用户信息,用户名和密码
        //AuthorityUtils.commaSeparatedStringToAuthorityList("admin") 把字符串转化为对应的对象,以逗号分隔字符串
        List<String> roles1 = userDto.getRoles();
        //解析
        StringBuilder rolestr = new StringBuilder();
        roles1.stream().forEach(e->{
            rolestr.append(e+",");
        });

        logger.info("用户名为:{}",username);
        return new User(username,userDto.getPasswd(), AuthorityUtils.commaSeparatedStringToAuthorityList(rolestr.toString()));
    }
}

9、用户名,密码校验

@Component
public class MyPasswordEncoder implements PasswordEncoder {
    private Logger logg = LoggerFactory.getLogger(MyPasswordEncoder.class);

    @Autowired
    private ITbSysEmployeeService tbSysEmployeeService;
    /**
     *  编码原始密码。通常,良好的编码算法应用SHA-1或更大的哈希与8字节或更大的随机生成的盐相结合。
     * @param rawPassword 密码,一个可读的字符值序列
     * @return
     */
    @Override
    public String encode(CharSequence rawPassword) {
        logg.info("原始密码:{}", rawPassword);
        return rawPassword.toString();
    }

    /**
     * 验证从存储中获得的编码密码是否与提交的原始密码匹配。如果密码匹配,返回true;如果不匹配,返回false。存储的密码本身永远不会被解码。
     * @param username 预设的验证密码。要编码和匹配的原始密码
     * @param encodedPassword 表单输入的密码。来自存储的编码密码与之比较
     * @return
     */
    @Override
    public boolean matches(CharSequence username, String encodedPassword) {
        logg.info("预设的验证密码:{}", username);
        logg.info("表单输入的密码:{}", encodedPassword);
        TbSysEmployeeEntity entity = tbSysEmployeeService.selectByUsername((String) username);
        //校验密码
        String pwd = "";
        try {
            pwd = EncryptionUtil.SHA1(EncryptionUtil.SHA1(encodedPassword+entity.getSalt()));
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (! pwd.equals( entity.getPassword())) {

            throw new BadCredentialsException("请输入正确的密码");
        }
        return true;
    }
}

10、动态url权限控制(重点呜呜,坑了我半天)

@Component
public class UrlFilterInvocationSecurityMetadataSource implements FilterInvocationSecurityMetadataSource {

    @Autowired
    TbSysPermissionDao permissionMapper;
    /***
     * 返回该url所需要的用户权限信息
     *
     * @param object: 储存请求url信息
     * @return: null:标识不需要任何权限都可以访问
     */
    @Override
    public Collection<ConfigAttribute> getAttributes(Object object) throws IllegalArgumentException {
        // 获取当前请求url
        String requestUrl = ((FilterInvocation) object).getRequestUrl();

        // TODO 忽略url请放在此处进行过滤放行,呜呜坑我半天
        List<String> urlList = new ArrayList<>();
        urlList.add("/login/user/employee/login");
        urlList.add("/login/user/employee/register");
        if (urlList.contains(requestUrl)) {
            return null;
        }

        // 数据库中所有url
        List<TbSysPermissionEntity> permissionList = permissionMapper.selectList(null);
        for (TbSysPermissionEntity permission : permissionList) {
            // 获取该url所对应的权限
            if (requestUrl.equals(permission.getUrl())) {
                //据url获取对应的角色列表

                List<String> roles = permissionMapper.selectRoleCodeByUrl(permission.getId());
                // 保存该url对应角色权限信息,将role返回
                return SecurityConfig.createList(roles.toArray(new String[roles.size()]));
            }
        }
        // 如果数据中没有找到相应url资源则为非法访问,要求用户登录再进行操作
        return SecurityConfig.createList("role_login");
    }

    @Override
    public Collection<ConfigAttribute> getAllConfigAttributes() {
        return null;
    }

    @Override
    public boolean supports(Class<?> aClass) {
        return FilterInvocation.class.isAssignableFrom(aClass);
    }
}

11、未登录和未授权的两种处理

/**
 * 当未登录或者token失效访问接口时,自定义的返回结果
 * Created by macro on 2018/5/14.
 */
@Component
public class RestAuthenticationEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json");
        response.getWriter().println("你还没登录哦");
        response.getWriter().flush();
    }
}

12、没得权限

/**
 * 当访问接口没有权限时,自定义的返回结果
 * Created by macro on 2018/4/26.
 */
@Component
public class RestfulAccessDeniedHandler implements AccessDeniedHandler {

    @Override
    public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AccessDeniedException e) throws IOException, ServletException {
        httpServletResponse.setCharacterEncoding("UTF-8");
        httpServletResponse.setContentType("application/json");
        httpServletResponse.getWriter().println("你没有权限哦");
        httpServletResponse.getWriter().flush();
    }
}

13、入门小结,后面将会围绕security 的各种过滤器去进行进一步的分析和学习

评论

暂无评论