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

最新推荐文章于 2023-08-28 08:43:25 发布
最新推荐文章于 2023-08-28 08:43:25 发布
阅读量813 收藏 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
关注
专栏目录
spring boot + shiro + redis 整合（完整）
qq_45275875的博客
04-17 7375
spring boot + shiro + redis 整合（完整）什么是shiro?数据库设计 什么是shiro? shiro是一个Java平台的开源权限框架，用于认证和访问授权。具体来说，满足对如下元素的支持： 用户，角色，权限（仅仅是操作权限，数据权限必须与业务需求紧密结合），资源（url） 用户分配角色，角色定义权限 访问授权时支持角色或者权限，并且支持多级的权限定义 数据库设计 数据...
Spring Boot2整合Shiro:BCrypt加密密码,springsecurity+BCryptPasswordEncoder实现加密注册登录 加密问题
qq_44970883的博客
12-13 1500
Spring Boot2+Shiro：加密密码注册， 登陆验证实现 一.前言 我在这与大家分享一下登陆验证时的一些问题和实现。应用考虑到安全，绝不能明文的方式保存密码（数据库不能存看得懂的秘密，一定程度也保证了用户的安全，同时也让很多攻破数据库的程序员没法瞎搞，比如 玩游戏出现用户的账号异地登陆之类的。。。） 有很多标准的算法比如SHA或者MD5(MD5可以用彩虹表暴力破解 后面会讲解如何破解)，MD5结合salt(盐)是一个不错的选择，j 项目使用Shiro框架做密码验证时的改进。 学习内容： 提示：这里
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标签整合使用。
springboot整合shiro(含MD5加密)
Pinghu_Gary的博客
07-06 204
https://www.jianshu.com/p/7716951f4d7f
shiro认证+授权(使用MD5+salt+散列加密）
Kevinnsm的博客
12-28 289
通过上文自定义realm分析源码可得https://blog.csdn.net/Kevinnsm/article/details/11183124 用户认证在doGetAuthenticationInfo()方法中进行操作，授权在doGetAuthorizationInfo()方法中进行，如果想要自定义则必须实现AuthorizingRealm类，该类中继承了AuthenticatingRealm；AuthenticatingRealm类中的doGetAuthenticationInfo()方法实现了用户
SpringBoot整合Shiro(超详细，适合新手学习，附有源码)
lianaozhe的博客
03-24 1413
shiro是什么呢?Shiro是一个功能强大,简单易用的 Java 安全框架，提供了用户认证、授权、加密、会话管理、缓存等功能。和目前另一款Java安全框架Spring Security相比，Shiro更加轻便，易于上手。各功能点介绍Authentication：用户身份认证/登录，即验证用户是不是合法用户Authorization：用户权限验证，即验证用户是否拥有某个角色，是否拥有某个权限。
Springboot整合Shiro实现MD5盐值加密
最新发布
kkk990101的博客
08-28 314
在 doGetAuthenticationInfo 方法中，返回值创建 SimpleAuthenticationInfo 对象, 需要使用 SimpleAuthenticationInfo(principal, credentials, credentialsSalt, realmName) 构造器，参数列表（实体信息，密码，盐值，realm名称）来计算盐值加密后的密码的值，随着越来越多MD5解密破解工具兴起，相对于MD5加密，MD5盐值加密更加安全保险。前台编写注册页面和登录页面。
Spring Boot 整合 Shiro 实现 Token 的登录和认证
u011202388的博客
04-15 6093
Spring Boot 2.X 实战--Shiro (Token)登录和验证 主要介绍了 Spring Boot 整合 Spring Security 实现 Token 的登录和认证，这一小节中，我们将实现 Spring Boot 整合 Shiro 实现 Token 的登录和认证。 目录结构 1）Apache Shiro 简介 2）Shiro 项目配置 2.1）项目配置 3）开始...
Web项目实战 | 购物系统v2.0 | 开发记录（七）SpringBoot整合Shiro框架进行身份认证 | Shiro 加盐(MD5+Salt)验证登陆 | 数据表结构优化避免外键+设置中间表
希望每天都能进步一点点
02-11 487
文章目录以往记录一、运行环境Bug&DeBug使用Shiro进行加盐身份认证时候报错 CryptoException 以往记录 Web项目实战 | 购物系统v2.0 | 开发记录（一）需求分析 | 技术选型 | 系统设计 | 数据表设计 | SpringBoot、SSM、Thymeleaf、Bootstrap… Web项目实战 | 购物系统v2.0 | 开发记录（二）搭建SpringBoot+SSM框架环境 | 配置Druid+MyBatis | 基于Bootstrap实现登陆页面| 图片验
Springboot+shiro简单登录案例
06-06
Shiro的简单登录，如若没有足够积分下载可留下邮箱或者私信我，直接发到你们邮箱，文章链接：https://blog.csdn.net/sutongxuevip/article/details/80584607
springboot+shiro+md5
07-23
这里详细记录一次springboot使用shiro进行登录验证操作，同时结合MD5加密技术，实现web后台的登录功能。
SpringBoot+Shiro实现MD5密码加密认证
帅帅气气的黑猫警长
08-24 947
SpringBoot+Shiro实现MD5加密验证
SpringBoot与Shiro整合详解
Zero摄氏度的博客
08-04 2356
Apache Shiro 是一个Java的安全（权限）框架 ------- 和SpringSecurity一样是安全框架 2. Shiro 可以非常容易的开发出足够好的应用，其不仅可以用在JavaSe环境. 3. Shiro 可以完成： 认证，授权，加密，会话管理，Web集成，缓存等...
SpringBoot(36) —— Shiro快速开始
Jzandth的博客
10-04 862
目录1.什么是Shiro2.Shiro的作用3.Shiro架构(外部)4.Shiro架构(内部)5.Hello World6.小结 1.什么是Shiro Apache Shiro 是 Java 的一个安全（权限）框架 Shiro 可以非常容易的开发出足够好的应用，其不仅可以用在 JavaSE 环境，也可以用在 JavaEE 环境 Shiro 可以完成：认证、授权、加密、会话管理、与Web 集成、缓存等 下载地址 官网 github 直接取GitHub上下载压缩包即可 2.Shiro的作用
springboot整合shiro实现权限控制
热门推荐
jiankang66的博客
05-24 4万+
Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码学和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。上个月写了一个在线教育的项目用到了shiro权限控制，这几天又复盘了一下，对其进行了深入探究，来总结一下。 下面所总结的有关shiro的代码已经传到我的github上，可以访问下面的......
springboot整合shiro登录MD5加密详细使用
weixin_45569664的博客
01-21 1596
2、shiro需要引用的jar包 @Configuration public class ShiroConfig { /** * 配置加密方式 * @return */ @Bean //用来声明bean 相当于在spring配置文件中配置<bean>标签 HashedCredentialsMatcher credentia...
springboot(十四)：springboot整合shiro-登录认证和权
weixin_34337265的博客
01-11 1965
这篇文章我们来学习如何使用Spring Boot集成Apache Shiro。安全应该是互联网公司的一道生命线，几乎任何的公司都会涉及到这方面的需求。在Java领域一般有Spring Security、Apache Shiro等安全框架，但是由于Spring Security过于庞大和复杂，大多数公司会选择Apache Shiro来使用，这篇文章会先介...
Shiro之springboot整合shiro的MD5加密问题（三）
it_erge的博客
06-24 1777
为了框架的安全考虑，不管前端加不加密，后端一定是需要加密的。这里先说一下为什么加密？我个人也在无数个夜晚问自己，加密有必要吗？如果前端传输把密码泄露了或者被拦截了，那我即使在后台加密也不安全啊！那既然这样为什么还要加密呢？个人认为后台加密还是主要是针对数据库的保护。如果数据库被攻克了，黑客拿着数据库的密码，直接去请求登录，这时候如果后台没做加密，这就会出现极大的安全隐患。但是做了加密，即使他拿到数...
"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、付费专栏及课程。

余额充值