Shiro 安全框架 2（springboot整合、认证、授权）

最新推荐文章于 2024-08-24 20:28:49 发布
最新推荐文章于 2024-08-24 20:28:49 发布
阅读量500 收藏 1
点赞数 1
分类专栏： java系列 文章标签： shiro mybatis mysql spring springboot
@BeanInJ
本文链接：https://blog.csdn.net/a__int__/article/details/112545725
版权
本文详细介绍了如何将Apache Shiro与SpringBoot结合，实现用户认证和授权功能。包括搭建SpringBoot环境，配置Shiro，数据库连接，MD5加密，角色权限持久化等步骤。涉及的内容包括自定义Realm，JSP页面，登录注册，角色权限标签的使用，以及解决报错问题。最后展示了项目结构和关键代码。
摘要由CSDN通过智能技术生成

文章目录

1、Shiro 与Spring boot整合

1.1、搭建spring boot环境

创建需要勾选的依赖
在这里插入图片描述
手动导入的jsp依赖

		<!--jsp-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <version>7.0.59</version>
        </dependency>
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

因为有jsp，我们设置一下工作路径
在这里插入图片描述
application.properties（配置端口、路径、jsp等）

server.port=8081
server.servlet.context-path=/shrio
spring.application.name=shrio

spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

新建一个jsp页面
在这里插入图片描述

<%@page contentType="text/html; UTF-8" pageEncoding="UTF-8" isELIgnored="false" %>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>jsp index</title>
</head>
<body>
    <h1>1111</h1>
</body>
</html>

同样的代码，再新建一个login.jsp
在这里插入图片描述

运行并访问试试
在这里插入图片描述

1.2、spring boot整合shiro

依赖

		<dependency>
			<groupId>org.apache.shiro</groupId>
			<artifactId>shiro-spring-boot-web-starter</artifactId>
			<version>1.4.1</version>
		</dependency>

开始配置shiro环境
新建shiro配置类ShiroConfig.java

import org.apache.shiro.realm.Realm;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

/*
* 整合shiro框架
* */
@Configuration
public class ShiroConfig {

    @Bean( name="shiroFilterFactoryBean")
    public ShiroFilterFactoryBean getFilter(DefaultWebSecurityManager defaultWebSecurityManager){
        // 负责拦截所有请求
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        // 给filter设置安全管理器
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        // 配置公共资源和受限资源
        Map<String,String> map = new HashMap<String,String>();
        map.put("/","authc");             // authc 表示请求这个资源需要认证和授权
        map.put("/index.jsp","authc");
        // 默认认证界面路径(也就是不管你访问哪个界面，都会先跳到这个界面认证)
        shiroFilterFactoryBean.setLoginUrl("/login.jsp");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);

        return shiroFilterFactoryBean;
    }
    @Bean
    public DefaultWebSecurityManager getManager(Realm realm){
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        defaultWebSecurityManager.setRealm(realm);
        return defaultWebSecurityManager;
    }


    @Bean
    public Realm getRealm(){
        CustomerRealm customerRealm = new CustomerRealm();
        return customerRealm;
    }
}

新建CustomerRealm.java

import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;

/*
* 自定义Realm
* */
public class CustomerRealm extends AuthorizingRealm {
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        return null;
    }
}

所有请求都需要认证如下
在这里插入图片描述
如上图，有个authc表示请求这个资源需要认证和授权，更多过滤器如下
在这里插入图片描述

2、认证实例

2.1、登录\退出 实例

新建一个UserController.java

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authc.pam.UnsupportedTokenException;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("user")
public class UserController {
    // 处理身份认证
    @RequestMapping("login")
    public String login(String username,String password){
        //获取主体对象
        Subject subject = SecurityUtils.getSubject();
        try {
            subject.login(new UsernamePasswordToken(username,password));
        } catch (UnsupportedTokenException e) {
            e.printStackTrace();
            System.out.println("用户名错误");
        } catch (IncorrectCredentialsException e) {
            e.printStackTrace();
            System.out.println("密码错误");
        }
        return "redirect:/index.jsp";
    }

    // 退出登录
    @RequestMapping("logout")
    public String logout(){
        Subject subject = SecurityUtils.getSubject();
        subject.logout();
        return "redirect:/login.jsp";
    }
}

login.jsp
在这里插入图片描述
index.jsp
在这里插入图片描述
修改CustomerRealm.java
在这里插入图片描述

        String principal = (String) authenticationToken.getPrincipal();

        if ("zhang".equals(principal)) {
            return new SimpleAuthenticationInfo(principal,"123",this.getName());
        }

修改ShiroConfig.java
指定公共资源和需要认证的资源
在这里插入图片描述

2.2、连接数据库、MD5加密+“盐”

pom中引入mysql、mybatis、druid依赖

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
         <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.19</version>
        </dependency>
2.2.1、数据库与mybatis

在mysql中新建库shiro，新建表t_user

create database shiro;

DROP TABLE IF EXISTS `t_user`;
CREATE TABLE `t_user` (
  `id` int NOT NULL AUTO_INCREMENT,
  `username` varchar(40) NOT NULL,
  `password` varchar(40) NOT NULL,
  `salt` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

application.properties配置数据库与mybatis

server.port=8081
server.servlet.context-path=/shrio
spring.application.name=shrio

spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/shiro?characterEncoding=utf-8&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root

mybatis.type-aliases-package=com.example.demo.entity
mybatis.mapper-locations=classpath:/mapper/*.xml

新建实体类User.java

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

@Data
@Accessors(chain = true)
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String username;
    private String password;
    private String salt;

}

在这里插入图片描述
新建接口UserDao
在这里插入图片描述

import com.example.demo.entity.User;
import org.springframework.stereotype.Service;

@Mapper
public interface UserDao {
    void save(User user);
}

新建User对应的mapper.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.demo.dao.UserDao">
    <insert id="save" parameterType="com.example.demo.entity.User" useGeneratedKeys="true" keyProperty="id">
        insert into t_user values(#{id},#{username},#{password},#{salt})
    </insert>
</mapper>

新建接口UserService
在这里插入图片描述

import com.example.demo.entity.User;
import org.apache.ibatis.annotations.Mapper;

public interface UserService {
    // 用户注册
    void register(User user);
}
2.2.2、页面

添加一个注册页面regedit.jsp (从登录页面复制过来修改的)
在这里插入图片描述

在ShiroConfig,java里面放行注册页面、注册路径
在这里插入图片描述

2.2.3、密码加密（注册）

新建工具类SaltUtils.java用来生成随机盐

import java.util.Random;

public class SaltUtils {
    public static String getSalt(int n){
        char[] chars = "qazwsxedcrfvtgbyhnujmikolpQAZWSXEDCRFVTGBYHNUJMIKOLP0123456789,./;'[]-=".toCharArray();
        StringBuilder s = new StringBuilder();
        for (int i=0;i<n;i++){
            char a = chars[new Random().nextInt(chars.length)];
            s.append(a);
        }
        return s.toString();
    }
}

新建UserServiceImpl.java里面完成注册业务

import com.example.demo.SaltUtils;
import com.example.demo.dao.UserDao;
import com.example.demo.entity.User;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional
public class UserServiceImpl implements UserService{
    @Autowired
    private UserDao userDao;
    @Override
    public void register(User user) {
        // 处理业务
        // 密码md5+salt+hash散列
        String salt = SaltUtils.getSalt(6);
        Md5Hash newPassword = new Md5Hash(user.getPassword(),salt,1024);

        user.setSalt(salt);
        user.setPassword(newPassword.toHex());

        userDao.save(user);

    }
}

在这里插入图片描述
在UserController里面添加注册
在这里插入图片描述

在这里插入图片描述


    @Autowired
    private UserService userService;


    // 用户注册
    @RequestMapping("register")
    public String register(User user){
        System.out.println(user.toString());
        try {
            // 注册成功，返回登录界面
            userService.register(user);
            return "redirect:/login.jsp";
        } catch (Exception e) {
            // 失败继续待在注册页面
            e.printStackTrace();
            System.out.println("注册失败");
            return "redirect:/regedit.jsp";
        }
    }

运行项目试试能不能注册了
在这里插入图片描述
注册完看看数据库
在这里插入图片描述
目前项目目录结构
在这里插入图片描述

2.2.4、验证密码（登录）

在配置文件里面添加logging日志
在这里插入图片描述

在UserDao接口中加入查询方法
在这里插入图片描述
在UserDaoMapper.xml里面实现查询数据库
在这里插入图片描述
在业务层接口添加上对应的方法
在这里插入图片描述
在业务层接口实现类添加上对应的方法
在这里插入图片描述新建ApplicationContextUtils.java （用来在工厂中获取service对象）

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class ApplicationContextUtils implements ApplicationContextAware {

    private static ApplicationContext context;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.context = applicationContext;
    }
    // 根据bean的名字获取工厂中指定bean
    public static Object getBean(String beanName){
        return context.getBean(beanName);
    }
}

在这里插入图片描述

定义realm到目前全部代码 （这里添加了md5验证、加盐、散列）
CustomerRealm.java

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
import org.springframework.util.ObjectUtils;

/*
* 自定义Realm
* */
public class CustomerRealm extends AuthorizingRealm {
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        String principal = (String) authenticationToken.getPrincipal();
        // 在工厂中获取service对象
        UserService us= (UserService) ApplicationContextUtils.getBean("userServiceImpl");
        User user = us.findByUsername(principal);

        if (!ObjectUtils.isEmpty(user)) {
            return new SimpleAuthenticationInfo(user.getUsername(),user.getPassword(), ByteSource.Util.bytes(user.getSalt()),this.getName());
        }
        return null;
    }
}

ShiroConfig.java到目前为止所有代码

import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

/*
* 整合shiro框架
* */
@Configuration
public class ShiroConfig {

    @Bean( name="shiroFilterFactoryBean")
    public ShiroFilterFactoryBean getFilter(DefaultWebSecurityManager defaultWebSecurityManager){
        // 负责拦截所有请求
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        // 给filter设置安全管理器
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        // 配置公共资源和受限资源
        Map<String,String> map = new HashMap<String,String>();
        map.put("/user/login","anon");           // anon 这个资源不需要认证
        map.put("/user/register","anon");
        map.put("/regedit.jsp","anon");
        map.put("/**","authc");                  // authc 表示请求这个资源需要认证和授权
        // 默认认证界面路径(也就是不管你访问哪个界面，都会先跳到这个界面认证)
        shiroFilterFactoryBean.setLoginUrl("/login.jsp");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);

        return shiroFilterFactoryBean;
    }
    @Bean
    public DefaultWebSecurityManager getManager(Realm realm){
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        defaultWebSecurityManager.setRealm(realm);
        return defaultWebSecurityManager;
    }


    @Bean
    public Realm getRealm(){
        CustomerRealm customerRealm = new CustomerRealm();
        // 修改凭证校验匹配器
        HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
        // MD5
        credentialsMatcher.setHashAlgorithmName("MD5");
        // 设置散列次数
        credentialsMatcher.setHashIterations(1024);
        customerRealm.setCredentialsMatcher(credentialsMatcher);
        return customerRealm;
    }
}

如上运行后就能成功认证了

3、报错

如果报错java.lang.NoSuchMethodError: org.apache.tomcat.JarScanner.scan…
在这里插入图片描述

可能是因为自己引入的tomcat版本和springboot自带的不一致导致出现此问题
所以要么删除自己引入的tomcat，要么去掉springboot内置的tomcat
在这里插入图片描述
这里我不需要外置tomcat，所以我删除了tomcat依赖
在这里插入图片描述

4、授权实例

修改自定义Realm
在这里插入图片描述
CustomerRealm.java目前全部代码

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
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.util.ByteSource;
import org.springframework.util.ObjectUtils;

/*
* 自定义Realm
* */
public class CustomerRealm extends AuthorizingRealm {
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        // 获取身份信息
        String pp = (String) principalCollection.getPrimaryPrincipal();
        // 根据主身份信息获取角色 和 权限信息
        if("a".equals(pp)){
            SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
            simpleAuthorizationInfo.addRole("admin");
            simpleAuthorizationInfo.addRole("user");
//            simpleAuthorizationInfo.addStringPermission("user:*:* ");
            simpleAuthorizationInfo.addStringPermission("user:add:* ");
            simpleAuthorizationInfo.addStringPermission("user:del:* ");
        }
        return null;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        String principal = (String) authenticationToken.getPrincipal();
        // 在工厂中获取service对象
        UserService us= (UserService) ApplicationContextUtils.getBean("userService");
        User user = us.findByUsername(principal);

        if (!ObjectUtils.isEmpty(user)) {
            return new SimpleAuthenticationInfo(user.getUsername(),user.getPassword(), ByteSource.Util.bytes(user.getSalt()),this.getName());
        }
        return null;
    }
}

index.jsp目前全部代码

<%@page contentType="text/html; UTF-8" pageEncoding="UTF-8" isELIgnored="false" %>
<%@taglib prefix="shiro" uri="http://shiro.apache.org/tags" %>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>jsp index</title>
</head>
<body>
    <h1>index界面</h1>
    <a href="${pageContext.request.contextPath}/user/logout">退出</a>

    <%--user或admin组都可以看到--%>
    <shiro:hasAnyRoles name="user,admin">
        <li><a href="">商品管理</a></li>
        <li><a href="">订单管理</a></li>
    </shiro:hasAnyRoles>

    <%--只有admin可以看到--%>
    <shiro:hasRole name="admin">
        <li><a href="">用户管理</a>
            <ul>
                <shiro:hasPermission name="user:add:*">
                    <li><a href="">添加</a></li>
                </shiro:hasPermission>
                <shiro:hasPermission name="user:del:*">
                    <li><a href="">删除</a></li>
                </shiro:hasPermission>
            </ul>
        </li>
        <li><a href="">物流管理</a></li>
    </shiro:hasRole>

</body>
</html>

新建OrderController.java

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authc.pam.UnsupportedTokenException;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @Author BeanInJ
 * @Date 16:04 2021/1/14
 **/
@Controller
@RequestMapping("order")
public class OrderController {
    @RequestMapping("save")
//    @RequiresRoles("admin")  //判断角色
//    @RequiresRoles(value = {"admin","user"})  //判断角色  同时具有admin、user
    @RequiresPermissions("user:del:01")    // 判断权限字符串
    public String save(){
        // 代码方式授权
        Subject subject = SecurityUtils.getSubject();
        if (subject.hasRole("admin")) {
            System.out.println("保存订单");
        }else {
            System.out.println("无权访问");
        }
        return "redirect:/index.jsp";
    }
}

4.1、授权持久化

4.1.1、mysql建表与dao层

在shiro数据库新建表t_role、t_perms、t_role_perms、t_user_role
在这里插入图片描述

DROP TABLE IF EXISTS `t_role`;
CREATE TABLE `t_role` (
  `id` int NOT NULL AUTO_INCREMENT,
  `name` varchar(60) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;


DROP TABLE IF EXISTS `t_pers`;
CREATE TABLE `t_pers` (
  `id` int NOT NULL AUTO_INCREMENT,
  `name` varchar(80) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL,
  `url` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

DROP TABLE IF EXISTS `t_role_perms`;
CREATE TABLE `t_role_perms` (
  `id` int NOT NULL AUTO_INCREMENT,
  `roleid` int DEFAULT NULL,
  `permsid` int DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

DROP TABLE IF EXISTS `t_role`;
CREATE TABLE `t_role` (
  `id` int NOT NULL AUTO_INCREMENT,
  `name` varchar(60) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

添加几个用户
在这里插入图片描述

添加三个角色
在这里插入图片描述
为用户添加对应的角色
在这里插入图片描述
新建表对应的实体类
Role.java

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

@Data
@Accessors(chain = true)
@AllArgsConstructor
@NoArgsConstructor
public class Role {
    private int id;
    private String name;

}

Perms.java

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

@Data
@Accessors(chain = true)
@AllArgsConstructor
@NoArgsConstructor
public class Perms {
    private int id;
    private String name;
    private String url;
}

在user实体类中定义角色集合
在这里插入图片描述
在UserDao里面增加根据用户名获取角色信息
在这里插入图片描述

在mapper里面添加上对应的查询sql语句
在这里插入图片描述

    <resultMap id="userMap" type="User">
        <id column="uid" property="id" />
        <result column="username" property="username" />
        <!--角色信息-->
        <collection property="roles" javaType="list" ofType="Role">
            <id column="id" property="id" />
            <result column="rname" property="name"/>
        </collection>
    </resultMap>
    <select id="findRolesByUserName" parameterType="String" resultMap="">
        SELECT u.id uid,u.username,r.id,r.name rname
        FROM t_user u
        LEFT JOIN t_user_role ur on u.id=ur.userid
        LEFT JOIN t_role r on ur.roleid=r.id
        WHERE u.username=#{username}
    </select>
4.1.2、服务层与控制层

UserService添加findRolesByUserName查询方法
在这里插入图片描述
UserServiceImpl
在这里插入图片描述
修改自定义realm中的权限部分
在这里插入图片描述

        UserService us= (UserService) ApplicationContextUtils.getBean("userService");
        User user = us.findRolesByUserName(pp);
        // 授权角色
        if(!CollectionUtils.isEmpty(user.getRoles())){
            SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
            user.getRoles().forEach(role -> {
                simpleAuthorizationInfo.addRole(role.getName());
            });
            return simpleAuthorizationInfo;
        }

5、代码总结

到目前为止，做了认证、角色权限，项目目录结构我修改了一下，如下
在这里插入图片描述
ShiroConfig.java

import com.beaninj.shiro.util.MyRealm;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

@Configuration
public class ShiroConfig {
    @Bean(name = "shiroFilterFactoryBean")
    public ShiroFilterFactoryBean getFilter(DefaultWebSecurityManager dwsManager) {
        // 负责拦截所有请求
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        // 给filter设置安全管理器
        shiroFilterFactoryBean.setSecurityManager(dwsManager);

        // 配置公共资源和受限资源
        Map<String, String> map = new HashMap<String, String>();
        map.put("/**", "authc");
        map.put("/user/login", "anon");           // anon 这个资源不需要认证
        map.put("/user/register", "anon");
        map.put("/register.jsp", "anon");
        map.put("/login.jsp", "anon");
        // authc 表示请求这个资源需要认证和授权

        // 默认认证界面路径 (也就是不管你访问哪个界面，都会先跳到这个界面认证)
        shiroFilterFactoryBean.setLoginUrl("/login.jsp");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);

        return shiroFilterFactoryBean;
    }
    @Bean
    public DefaultWebSecurityManager getManager(Realm realm) {
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        defaultWebSecurityManager.setRealm(realm);
        return defaultWebSecurityManager;
    }

    @Bean
    public Realm getRealm() {
        MyRealm myRealm = new MyRealm();
        // 修改凭证校验匹配器
        HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
        // MD5
        credentialsMatcher.setHashAlgorithmName("MD5");
        // 设置散列次数
        credentialsMatcher.setHashIterations(1024);

        myRealm.setCredentialsMatcher(credentialsMatcher);
        return myRealm;
    }
}

UserServiceImpl.java

import com.beaninj.shiro.dao.UserDao;
import com.beaninj.shiro.entity.User;
import com.beaninj.shiro.util.SaltUtils;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service("userService")
@Transactional  // 开启事务
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;

    @Override
    public void register(User user) {
        // 密码md5+salt+hash散列
        System.out.println("-----------------注册：存入md5+salt+hash散列的密码---------------");
        String salt = SaltUtils.getSalt(6);
        Md5Hash newPassword = new Md5Hash(user.getPassword(), salt, 1024);

        user.setSalt(salt);
        user.setPassword(newPassword.toHex());

        userDao.save(user);

    }

    @Override
    public User findByUsername(String username) {
        return userDao.findByUsername(username);
    }

    @Override
    public User findRolesByUserName(String username) {
        return userDao.findRolesByUserName(username);
    }


}

ApplicationContextUtils.java

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class ApplicationContextUtils implements ApplicationContextAware {

    private static ApplicationContext context;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.context = applicationContext;
    }

    // 根据bean的名字获取工厂中指定bean
    public static Object getBean(String beanName) {
        return context.getBean(beanName);
    }
}

MyRealm.java

import com.beaninj.shiro.entity.User;
import com.beaninj.shiro.service.UserService;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
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.util.ByteSource;
import org.apache.shiro.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

public class MyRealm extends AuthorizingRealm {
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        // 获取身份信息
        String pp = (String) principalCollection.getPrimaryPrincipal();
        // 根据主身份信息获取角色 和 权限信息
        UserService us = (UserService) ApplicationContextUtils.getBean("userService");
        User user = us.findRolesByUserName(pp);
        // 授权角色
        if (!CollectionUtils.isEmpty(user.getRoles())) {
            SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
            user.getRoles().forEach(role -> {
                simpleAuthorizationInfo.addRole(role.getName());
            });
            return simpleAuthorizationInfo;
        }
        return null;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        String principal = (String) authenticationToken.getPrincipal();
        // 在工厂中获取service对象
        UserService us= (UserService) ApplicationContextUtils.getBean("userService");
        User user = us.findByUsername(principal);

        if (!ObjectUtils.isEmpty(user)) {
            return new SimpleAuthenticationInfo(user.getUsername(),user.getPassword(), ByteSource.Util.bytes(user.getSalt()),this.getName());
        }
        return null;
    }
}

SaltUtils.java

import java.util.Random;

public class SaltUtils {
    public static String getSalt(int n) {
        char[] chars = "qazwsxedcrfvtgbyhnujmikolpQAZWSXEDCRFVTGBYHNUJMIKOLP0123456789,./;'[]-=".toCharArray();
        StringBuilder s = new StringBuilder();
        for (int i = 0; i < n; i++) {
            char a = chars[new Random().nextInt(chars.length)];
            s.append(a);
        }
        return s.toString();
    }
}

UserDaoMapper.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.beaninj.shiro.dao.UserDao">
    <insert id="save" parameterType="com.beaninj.shiro.entity.User" useGeneratedKeys="true" keyProperty="id">
        insert into t_user values(#{id},#{username},#{password},#{salt})
    </insert>
    <select id="findByUsername" parameterType="String" resultType="com.beaninj.shiro.entity.User">
        select id,username,password,salt from t_user
        where username = #{username}
    </select>
    <resultMap id="userMap" type="User">
        <id column="uid" property="id"/>
        <result column="username" property="username"/>
        <!--角色信息-->
        <collection property="roles" javaType="list" ofType="Role">
            <id column="id" property="id"/>
            <result column="rname" property="name"/>
        </collection>
    </resultMap>
    <select id="findRolesByUserName" parameterType="String" resultMap="userMap">
        SELECT u.id uid,u.username,r.id,r.name rname
        FROM t_user u
        LEFT JOIN t_user_role ur on u.id=ur.userid
        LEFT JOIN t_role r on ur.roleid=r.id
        WHERE u.username=#{username}
    </select>
</mapper>

application.properties

server.port=8081
server.servlet.context-path=/shiro
spring.application.name=shiro
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/shiro?characterEncoding=utf-8&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root
mybatis.type-aliases-package=com.beaninj.shiro.entity
mybatis.mapper-locations=classpath:/mapper/*.xml
logging.level.com.example.demo.dao=debug

index.jsp

<%@page contentType="text/html; UTF-8" pageEncoding="UTF-8" isELIgnored="false" %>
<%@taglib prefix="shiro" uri="http://shiro.apache.org/tags" %>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>jsp index</title>
</head>
<body>
<h1>index界面</h1>
<a href="${pageContext.request.contextPath}/user/logout">退出</a>

user或admin组都可以看到
<shiro:hasAnyRoles name="user,admin">
    <li><a href="">商品管理</a></li>
    <li><a href="">订单管理</a></li>
</shiro:hasAnyRoles>

<%--只有admin可以看到--%>
<shiro:hasRole name="admin">
    <li><a href="">用户管理</a>
        <ul>
            <shiro:hasPermission name="user:add:*">
                <li><a href="">添加</a></li>
            </shiro:hasPermission>
            <shiro:hasPermission name="user:del:*">
                <li><a href="">删除</a></li>
            </shiro:hasPermission>
        </ul>
    </li>
    <li><a href="">物流管理</a></li>
</shiro:hasRole>

</body>
</html>

logoin.jsp

<%@page contentType="text/html; UTF-8" pageEncoding="UTF-8" isELIgnored="false" %>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>jsp login</title>
</head>
<body>
<h1>请先登录</h1>
<a href="register.jsp">注册</a>
<form action="${pageContext.request.contextPath}/user/login">
    用户名：<input type="text" name="username"> <br>
    密码：<input type="text" name="password"> <br>
    <input type="submit" value="登录">
</form>
</body>
</html>

register.jsp

<%@page contentType="text/html; UTF-8" pageEncoding="UTF-8" isELIgnored="false" %>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>jsp regedit</title>
</head>
<body>
<h1>注册页面</h1>
<form action="${pageContext.request.contextPath}/user/register">
    用户名：<input type="text" name="username"> <br>
    密码：<input type="text" name="password"> <br>
    <input type="submit" value="注册">
</form>
</body>
</html>

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.4.1</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <groupId>com.beaninj</groupId>
  <artifactId>springboot_shiro</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>
  <name>springboot_shiro</name>

  <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.springframework.boot</groupId>
      <artifactId>spring-boot-devtools</artifactId>
      <scope>runtime</scope>
      <optional>true</optional>
    </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>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
      <version>2.4.0</version>
    </dependency>
    <!-- jsp依赖-->
    <dependency>
      <groupId>org.apache.tomcat.embed</groupId>
      <artifactId>tomcat-embed-jasper</artifactId>
    </dependency>
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <!--  mysql、druid、mybatis -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.19</version>
    </dependency>
    <dependency>
      <groupId>org.mybatis.spring.boot</groupId>
      <artifactId>mybatis-spring-boot-starter</artifactId>
      <version>2.1.2</version>
    </dependency>
    <!-- shiro -->
    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-spring-boot-web-starter</artifactId>
      <version>1.4.1</version>
    </dependency>
  </dependencies>

</project>
BeanInJ
关注
专栏目录
springboot整合shiro安全认证框架
weixin_46164384的博客
01-04 274
首先搭建一个简单的测试环境 搭建一个springboot 项目 引入依赖，主要是web starter shiro（安全认证） 和thymeleaf（简单的页面构建），这里不做数据层的查询，所以不引入数据库相关的。 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId&g
SpringBoot_Shiro_JWT_Redis:SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新
05-14
SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新 前端代码为一个博客页面，使用了Semantic UI框架结合thymeleaf模板 SpringBoot结合JWT+Shiro+Redis实现token无状态登录授权 [TOC] 一、引言 ​ ...
Springboot整合Spring security+Oauth2+JWT搭建认证服务器，网关，微服务之间权限认证及授权
03-24
Springboot整合Spring security+Oauth2+JWT搭建认证服务器，网关，微服务之间权限认证及授权。 OAuth2是一个关于授权的开放标准，核心思路是通过各类认证手段（具体什么手段OAuth2不关心）认证用户身份，并颁发token（令牌），使得第三方应用可以使用该令牌在限定时间、限定范围访问指定资源。
springboot集成shiro认证授权框架
weixin_43716343的博客
09-09 267
Apache Shiro是一个强大且易用的Java安全框架，执行身份验证、授权、密码学和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。 Apache Shiro 体系结构 1、Authentication 认证 ---- 用户登录 2、Authorization 授权 — 用户具有哪些权限 3、Cryptography 安全数据加密 4、Session Management 会话管理 5、Web Integration we
springboot整合shiro
最新发布
weixin_45476535的博客
08-24 510
【代码】springboot整合shiro。
SpringBoot集成认证授权（SpringBoot + Spring Security）
IT_WEH_coder的博客
02-26 1704
Spring Security是一个非常强大的安全框架，提供了丰富的功能和灵活的配置选项，可以很方便地集成到Spring Boot项目中。
使用Spring Boot实现用户认证和授权
Easonmax的博客
06-22 1186
Spring Boot是一个基于Spring框架的开源项目，旨在通过简化配置和快速开发，帮助开发者构建独立、生产级的Spring应用。Spring Boot通过自动化配置、内嵌服务器和多样化的配置方式，使得开发者能够更加专注于业务逻辑，而不需要花费大量时间在繁琐的配置上。Spring Security是Spring框架的一个子项目，提供了全面的安全服务支持。Spring Security通过高度可扩展的安全机制，简化了用户认证和授权的实现。定义用户实体类和角色实体类，并配置JPA注解。
springboot(十四)：springboot整合shiro-登录认证和权
weixin_34337265的博客
01-11 1954
这篇文章我们来学习如何使用Spring Boot集成Apache Shiro。安全应该是互联网公司的一道生命线，几乎任何的公司都会涉及到这方面的需求。在Java领域一般有Spring Security、Apache Shiro等安全框架，但是由于Spring Security过于庞大和复杂，大多数公司会选择Apache Shiro来使用，这篇文章会先介...
springboot 与shiro安全框架的整合
08-05
SpringBoot和Shiro是两个在Java开发中广泛使用的框架，SpringBoot简化了Spring应用的初始搭建以及开发过程，而Shiro则是一个强大的安全管理框架，负责处理认证、授权、会话管理和安全相关的过滤器。当我们把它们整合...
搭建Springboot整合shiro安全框架+Redis+Swagger+Filter超详细
07-08
在本教程中，我们将深入探讨如何利用Spring Boot整合Shiro安全框架，以实现用户认证与授权，同时结合Redis进行会话管理，以及使用Swagger为API提供文档化接口，最后通过Filter实现自定义的请求处理。以下是对这些...
SpringBoot---Spring security权限认证框架
m0_71117042的博客
01-22 461
最核心的就是 Basic Authentication Filter 用来认证用户的身份，一个在 Spring Security 中一种过滤器处理一种认证方式。这些信息可以用于验证、授权、信息交换，前端使用JWT来实现用户认证，后端可以通过解析JWT来获取用户信息；为了满足企业项目的不同需求，它提供了很多定制化开发的解决方案，通过简单的调整配置，就能为我们的应用提供一套可靠的安全保障。会捕获抛出的错误，然后根据不同的认证方式进行信息的返回提示。--security 依赖-->--JWT 依赖-->
Springboot使用shiro
qq_38345598的博客
01-28 3850
一、什么叫Aop Aop 作为面向对象编程的一种补充,广泛应用于处理一些具有横切性质的系统级服务器,如事务管理,安全检查,缓存检查,对象池管理等 Aop 实现的关键就在于代理的实现,代理分为动态代理与静态代理.动态代理是指在运行时借助JDK动态代理、CGLIB等在内存中“临时”生成Aop动态代理类，被称为运行时增强。 ...
Spring Boot学习之Shiro
缘友一世的博客
01-27 2347
Apache Shiro 是一个Java 的安全（权限）框架。Shiro可以完成，认证，授权，加密，会话管理，Web集成，缓存等。Shiro官网。
SpringBoot集成SpringSecurity
学不死就往死里学
08-14 763
SpringSecurity 安全简介 在 Web 开发中，安全一直是非常重要的一个方面。安全虽然属于应用的非功能性需求，但是应该在应用开发的初期就考虑进来。如果在应用开发的后期才考虑安全的问题，就可能陷入一个两难的境地：一方面，应用存在严重的安全漏洞，无法满足用户的要求，并可能造成用户的隐私数据被攻击者窃取；另一方面，应用的基本架构已经确定，要修复安全漏洞，可能需要对系统的架构做出比较重大的调整，因而需要更多的开发时间，影响应用的发布进程。因此，从应用开发的第一天就应该把安全相关的因素考虑进来，并在整个应
极简shiro入门
czhAL的博客
12-07 453
1.shiro是什么? Shiro是Apache下的一个开源项目。shiro属于轻量级框架，相对于SpringSecurity简单的多，也没有SpringSecurity那么复杂。以下是我自己学习之后的记录。 官方架构图如下： 2.主要功能 shiro主要有三大功能模块： Subject：主体，一般指用户。 SecurityManager：安全管理器，管理所有Subject，可以配合内部安全组件。(类似于SpringMVC中的DispatcherServlet) Realms：用于进行权限信息的验证，一
Springboot_Shiro
qq_42102911的博客
04-08 510
一、shiro简介 1. shiro是啥？ Apache Shiro 是 Java 的一个安全（权限）框架。 Shiro 可以非常容易的开发出足够好的应用，其不仅可以用在 JavaSE 环境，也可以用在 JavaEE 环境。 Shiro 可以完成：认证、授权、加密、会话管理、与Web 集成、缓存等。 深入学习： 官网：http://shiro.apache.org/ github：https://github.com/apache/shiro 2. Shiro 基本功能
SpringBoot--Shiro
qq_43430343的博客
08-25 203
Shiro 什么是Shiro？ Apache Shiro是一个Java的安全(权限)框架。 Shiro 可以非常容易的开发出足够好的应用，其不仅可以用在JavaSE环境，也可以用在JavaEE环境。 Shiro可以完成， 认证,授权,加密，会话管理，Web集成，缓存等。 1、pom.xml <dependencies> <dependency> <groupId>org.apache.shiro</groupId&gt
springboot--shiro
qy132的博客
07-05 130
1.引入shiro综合嫁包 <!-- shiro--> <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring-boot-starter</artifactId> <version>1.7.0</version>
SpringBoot整合Shiro教程：认证、授权、加密与Web集成
Apache Shiro 是一个强大且易用的 Java 安全框架，它提供了认证、授权、加密和会话管理功能，简化了开发者处理安全问题的过程。在本视频教程中，你将学习如何将 Shiro 与 SpringBoot 和 Mybatis 整合，构建一个完整...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值