SpringBoot整合Shiro学习(中)

我爱学习呀

已于 2022-01-30 16:39:41 修改

阅读量887

点赞数 1

于 2021-11-21 20:07:15 首次发布

本文链接：https://blog.csdn.net/qq_45745964/article/details/121459028

版权

SpringBoot整合Shiro（中）

基于【编程不良人】2020最新版Shiro教程,整合SpringBoot项目实战教程

哔哩哔哩链接：https://www.bilibili.com/video/BV1uz4y197Zm?p=1

上篇我们简单介绍了shiro的基本原理和认证和授权的实现，接下来我们将进行Shiro与jsp页面的整合开发。

六、Shrio整合JSP实战

6.1 整合思路

6.2 配置环境

1.创建项目

我们新建一个springboot项目，

配置项目信息，

引入依赖，

命名项目和位置，

2.引入依赖

创建好项目好，我们在pom.xml文件中引入更多依赖，具体的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 https://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.3.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!-- 引入JSP解析依赖 -->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>
        <!-- JSP标准标签库 -->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- 引入shiro整合Springboot依赖 -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring-boot-starter</artifactId>
            <version>1.5.3</version>
        </dependency>
        <!-- web依赖 -->
        <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>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

3.修改视图

我们打开application.properties 项目配置文件，修改视图为jsp

# 端口号
server.port=8080
# 项目目录
server.servlet.context-path=/shiro
# 项目名称
spring.application.name=shiro

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

4.新建jsp文件

我们在项目main目录下新建webapp目录，并在其下新建login.jsp和index.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>登录</title>
</head>
<body>
<h1>登录界面</h1>
<form action="${pageContext.request.contextPath}/user/login" method="post">
    用户名:<input type="text" name="username"> <br/>
    密 码 : <input type="text" name="password"> <br>
    <input type="submit" value="登录">
</form>
</body>
</html>

index.jsp代码如下：

<%@page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8" %>
<!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>主页</title>
</head>
<body>
<h1>系统主页</h1>
<a href="${pageContext.request.contextPath}/user/logout">退出登录</a>
<ul>
    <li><a href="">用户管理</a></li>
    <li><a href="">商品管理</a></li>
    <li><a href="">订单管理</a></li>
    <li><a href="">物流管理</a></li>
    <li><a href="">库存管理</a></li>
</ul>
</body>
</html>

5.新建自定义realm

我们在项目中新建自定义realm，命名为CustomerRealm，继承AuthorizingRealm，并重写授权和认证方法，此次我们先不书写具体授权和认证代码

6.新建Shiro配置类

我们新建config包，并新建ShiroConfig ，用于配置shiro，我们设置index.jsp为受限资源，需要认证和授权才可访问，具体的代码如下：

package com.example.demo.config;

import com.example.demo.realm.CustomerRealm;
import org.apache.shiro.realm.Realm;
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.HashMap;
import java.util.Map;

/**
 * 用来整合shiro框架相关的配置类
 */
@Configuration
public class ShiroConfig {
   
    // 1.创建shiroFilter , 负责拦截所有请求
    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager){
   
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        // 给filter设置安全管理器
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        // 配置系统受限资源 和 配置系统公共资源
        Map<String,String> map = new HashMap<String,String>();
        // key为系统资源的路径，
        map.put("/user/login","anon");//anon 表示设置为公共资源，它是一个filter，后续我们会进行介绍
        map.put("/index.jsp","authc"); // authc 表示请求这个资源需要认证和授权，它是一个filter，后续我们会进行介绍
        // map.put("/**","authc"); // 表示请求所有资源都需要认证和授权
        //默认认证界面路径---当认证不通过时跳转（我们可以自定义,不写默认就是它（/login.jsp）），因为shiro对jsp实现了很好的集成
        shiroFilterFactoryBean.setLoginUrl("/login.jsp");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
        return shiroFilterFactoryBean;
    }

    //2.创建安全管理器,此处使用DefaultWebSecurityManager，我们之前使用的DefaultSecurityManager不具有web容器的特性
    @Bean
    public DefaultWebSecurityManager getDefaultWebSecurityManager(Realm realm){
   
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        //给安全管理器设置
        defaultWebSecurityManager.setRealm(realm);
        return defaultWebSecurityManager;
    }

    //3.创建自定义realm
    @Bean("realm")
    public Realm getRealm(){
   
        CustomerRealm customerRealm = new CustomerRealm();
        return customerRealm;
    }
}

7.新建controller

我们新建controller包，并在其下新建UserController.java，书写登录和退出的代码，具体代码如下：

package com.example.demo.controller;

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.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("user")
public class UserController {
   

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

    /**
     * 用来处理身份认证
     * @param username
     * @param password
     * @return
     */
    @RequestMapping("login")
    public String login(String username, String password) {
   
        try {
   
            /* 在web环境中，只要我们在ShiroConfig配置中创建了安全管理器，shiro就会自动给SecurityUtils注入web的安全管理器，即注入DefaultWebSecurityManager*/
            // 获取主体对象
            Subject subject = SecurityUtils.getSubject();
            // 在认证过程中使用subject.login进行认证, UsernamePasswordToken将用户名密码封装为token
            subject.login(new UsernamePasswordToken(username, password));
            return "redirect:/index.jsp";
        } catch (UnknownAccountException e) {
   
            e.printStackTrace();
            System.out.println("用户名错误!");
        } catch (IncorrectCredentialsException e) {
   
            e.printStackTrace();
            System.out.println("密码错误!");
        } catch (Exception e) {
   
            e.printStackTrace();
            System.out.println(e.getMessage());
        }
        return "redirect:/login.jsp";
    }
}

8.运行项目

我们输入 http://localhost:8080/shiro/index.jsp 访问 index.jsp页面，发现项目跳转到了 http://localhost:8080/shiro/login.jsp ，这是因为我们设置了index.jsp 为受限资源，我们没有进行认证和授权，而shiro的默认认证界面路径为 /login.jsp （shiro对jsp有很好的集成），所以我们跳转到了 http://localhost:8080/shiro/login.jsp

6.3 认证和退出

我们输入正确的用户名密码，发现我们已经可以访问了：

而当我们点击“退出登录”时，再次访问http://localhost:8080/shiro/index.jsp发现shiro把路径重定向到了http://localhost:8080/shiro/login.jsp

扩展：修改配置

JSP 与IDEA 与SpringBoot存在一定的不兼容，如果我们访问不了jsp页面，修改此配置即可解决

刚刚我们在ShiroConfig文件中通过authc这个filter设置了index.jsp为系统受限资源，anon 为匿名访问资源，那么常见的filter有哪些呢？

6.4 常见过滤器

注意: shiro提供和多个默认的过滤器，我们可以用这些过滤器来配置控制指定url的权限：

6.5 MD5+Salt+散列的认证实现

前面的案例我们的用户名密码为在代码中假设的，现在我们想要改成连接数据库的方式获取用户数据并对密码进行加密处理，并新建register.jsp页面用于用户注册，具体步骤如下：

1.新建register.jsp

我们继续在项目的webapp目录下新建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>注册</title>
</head>
<body>
<h1>注册界面</h1>
<form action="${pageContext.request.contextPath}/user/register" method="post">
    用户名:<input type="text" name="username"> <br/>
    密 码 : <input type="text" name="password"> <br/>
    <input type="submit" value="立即注册"><br/>
    <a href="${pageContext.request.contextPath}/login.jsp">返回登录</a>
</form>
</body>
</html>

2.导入依赖

我们在项目的pom.xml中添加mybatis、数据库连接驱动、数据库连接池的相关依赖，具体代码如下：

<!-- mybatis相关依赖 -->
<dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <version>2.1.2</version>
</dependency>

<!-- mysql连接java驱动 -->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>8.0.23</version>
</dependency>

<!-- druid数据库连接池 -->
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>
  <version>1.1.19</version>
</dependency>

3.修改项目配置文件

我们打开application.properties文件，配置连接的数据库和mybatis的配置，具体代码如下：

server.port=8080
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://localhost:3306/shiro?characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=123456

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

4.新建数据库

这里我们使用Navicat进行创建数据库，我们新建数据库名为shiro，结构如下：

5.新建实体类

我们新建entity包，并在其包下新建User.java类，与数据库中的表结构一一对应，此处因为我们在pom.xml文件中引入了lombok依赖，

所以我们可以使用lombok进行简化代码，代码如下：

package com.example.demo.entity;

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

/*
@Data:getter、setter、toString等方法
@Accessors(chain = true):开启链式编程
@AllArgsConstructor:有参构造
@NoArgsConstructor:无参构造
*/
@Data
@Accessors(chain = true)
@AllArgsConstructor
@NoArgsConstructor
public class User {
   
    private String  id;
    private String username;
    private String password;
    private String salt;
}

6.新建dao接口

我们新建dao包，并在其包下新建UserMapper.java类，具体代码如下：

package com.example.demo.dao;

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

@Mapper
@Repository
public interface UserMapper {
   

    // 保存用户接口
    int save(User user);

    // 根据身份信息认证的方法
    User findByUserName(String username);

}

7.新建mapper配置文件

我们在resources下新建mapper文件夹，并在其包下新建UserMapper.xml文件，具体代码如下：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.example.demo.dao.UserMapper">

    <!-- 保存用户 -->
    <insert id="save" parameterType="User" useGeneratedKeys="true" keyProperty="id">
        insert into t_user values(#{id}, #{username}, #{password}, #{salt})
    </insert>

    <!-- 根据用户名查询用户 -->
    <select id="findByUserName

最低0.47元/天解锁文章

我爱学习呀

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot整合Shiro学习(中)

SpringBoot整合Shiro（中）基于【编程不良人】2020最新版Shiro教程,整合SpringBoot项目实战教程哔哩哔哩链接：https://www.bilibili.com/video/BV1uz4y197Zm?p=1上篇我们简单介绍了shiro的基本原理和认证和授权的实现，接下来我们将进行Shiro与jsp页面的整合开发。六、Shrio整合JSP实战6.1 整合思路6.2 配置环境1.创建项目我们新建一个springboot项目，配置项目信息，引入依赖，命名项目
复制链接

扫一扫