Spring Boot整合Shiro完成认证，权限管理，MD5+salt加密

最新推荐文章于 2020-12-28 22:14:48 发布
最新推荐文章于 2020-12-28 22:14:48 发布
阅读量797 收藏 4
点赞数 1
分类专栏： Java 文章标签： SpringBoot Shiro
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wFitting/article/details/92184282
版权

Spring Boot整合Shiro完成认证，权限管理，MD5+salt加密

整合代码如下

Pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.junwei</groupId>
    <artifactId>springboot-shiro</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-shiro</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.28</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <!--thymel对shiro的扩展标签 整合-->
        <dependency>
            <groupId>com.github.theborakompanioni</groupId>
            <artifactId>thymeleaf-extras-shiro</artifactId>
            <version>2.0.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
后端代码

  1. User.java

    package com.junwei.springbootshiro.pojo;

import lombok.*;
import org.springframework.stereotype.Repository;

/**
 * @Auther: wangjunwei
 * @Description: 用户实体类
 * @Date: Created in 16:18 2019/6/8
 */
@Setter
@Getter
@NoArgsConstructor
@AllArgsConstructor
@ToString
@Repository
public class User {
    private int id;
    private String username;
    private String password;
    private String perms;
}

  2. UserMapper.java

    package com.junwei.springbootshiro.mapper;

import com.junwei.springbootshiro.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

/**
 * @Auther: wangjunwei
 * @Description: 用户mapper层
 * @Date: Created in 16:19 2019/6/8
 */
@Mapper
public interface UserMapper {
    User findUser(@Param("username") String username);
    User findById(@Param("id") Integer id);

    void toRegist(@Param("user") User user,@Param("perms") String perms);
}

  3. UserMapper.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.junwei.springbootshiro.mapper.UserMapper">
    <insert id="toRegist">
        insert into user (username, password,perms) values (#{user.username},#{user.password},
                                                            #{perms})
    </insert>
    <select id="findUser" resultType="com.junwei.springbootshiro.pojo.User">
        select id,username,password from user where username = #{username}
    </select>
    <select id="findById" resultType="com.junwei.springbootshiro.pojo.User">
        select id,username,password,perms from user where id=#{id}
    </select>
</mapper>

  4. UserService.java

    package com.junwei.springbootshiro.service;

import com.junwei.springbootshiro.mapper.UserMapper;
import com.junwei.springbootshiro.pojo.User;
import com.junwei.springbootshiro.utils.Salt;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @Auther: wangjunwei
 * @Description: 用户业务逻辑层
 * @Date: Created in 16:21 2019/6/8
 */
@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public User findUser(String username) {
        return userMapper.findUser(username);
    }

    public User findById(Integer id) {
        return userMapper.findById(id);
    }

    public void toRegist(User user) {
        //密码加盐
        user.setPassword(new Md5Hash(user.getPassword(), Salt.addSalt).toString());
        userMapper.toRegist(user,"user:none");
    }
}

  5. ShiroConfig.java

    package com.junwei.springbootshiro.shiro;

import at.pollux.thymeleaf.shiro.dialect.ShiroDialect;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * @Auther: wangjunwei
 * @Description: Shiro配置类
 * @Date: Created in 10:34 2019/6/8
 */
@Configuration
public class ShiroConfig {

    /**
     * @param defaultWebSecurityManager 1
     * @return : org.apache.shiro.spring.web.ShiroFilterFactoryBean
     * @Author: wangjunwei
     * @Date: Created in 10:57 2019/6/8
     * @Description: 创建ShiroFilterFactoryBean
     */
    @Bean(name = "shiroFilterFactoryBean")
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("defaultWebSecurityManager"
    ) DefaultWebSecurityManager defaultWebSecurityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        //设置安全管理器
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        //添加shiro内置过滤器
        /*
            annon：表示可以匿名使用
            authc：表示需要认证（登录）才能使用，没有参数
            roles：参数可以写多个，多个时必须加上双引号，并且参数之间用逗号分隔
                例如/admins/user/**=perms["user:add:*,
                user:modify:*"]，当有多个参数时必须每个参数都通过才通过，想当于isPermitedAll()方法。
            rest：根据请求的方法，相当于/admins/user/**=perms[user:method] ,其中method为post，get，delete等。
            port：当请求的url的端口不是8081是跳转到schemal://serverName:8081?queryString,
            其中schmal是协议http或https等，serverName是你访问的host,
            8081是url配置里port的端口，queryString是你访问的url里的？后面的参数。
            authcBasic：没有参数表示httpBasic认证
            ssl：表示安全的url请求，协议为https
            user：当登入操作时不做检查
            perms：该资源必须授予权限才可以访问
         */

        Map<String, String> fMap = new LinkedHashMap<>();
        //拦截页面
        fMap.put("/add", "authc");
        fMap.put("/update", "authc");

        //授权过滤器
        //注意：当前授权拦截后，shiro会自动跳转到未授权页面
        fMap.put("/add", "perms[user:add]");
        fMap.put("/update", "perms[user:update]");

        shiroFilterFactoryBean.setFilterChainDefinitionMap(fMap);

        //被拦截返回登录页面
        shiroFilterFactoryBean.setLoginUrl("/login");
        //设置未授权提示页面
        shiroFilterFactoryBean.setUnauthorizedUrl("/permission");
        return shiroFilterFactoryBean;
    }

    /**
     * @param userRealm 1
     * @return : org.apache.shiro.web.mgt.DefaultWebSecurityManager
     * @Author: wangjunwei
     * @Date: Created in 17:24 2019/6/14
     * @Description: 创建SecurityManager
     */
    @Bean(name = "defaultWebSecurityManager")
    public DefaultWebSecurityManager getDefaultWebSecurityManager(@Qualifier("userRealm") UserRealm userRealm) {
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        //关联Realm
        defaultWebSecurityManager.setRealm(userRealm);
        return defaultWebSecurityManager;
    }

    /**
     * @return : com.junwei.springbootshiro.shiro.UserRealm
     * @Author: wangjunwei
     * @Date: Created in 16:55 2019/6/14
     * @Description: 创建Realm
     * 并设置加密规则
     */
    @Bean(name = "userRealm")
    public UserRealm getRealm(@Qualifier("hashedCredentialsMatcher") HashedCredentialsMatcher hashedCredentialsMatcher) {
        UserRealm userRealm = new UserRealm();
        userRealm.setCredentialsMatcher(hashedCredentialsMatcher);
        return userRealm;
    }

    /**
     * @return : at.pollux.thymeleaf.shiro.dialect.ShiroDialect
     * @Author: wangjunwei
     * @Date: Created in 18:00 2019/6/15
     * @Description: 配置ShiroDialect，用于thymeleaf和shiro标签配合使用
     */
    @Bean
    public ShiroDialect getShiroDialect() {
        return new ShiroDialect();
    }

    /**
     * @return : org.apache.shiro.authc.credential.HashedCredentialsMatcher
     * @Author: wangjunwei
     * @Date: Created in 19:14 2019/6/15
     * @Description: 设置加密对象，加密规则
     */
    @Bean(name = "hashedCredentialsMatcher")
    public HashedCredentialsMatcher hashedCredentialsMatcher() {
        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
        //使用md5加密算法进行加密
        hashedCredentialsMatcher.setHashAlgorithmName("md5");
        //设置散列次数：加密次数
        hashedCredentialsMatcher.setHashIterations(1);
        return hashedCredentialsMatcher;
    }
}

  6. UserRealm.java

    package com.junwei.springbootshiro.shiro;

import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.junwei.springbootshiro.pojo.User;
import com.junwei.springbootshiro.service.UserService;
import com.junwei.springbootshiro.utils.Salt;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.ByteSource;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @Auther: wangjunwei
 * @Description: 自定义Realm
 * @Date: Created in 16:17 2019/6/8
 */
public class UserRealm extends AuthorizingRealm {
    @Autowired
    private UserService userService;

    /**
     * @param principalCollection 1
     * @return : org.apache.shiro.authz.AuthorizationInfo
     * @Author: wangjunwei
     * @Date: Created in 16:53 2019/6/14
     * @Description: 执行授权
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //授权
        System.out.println("授权");
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        //到数据库查询当前登录用户的授权字符串
        //获取当前登录用户
        Subject subject = SecurityUtils.getSubject();
        User user = (User) subject.getPrincipal();
        User result = userService.findById(user.getId());
        //授权
        simpleAuthorizationInfo.addStringPermission(result.getPerms());
        return simpleAuthorizationInfo;
    }

    /**
     * @param authenticationToken 1
     * @return : org.apache.shiro.authc.AuthenticationInfo
     * @Author: wangjunwei
     * @Date: Created in 16:54 2019/6/14
     * @Description: 执行认证
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        System.out.println("认证");
        //shiro判断逻辑 判断用户名和密码
        UsernamePasswordToken user = (UsernamePasswordToken) authenticationToken;
        User newUser = userService.findUser(user.getUsername());
        if (newUser == null) {
            return null;
        }
        System.out.println(user.getPassword());
        //加密加盐认证
        SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(newUser,
                newUser.getPassword(),
                ByteSource.Util.bytes(Salt.addSalt), getName());
        return authenticationInfo;
    }
}

  7. Salt.java

    package com.junwei.springbootshiro.utils;

/**
 * @Auther: wangjunwei
 * @Description: 用户加盐
 * @Date: Created in 18:51 2019/6/15
 */
public class Salt {
    public static final String addSalt = "regist@^$*#!";
}

  8. PageController.java

    package com.junwei.springbootshiro.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @Auther: wangjunwei
 * @Description: 页面跳转controller
 * @Date: Created in 17:38 2019/6/14
 */
@Controller
public class PageController {
    @RequestMapping("/")
    public String toIndex(){
        return "index";
    }

    @RequestMapping("/{pageName}")
    public String toPage(@PathVariable String pageName){
        return pageName;
    }
}

  9. UserController.java

    package com.junwei.springbootshiro.controller;

import com.junwei.springbootshiro.pojo.User;
import com.junwei.springbootshiro.service.UserService;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
 * @Auther: wangjunwei
 * @Description: 用户controller层
 * @Date: Created in 16:23 2019/6/8
 */
@Controller
public class UserController {
    @Autowired
    private UserService userService;

    @RequestMapping(value = "toLogin",method = RequestMethod.POST)
    public String toLogin(User user, Model model){
        //shiro用户认证
        Subject subject = SecurityUtils.getSubject();
        //封装用户数据
        UsernamePasswordToken token = new UsernamePasswordToken(user.getUsername(),
                user.getPassword());
        try {
            subject.login(token);
            model.addAttribute("username",user.getUsername());
            return "index";
        }catch (UnknownAccountException e){
            model.addAttribute("msg","用户名不存在");
            return "login";
        }catch (IncorrectCredentialsException e){
            model.addAttribute("msg","密码错误");
            return "login";
        }
    }

    /**
     * @Author: wangjunwei
     * @Date: Created in 18:42 2019/6/15
     * @Description:
     * 注销功能
     * @return : java.lang.String
     */
    @RequestMapping("logout")
    public String logout(){
        Subject subject = SecurityUtils.getSubject();
        subject.logout();
        return "index";
    }

    /**
     * @Author: wangjunwei
     * @Date: Created in 18:46 2019/6/15
     * @Description: 用户注册
     * @param user 1
     * @return : java.lang.String
     */
    @RequestMapping(value = "toRegist",method = RequestMethod.POST)
    public String toRegist(User user){
        userService.toRegist(user);
        return "index";
    }
}
配置文件application.properties
#spring集成Mybatis环境 别名扫描
mybatis.type-aliases-package=com.junwei.springbootshiro.pojo
#加载Mybatis配置文件
mybatis.mapper-locations = classpath:mapper/*Mapper.xml
spring.datasource.type = com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name= com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/yjlg?useUnicode=true&characterEncoding=utf-8
spring.datasource.username = root
spring.datasource.password = 123
前台代码

  1. index.html

    <!DOCTYPE html>
<html lang="en" xmlns:th="http://www.w3.org/1999/xhtml" xmlns:shiro="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
</head>
<body>
<h1>首页</h1>
<!--验证当前用户是否为“访客”，即未登录的用户-->
<p shiro:guest=""><a href="/login">请登录</a></p>
<p><a href="/regist">注册</a></p>
<p shiro:authenticated="">你好，
    <shiro:principal property="username" /><br/><a href="/logout">注销</a></p>
<a shiro:hasPermission="user:add" href="/add">添加</a>
<a shiro:hasPermission="user:update" href="/update">修改</a>
</body>
</html>

  2. login.html

    <!DOCTYPE html>
<html lang="en" xmlns:th="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>登录页面</title>
</head>
<body>
<h1>登录页面</h1>
<form action="/toLogin" method="post">
    <p>
        <span>用户名：</span>
        <input type="text" name="username">
    </p>
    <p>
        <span>密码：</span>
        <input type="password" name="password">
    </p>
    <input type="submit" value="登陆">
</form>
<h3 th:text="${msg}"></h3>
</body>
</html>

  3. regist.html

    <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>用户注册</title>
</head>
<body>
<h1>用户注册</h1>
<form action="/toRegist" method="post">
    <p>用户名：<input type="text" name="username"></p>
    <p>密码：<input type="password" name="password"></p>
    <input type="submit" value="注册">
</form>
</body>
</html>

  4. add.html

    <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>用户添加</title>
</head>
<body>
    <h1>用户添加页面</h1>
</body>
</html>

  5. update.html

    <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>用户修改</title>
</head>
<body>
<h1>用户修改页面</h1>
</body>
</html>

  6. premission.html

    <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>未授权提示页面</title>
</head>
<body>
<h1>为授权提示页面</h1>
</body>
</html>
wFitting
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
SpringBoot与Shiro整合-权限管理实战视频及源码
09-03
Spring一直是很火的一个开源框架，在过去的一段时间里，Spring Boot在社区中热度一直很高，所以传智播客经常开课讲一讲这方面的知识点，为热爱编程技术的网友提前做好知识储备。 课程介绍： Spring Boot设计目的是用来简化Spring应用的初始搭建以及开发过程，而Shiro是一个强大且易用的Java权限框架,有身份验证、授权、加密和会话管理等功能。本课程重点讲解如何使用Spring Boot与Shiro进行无缝整合，实现强大的用户权限管理。 课程核心技术： Shiro框架功能简介； SpringBoot快速入门； Spring Boot与Shiro整合实现用户认证； Spring Boot与Shiro整合实现用户授权； thymeleaf和shiro标签整合使用。
spring boot+shiro 权限认证管理案例
12-20
Spring Boot 和 Apache Shiro 的整合是企业级应用中常见的权限认证和安全管理方案。Spring Boot 提供了简化 Java 应用程序开发的框架，而 Shiro 是一个轻量级的安全框架，专注于身份验证、授权、会话管理和加密。...
springboot整合shiro(含MD5加密)
Pinghu_Gary的博客
07-06 190
https://www.jianshu.com/p/7716951f4d7f
shiro认证+授权(使用MD5+salt+散列加密）
Kevinnsm的博客
12-28 268
通过上文自定义realm分析源码可得https://blog.csdn.net/Kevinnsm/article/details/11183124 用户认证在doGetAuthenticationInfo()方法中进行操作，授权在doGetAuthorizationInfo()方法中进行，如果想要自定义则必须实现AuthorizingRealm类，该类中继承了AuthenticatingRealm；AuthenticatingRealm类中的doGetAuthenticationInfo()方法实现了用户
SpringBoot整合shiro之盐值加密详解
和我一起学习吧
04-04 1万+
盐值是什么首先我们来探讨一下关于密码安全的问题在一个系统中我们通常会将用户名和密码存在数据库中，如果我们直接将密码存入数据库，会存在很大的安全隐患，比如：数据库被盗，传输过程中被黑客拦截，这都是很常见的问题，数据库所在的服务并不是绝对的安全，传输过程中也有可能被黑客拦截得到你传输的数据获得一些隐私的数据，并篡改后发往服务器。那么针对这种问题我们如何解决呢，安全在升级，骇客的技术同样也在进步，一个网...
SpringBoot整合Shiro示例实现动态权限加载更新+Session共享+单点登录
最新发布
06-19
SpringBoot整合Shiro示例实现动态权限加载更新+Session共享+单点登录 SpringBoot整合Shiro示例实现动态权限加载更新+Session共享+单点登录 SpringBoot整合Shiro示例实现动态权限加载更新+Session共享+单点登录 ...
Springboot整合Shiro之加盐MD5加密的方法
08-26
在本文中，我们将介绍如何在 Spring Boot 项目中整合 Shiro 框架，并使用加盐 MD5 加密来实现身份认证。Shiro 是一个功能强大且灵活的安全框架，提供了身份认证、授权、会话管理、缓存等功能。在 Spring Boot 项目中...
Spring Boot 整合 Shiro+Thymeleaf过程解析
08-25
Spring Boot 是一个基于Java的开源框架，提供了 eine 可以快速构建生产级别的应用程序的方法，而 Shiro 是一个功能强大且灵活的安全框架，提供了身份验证、授权、加密和会话管理等功能。Thymeleaf 是一个基于Java的...
Spring boot整合shiro+jwt实现前后端分离
08-25
Spring Boot 整合 Shiro+JWT 实现前后端分离 Spring Boot 框架是一个流行的 Java 框架，用于构建 Web 应用程序。Shiro 是一个强大的安全框架，提供了身份验证、授权、会话管理、加密等功能。JWT（JSON Web Token）...
springboot集成shiro的密码加密功能(MD5+salt)和登录验证功能
qq_39847344的博客
02-18 5066
1.先写一个shiro的密码生成工具 package com.learning.www.shiro.config; import org.apache.shiro.crypto.hash.SimpleHash; public class ShiroEncryption { /*** * 对用户的密码进行MD5加密 * 做成工具类 */ public static Str...
SpringBoot与权限框架shiro+MD5三次盐值加密 整合---多身份Realm认证
HELLO_CZ的博客
09-19 2443
最近在工作中用到权限框架shiro用于多重身份认证和登录，并且需要与sprinboot整合，于是网上搜索参考各种资料，再问问大佬，算是搞出来  但是估计还是有坑没有被发现 需求：现在客户登录分为工程商和工程师两种客户，并且这两种客户对于2张表，需要shiro来区别登录身份，并且去不同表查询用户信息来加以验证 步骤：     1：需要自定义UserNamePasswordToken 2 ...
springboot+shiro实现登陆过滤、权限认证、shiro密码加密、ehcache缓存（附demo项目）
热门推荐
AmbroseLe
09-12 2万+
首先说一下shiro能干什么 Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码学和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。（百度百科） 主要功能 三个核心组件：Subject, SecurityManager 和 Realms. Subjec...
SpringBoot/SpringMVC整合Shiro：实现登录与注册（MD5加盐加密）
因特马
01-07 1万+
本文欢迎转载，转载前请联系作者，经允许后方可转载。转载后请注明出处，谢谢！ http://blog.csdn.net/colton_null 作者：喝酒不骑马 Colton_Null from CSDN 终于终于，用正确姿势搭建了一个Spring框架下整合Shiro的登录注册的DEMO。 因为还有其他事情要忙，所以有关这个shiro的demo前前后后鼓捣了一周多。为啥多花这么多时间？ 按
springboot+shiro 登录时密码加密失败问题解决
oMangGuoBuDing1的专栏
07-25 2170
研究很长时间大盖两周，主要是卡在 登录的代码按照注册加密 然后与数据库中存的密码对比这块 网上找了好长时间都没找到答案，最后终于找到原因了。 解决问题的核心就是下面的代码 @Bean(name="myShiroRealm") public MyShiroRealm myShiroRealm(@Qualifier("credentialMatcher") CredentialsMatc...
springboot用户登陆密码两次md5加密
weixin_30846599的博客
01-29 291
1.用户端:PASS = MD5(明文 + 固定salt) 2.服务端:PASS = MD5(用户输入 + 随机salt) 引入依赖包 <dependency> <groupId>commons-codec</groupId> <artifactId>commons-codec</a...
springboot整合shiro登录MD5加密详细使用
weixin_45569664的博客
01-21 1568
2、shiro需要引用的jar包 @Configuration public class ShiroConfig { /** * 配置加密方式 * @return */ @Bean //用来声明bean 相当于在spring配置文件中配置<bean>标签 HashedCredentialsMatcher credentia...
Springboot（2.0）整合shiro
plumblum的博客
08-24 2557
Springboot（2.0）整合shiro 这个项目使用MD5算法加密，salt为username加随机数。 项目源码：github： 使用idea创建springboot工程并导入相关包 &amp;amp;amp;amp;lt;dependency&amp;amp;amp;amp;gt; &amp;amp;amp;amp;lt;groupId&amp;amp;amp;amp;gt;org.springframework.bo
"Spring Boot整合Shiro搭建权限管理系统教学指南
Spring Boot整合Shiro搭建权限管理系统是一项非常重要的教学内容，它涉及了在现代Web应用程序开发中必不可少的权限管理功能。本教学提纲以"Spring Boot整合Shiro搭建权限管理系统"为主题，通过详细的步骤和示例，...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值