• Shiro 01（shiro框架入门）

    目录

    一、Shiro简介

    1.1、什么是shiro? 

            1.2、 在应用程序角度来观察如何使用Shiro完成工作？

    1.3、Shiro架构

    shiro功能简介：

    Shiro核心架构图：

    二、Shiro入门案例

    准备工作：

    1、导入相关依赖

    2、编写shiro.ini文件（Shiro框架的配置文件）

     3、使用Shiro

    4、Shiro与Web容器集成

            ①在web.xml中进行shiro过滤器配置

            ②添加配置文件 shiro-web.ini

    一、Shiro简介

    1.1、什么是shiro? 

    Shiro是Apache的一个开源框架，是一个权限管理的框架，实现  用户认证、用户授权。

     ​ 权限管理，一般指根据系统设置的安全策略或者安全规则，用户可以访问而且只能访问自己被授权的资源，不多不少。权限管理几乎出现在任何系统里面，只要有用户和密码的系统。

    Spring中有Spring security（原名Acegi），是一个权限框架，它和Spring依赖过于紧密，没有Shiro使用简单。

    Shiro不依赖于Spring ，Shiro不仅可以实现Web应用的权限管理，还可以实现c/s系统，分布系统权限管理Shiro属于轻量级框架，越来越多企业项目开始使用Shiro。

    1.2、 在应用程序角度来观察如何使用Shiro完成工作？

    Subject：主体；代表了当前“用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是Subject，例如网络爬虫，机器人等；即一个抽象概念；所有Subject都绑定到SecurityManager，与Subject的所有交互都给SecurityManager；可以把Subject认为是一个门面；SecurityManager才是实际的执行者。

    SecurityManager：安全管理器；即所有与安全有关的操作都会与SecurityManager交互；且它管理着所有Subject；可以看出它是Shiro的核心，它负责与后边介绍的其他组件进行交互，如果学习过SpringMVC，你可以把它看成DispatcherServlet前端控制器。

    Realm：域；Shiro从Realm获取安全数据（例如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源。

    如图所示：

    1.3、Shiro架构

    ① subject：主体，可以是用户也可以是程序，主体要访问系统，系统需要对主体进行认证、授权。

    ② securityManager：安全管理器，主体进行认证和授权都是通过securityManager进行。securityManager是一个集合，  真正做事的不是securityManager而是它里面的东西。

    ③ authenticator：认证器，主体进行认证最终通过authenticator进行的。

    ④ authorizer：授权器，主体进行授权最终通过authorizer进行的。

    ⑤sessionManager：web应用中一般是用web容器（中间件tomcat）对session进行管理，shiro也提供一套session管理的方式，shiro不仅仅可以用于web管理也可以用于cs管理，所以他不用web容器的session管理。

      ⑥SessionDao：  通过SessionDao管理session数据，针对个性化的session数据存储需要使用sessionDao。（如果用tomcat管理session就不用SessionDao，如果要分布式的统一管理session就要用到SessionDao）。

    ⑦cache Manager：缓存管理器，主要对session和授权数据进行缓存（权限管理框架主要就是对认证和授权进行管理，session是在服务器缓存中的），比如将授权数据通过cacheManager进行缓存管理，和ehcache整合对缓存数据进行管理（redis是缓存框架）。

      ⑧ realm：域，领域，相当于数据源，通过realm存取认证、授权相关数据（原来是通过数据库取的）。 注意：authenticator认证器和authorizer授权器调用realm中存储授权和认证的数据和逻辑。

      ⑨ cryptography：密码管理，比如md5加密，提供了一套加密/解密的组件，方便开发。比如提供常用的散列、加/解密等功能。比如 md5散列算法（md5只有加密没有解密）。

    shiro功能简介：

     

     

    **Authentication：**身份认证/登录，验证用户是不是拥有相应的身份；

    **Authorization：**授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能进行什么操作，如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限；

    Session Manager：会话管理**，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；**会话可以是普通 JavaSE环境，也可以是 Web 环境；

    Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；

    Web Support：Web 支持，可以非常容易的集成到Web 环境；

    Caching：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可以提高效率；

    Concurrency：Shiro 支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能把权限自动传播过去；

    Testing：提供测试支持；

    Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；

    Remember Me：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了

    Shiro核心架构图：

      

    知识总结：

    1、认证        ——>接管了用户登录操作

    2、授权        ——>接管理系统资源的分配

    3、会话管理        ——>接管了Tomcat中国的session

    4、缓存管理        ——>主要提示权限管理的执行效率

    5、密码管理        ——>对密码进行加密

    二、Shiro入门案例

    准备工作：

    1、导入相关依赖

    导入pom依赖，将以下代码替换pom.xml中的 和

    1. <properties>
    2.         <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    3.         <maven.compiler.source>1.7maven.compiler.source>
    4.         <maven.compiler.target>1.7maven.compiler.target>
    5.         <maven.compiler.plugin.version>3.7.0maven.compiler.plugin.version>
    6.  
    7.         
    8.         <junit.version>4.12junit.version>
    9.         <servlet.version>4.0.0servlet.version>
    10.         <log4j2.version>2.9.1log4j2.version>
    11.         <slf4j.version>1.7.7slf4j.version>
    12.         <log4j2.disruptor.version>3.2.0log4j2.disruptor.version>
    13.  
    14.         <shiro.version>1.2.5shiro.version>
    15.     properties>
    16.  
    17.     <dependencies>
    18.         
    19.         <dependency>
    20.             <groupId>org.apache.shirogroupId>
    21.             <artifactId>shiro-coreartifactId>
    22.             <version>${shiro.version}version>
    23.         dependency>
    24.         
    25.         <dependency>
    26.             <groupId>org.apache.shirogroupId>
    27.             <artifactId>shiro-webartifactId>
    28.             <version>${shiro.version}version>
    29.         dependency>
    30.         
    31.         <dependency>
    32.             <groupId>junitgroupId>
    33.             <artifactId>junitartifactId>
    34.             <version>${junit.version}version>
    35.             <scope>testscope>
    36.         dependency>
    37.         
    38.         <dependency>
    39.             <groupId>javax.servletgroupId>
    40.             <artifactId>javax.servlet-apiartifactId>
    41.             <version>${servlet.version}version>
    42.             <scope>providedscope>
    43.         dependency>
    44.         
    45.         <dependency>
    46.             <groupId>org.slf4jgroupId>
    47.             <artifactId>slf4j-apiartifactId>
    48.             <version>${slf4j.version}version>
    49.         dependency>
    50.         <dependency>
    51.             <groupId>org.slf4jgroupId>
    52.             <artifactId>jcl-over-slf4jartifactId>
    53.             <version>${slf4j.version}version>
    54.             <scope>runtimescope>
    55.             <exclusions>
    56.                 <exclusion>
    57.                     <artifactId>slf4j-apiartifactId>
    58.                     <groupId>org.slf4jgroupId>
    59.                 exclusion>
    60.             exclusions>
    61.         dependency>
    62.         
    63.         <dependency>
    64.             <groupId>org.apache.logging.log4jgroupId>
    65.             <artifactId>log4j-slf4j-implartifactId>
    66.             <version>${log4j2.version}version>
    67.             <exclusions>
    68.                 <exclusion>
    69.                     <artifactId>slf4j-apiartifactId>
    70.                     <groupId>org.slf4jgroupId>
    71.                 exclusion>
    72.             exclusions>
    73.         dependency>
    74.         
    75.         <dependency>
    76.             <groupId>org.apache.logging.log4jgroupId>
    77.             <artifactId>log4j-apiartifactId>
    78.             <version>${log4j2.version}version>
    79.         dependency>
    80.         <dependency>
    81.             <groupId>org.apache.logging.log4jgroupId>
    82.             <artifactId>log4j-coreartifactId>
    83.             <version>${log4j2.version}version>
    84.         dependency>
    85.         
    86.         <dependency>
    87.             <groupId>org.apache.logging.log4jgroupId>
    88.             <artifactId>log4j-webartifactId>
    89.             <version>${log4j2.version}version>
    90.             <scope>runtimescope>
    91.         dependency>
    92.         
    93.         <dependency>
    94.             <groupId>com.lmaxgroupId>
    95.             <artifactId>disruptorartifactId>
    96.             <version>${log4j2.disruptor.version}version>
    97.         dependency>
    98.  
    99.     dependencies>

     将以下代码直接导入pom.xml中

    1.  <resources>
    2.             
    3.             <resource>
    4.                 <directory>src/main/javadirectory>
    5.                 <includes>
    6.                     <include>**/*.xmlinclude>
    7.                 includes>
    8.             resource>
    9.             
    10.             <resource>
    11.                 <directory>src/main/resourcesdirectory>
    12.                 <includes>
    13.                     <include>*.propertiesinclude>
    14.                     <include>*.xmlinclude>
    15.                     <include>*.iniinclude>
    16.                 includes>
    17.             resource>
    18.         resources>

    将以下代码直接导入pom.xml中（maven编译器） 

    1. <plugin>
    2.                     <groupId>org.apache.maven.pluginsgroupId>
    3.                     <artifactId>maven-compiler-pluginartifactId>
    4.                     <version>${maven.compiler.plugin.version}version>
    5.                     <configuration>
    6.                         <source>${maven.compiler.source}source>
    7.                         <target>${maven.compiler.target}target>
    8.                         <encoding>${project.build.sourceEncoding}encoding>
    9.                     configuration>
    10.                 plugin>

      

    log4j2.xml 

    1. "1.0" encoding="UTF-8"?>
    2.  
    4. <Configuration status="WARN" monitorInterval="30">
    5.     <Properties>
    6.         
    7.         
    8.         <Property name="LOG_HOME">${sys:user.home}/logsProperty>
    9.         <property name="ERROR_LOG_FILE_NAME">${sys:user.home}/logs/errorproperty>
    10.         <property name="WARN_LOG_FILE_NAME">${sys:user.home}/logs/warnproperty>
    11.  
    12.         
    13.         
    14.         
    15.         
    16.         
    17.  
    18.         
    19.         <property name="PATTERN">%d{yyyy-MM-dd HH:mm:ss.SSS} [%t-%L] %-5level %logger{36} - %msg%nproperty>
    20.         
    21.     Properties>
    22.  
    23.     <Appenders>
    24.         
    25.         <Console name="Console" target="SYSTEM_OUT">
    26.             
    27.             <ThresholdFilter level="trace" onMatch="ACCEPT"
    28.                              onMismatch="DENY"/>
    29.             
    30.             
    31.             <PatternLayout pattern="${PATTERN}"/>
    32.         Console>
    33.  
    34.         
    35.         
    36.         <File name="log" fileName="logs/test.log" append="false">
    37.             <PatternLayout
    38.                     pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
    39.         File>
    40.         
    41.         <RollingFile name="RollingFileInfo" fileName="${LOG_HOME}/info.log"
    42.                      filePattern="${LOG_HOME}/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log">
    43.             
    44.             <ThresholdFilter level="info" onMatch="ACCEPT"
    45.                              onMismatch="DENY"/>
    46.             <PatternLayout
    47.                     pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
    48.             <Policies>
    49.                 
    50.                 
    51.                 
    52.                 <TimeBasedTriggeringPolicy interval="1"
    53.                                            modulate="true"/>
    54.                 
    55.                 
    56.             Policies>
    57.         RollingFile>
    58.  
    59.         <RollingFile name="RollingFileWarn" fileName="${WARN_LOG_FILE_NAME}/warn.log"
    60.                      filePattern="${WARN_LOG_FILE_NAME}/$${date:yyyy-MM}/warn-%d{yyyy-MM-dd}-%i.log">
    61.             <ThresholdFilter level="warn" onMatch="ACCEPT"
    62.                              onMismatch="DENY"/>
    63.             <PatternLayout
    64.                     pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
    65.             <Policies>
    66.                 <TimeBasedTriggeringPolicy/>
    67.                 <SizeBasedTriggeringPolicy size="2 kB"/>
    68.             Policies>
    69.             
    70.             <DefaultRolloverStrategy max="20"/>
    71.         RollingFile>
    72.  
    73.         <RollingFile name="RollingFileError" fileName="${ERROR_LOG_FILE_NAME}/error.log"
    74.                      filePattern="${ERROR_LOG_FILE_NAME}/$${date:yyyy-MM}/error-%d{yyyy-MM-dd-HH-mm}-%i.log">
    75.             <ThresholdFilter level="error" onMatch="ACCEPT"
    76.                              onMismatch="DENY"/>
    77.             <PatternLayout
    78.                     pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
    79.             <Policies>
    80.                 
    81.                 <TimeBasedTriggeringPolicy interval="1"
    82.                                            modulate="true"/>
    83.                 
    84.             Policies>
    85.         RollingFile>
    86.  
    87.     Appenders>
    88.  
    89.     
    90.     <Loggers>
    91.         
    92.         
    93.         <logger name="org.springframework" level="ERROR">logger>
    94.         <logger name="org.mybatis" level="ERROR">logger>
    95.         <logger name="org.apache.ibatis" level="ERROR">logger>
    96.         <logger name="net.sf" level="ERROR"/>
    97.         <logger name="org.jboss" level="ERROR"/>
    98.         <logger name="org.apache.shiro" level="ERROR"/>
    99.  
    100.  
    101.         
    102.         <root level="all">
    103.             <appender-ref ref="Console"/>
    104.             
    105.             
    106.             
    107.         root>
    108.     Loggers>
    109.  
    110. Configuration>

     

    2、编写shiro.ini文件（Shiro框架的配置文件）

    shiro.ini

    代码展示：

    1. [users]
    2. zs=123
    3. ls=456
    4. ww=789

     3、使用Shiro

    1. 读取ini数据源文件，得到securitymanager工厂
    2. 获取securitymanager实例
    3. 将securitymanager交给Securityutils进行管理
    4. 通过securityutil获取登入用户主体subject
    5. 创建登入令牌token
    6. 利用主体subject进行登入
    7. 退出也使用subject

    解析：

     代码块展示：

    1. package com.chenchen.demo;
    2.  
    3. import org.apache.shiro.SecurityUtils;
    4. import org.apache.shiro.authc.UsernamePasswordToken;
    5. import org.apache.shiro.config.IniSecurityManagerFactory;
    6. import org.apache.shiro.mgt.SecurityManager;
    7. import org.apache.shiro.subject.Subject;
    8.  
    9. /**
    10.  * @author chenchen
    11.  * @site www.javacc.com
    12.  * @company xxx公司
    13.  * @create  2022-08-24 21:47
    14.  */
    15. public class Demo1 {
    16.     public static void main(String[] args) {
    17. //        将数据源放入工厂对像（将数据源放入工厂对象中）
    18.         IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro.ini");
    19. //        获取事务管理器（安全管理器）的实例
    20.         SecurityManager instance = factory.getInstance();
    21. //        将事务管理器实例交给SecurityUtils进行管理
    22.         SecurityUtils.setSecurityManager(instance);
    23. //        从安全管理器工具包中拿到登录的主体（用户）
    24.         Subject subject = SecurityUtils.getSubject();
    25. //      生成token 令牌 设置密码
    26.         UsernamePasswordToken token = new UsernamePasswordToken("zs", "123");
    27. //      这个时候这个用户是否可以登录取决于有没有token令牌--->登录密码
    28. //      主体携带令牌进行登录
    29.         subject.login(token);
    30.         System.out.println("登录成功....");
    31.         subject.logout();
    32.         System.out.println("登出成功....");
    33.  
    34.     }
    35. }

    效果展示：

    4、Shiro与Web容器集成

    回顾：

            Spring与Web容器集成，配置了监听器ContextLodaListener

            Springmvc与Web容器集成，配置了Dispatcherservlet

    Shiro与Web集成：

            ①在web.xml中进行shiro过滤器配置

    【这里的过滤器就是加载数据源，在你启动的时候拦截了所有的请求，将前面的那六步在过滤器中完成（使用shiro的六步骤）】

     

     web.xml代码块展示：

    1. "1.0" encoding="UTF-8"?>
    2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
    5.          version="3.1">
    6.   <display-name>Archetype Created Web Applicationdisplay-name>
    7.  
    8.   
    9.   <context-param>
    10.     <param-name>shiroConfigLocationsparam-name>
    11.     <param-value>classpath:shiro-web.iniparam-value>
    12.   context-param>
    13.   <listener>
    14.     <listener-class>org.apache.shiro.web.env.EnvironmentLoaderListenerlistener-class>
    15.   listener>
    16.  
    17.   
    18.   <filter>
    19.     <filter-name>ShiroFilterfilter-name>
    20.     <filter-class>org.apache.shiro.web.servlet.ShiroFilterfilter-class>
    21.   filter>
    22.   <filter-mapping>
    23.     <filter-name>ShiroFilterfilter-name>
    24.     <url-pattern>/*url-pattern>
    25.   filter-mapping>
    26.  
    27. web-app>

            ②添加配置文件 shiro-web.ini

    【辅助shiro过滤器完成shiro的六步骤，而前面我们所用的配置文件是shiro.ini的原因是因为我们没有使用web容器】

     shiro-web.ini        代码块展示：

    1. [main]
    2. #定义身份认证失败后的请求url映射，loginUrl是身份认证过滤器中的一个属性
    3. authc.loginUrl=/login
    4. #定义角色认证失败后的请求url映射，unauthorizedUrl是角色认证过滤器中的一个属性
    5. roles.unauthorizedUrl=/unauthorized.jsp
    6. #定义权限认证失败后请求url映射，unauthorizedUrl是角色认证过滤器中的一个属性
    7. perms.unauthorizedUrl=/unauthorized.jsp
    8.  
    9. [users]
    10. zs=123,role1
    11. ls=123,role2
    12. ww=123,role3
    13. zdm=123,admin
    14.  
    15.  
    16. [roles]
    17. role1=user:create
    18. role2=user:create,user:update
    19. role3=user:create,user:update,user:delete,user:view,user:load
    20. admin=user:*
    21.  
    22.  
    23.  
    24. #定义请求的地址需要做什么验证
    25. [urls]
    26. #请求login的时候不需要权限，游客身份即可(anon)
    27. /login.do=anon
    28.  
    29. #请求/user/updatePwd.jsp的时候，需要身份认证(authc)
    30. /user/updatePwd.jsp=authc
    31.  
    32. #请求/admin的时候，需要角色认证，必须是拥有admin角色的用户才行
    33. /admin/*.jsp=roles[admin]
    34.  
    35. #请求/teacher的时候，需要权限认证，必须是拥有user:create权限的角色的用户才行
    36. /user/teacher.jsp=perms["user:update"]

     三、测试

    添加测试所需要的代码：

     addUser.jsp

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <html>
    3. <head>
    4.     <title>Titletitle>
    5. head>
    6. <body>
    7.     <h1>用户新增h1>
    8. body>
    9. html>

    listUser.jsp 

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <html>
    3. <head>
    4.     <title>Titletitle>
    5. head>
    6. <body>
    7.     <h1>用户查询(所有)h1>
    8. body>
    9. html>

    resetPwd.jsp 

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <html>
    3. <head>
    4.     <title>Titletitle>
    5. head>
    6. <body>
    7.     <h1>重置用户密码h1>
    8. body>
    9. html>

    updateUser.jsp 

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <html>
    3. <head>
    4.     <title>Titletitle>
    5. head>
    6. <body>
    7.     <h1>用户修改h1>
    8. body>
    9. html>

    teacher.jsp 

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <html>
    3. <head>
    4.     <title>Titletitle>
    5. head>
    6. <body>
    7.     <h1>老师个人信息h1>
    8. body>
    9. html>

    updatePwd.jsp 

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <html>
    3. <head>
    4.     <title>Titletitle>
    5. head>
    6. <body>
    7.     <h1>个人密码修改h1>
    8. body>
    9. html>

    index.jsp 

    1. <html>
    2. <body>
    3. <h2>Hello World!h2>
    4. body>
    5. html>

    login.jsp

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <html>
    3. <head>
    4.     <title>Titletitle>
    5. head>
    6. <body>
    7.     <h1>用户登陆h1>
    8.     <div style="color: red">${message}div>
    9.     <form action="${pageContext.request.contextPath}/login" method="post">
    10.         帐号：<input type="text" name="username"><br>
    11.         密码：<input type="password" name="password"><br>
    12.         <input type="submit" value="确定">
    13.         <input type="reset" value="重置">
    14.     form>
    15. body>
    16. html>

    main.jsp

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <%@taglib prefix="r" uri="http://shiro.apache.org/tags" %>
    3. <html>
    4. <head>
    5.     <title>Titletitle>
    6. head>
    7. <body>
    8. <h1>主界面<%=System.currentTimeMillis()%>，欢迎您：[${sessionScope.username}]h1>
    9. <ul>
    10.     系统功能列表
    11.     <li>
    12.         <a href="admin/addUser.jsp">用户新增a>
    13.     li>
    14.     <li>
    15.         <a href="admin/listUser.jsp">用户查询a>
    16.     li>
    17.     <li>
    18.         <a href="admin/resetPwd.jsp">重置用户密码a>
    19.     li>
    20.     <li>
    21.         <a href="admin/updateUser.jsp">用户修改a>
    22.     li>
    23.     <li>
    24.         <a href="user/updatePwd.jsp">个人密码修改a>
    25.     li>
    26.     <li>
    27.         <a href="user/teacher.jsp">老师简介a>
    28.     li>
    29.     <li>
    30.         <a href="${pageContext.request.contextPath}/logout">退出系统a>
    31.     li>
    32. ul>
    33. <ul>
    34.     shiro标签
    35.     <li>
    36.         <r:hasPermission name="user:create">
    37.             <a href="admin/addUser.jsp">用户新增a>
    38.         r:hasPermission>
    39.     li>
    40.     <li>
    41.         <a href="admin/listUser.jsp">用户查询a>
    42.     li>
    43.     <li>
    44.         <a href="admin/resetPwd.jsp">重置用户密码a>
    45.     li>
    46.     <li>
    47.         <r:hasPermission name="user:update">
    48.             <a href="admin/updateUser.jsp">用户修改a>
    49.         r:hasPermission>
    50.     li>
    51.     <li>
    52.         <a href="user/updatePwd.jsp">个人密码修改a>
    53.     li>
    54.     <li>
    55.         <a href="${pageContext.request.contextPath}/logout">退出系统a>
    56.     li>
    57. ul>
    58. body>
    59. html>

    unauthorized.jsp

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <html>
    3. <head>
    4.     <title>Titletitle>
    5. head>
    6. <body>
    7.     <h1>未授权的操作h1>
    8.     <div>
    9.         未授权的操作，请与管理员联系，或切换帐号重新<a href="${pageContext.request.contextPath}/logout">登陆a>后再试！
    10.     div>
    11. body>
    12. html>

    Ok，那么我们现在可以开始测试了，

     

     点击运行，效果如下：

     这个时候，如果我们想要跳到其他页面的时候是不可以的，因为需要身份验证，

    所以这时候，需要写身份验证测试，

     

     LoginServlet.java        代码展示：

    1. package com.chenchen.demo;
    2.  
    3. import org.apache.shiro.SecurityUtils;
    4. import org.apache.shiro.authc.UsernamePasswordToken;
    5. import org.apache.shiro.subject.Subject;
    6.  
    7. import javax.servlet.ServletException;
    8. import javax.servlet.annotation.WebServlet;
    9. import javax.servlet.http.HttpServlet;
    10. import javax.servlet.http.HttpServletRequest;
    11. import javax.servlet.http.HttpServletResponse;
    12. import java.io.IOException;
    13.  
    14. /**
    15.  * @author chenchen
    16.  * @site www.javacc.com
    17.  * @company xxx公司
    18.  * @create  2022-08-25 14:50
    19.  *
    20.  * 用于用户登录
    21.  */
    22.  
    23. @WebServlet("/login")
    24. public class LoginServlet extends HttpServlet {
    25.  
    26.     @Override
    27.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    28.         doPost(req,resp);
    29.     }
    30.  
    31.     @Override
    32.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    33. //        获取用户账号
    34.         String username = req.getParameter("username");
    35. //        获取用户密码
    36.         String password = req.getParameter("password");
    37. //        拿到令牌
    38.         UsernamePasswordToken token = new UsernamePasswordToken(username,password);
    39. //        从安全管理器工具包中拿到登录的主体（用户）
    40.         Subject subject = SecurityUtils.getSubject();
    41. //        进行判断
    42.         try{
    43. //            匹配则转发进入主界面
    44.             subject.login(token);
    45.             req.getRequestDispatcher("/main.jsp").forward(req,resp);
    46.         }catch (Exception e){
    47. //            反之则进入登录界面
    48.             req.getRequestDispatcher("/login.jsp").forward(req,resp);
    49. //            提示
    50.             req.setAttribute("message","用户密码输入有误！！！");
    51.         }
    52.  
    53.     }
    54. }

     同样的还需要退出登录，

    logout.java        代码展示：

    1. package com.chenchen.demo;
    2.  
    3. import org.apache.shiro.SecurityUtils;
    4. import org.apache.shiro.authc.UsernamePasswordToken;
    5. import org.apache.shiro.subject.Subject;
    6.  
    7. import javax.servlet.ServletException;
    8. import javax.servlet.annotation.WebServlet;
    9. import javax.servlet.http.HttpServlet;
    10. import javax.servlet.http.HttpServletRequest;
    11. import javax.servlet.http.HttpServletResponse;
    12. import java.io.IOException;
    13.  
    14. /**
    15.  * @author chenchen
    16.  * @site www.javacc.com
    17.  * @company xxx公司
    18.  * @create  2022-08-25 14:50
    19.  *
    20.  * 用于用户登录
    21.  */
    22.  
    23. @WebServlet("/login")
    24. public class LoginServlet extends HttpServlet {
    25.  
    26.     @Override
    27.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    28.         doPost(req,resp);
    29.     }
    30.  
    31.     @Override
    32.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    33. //        获取用户账号
    34.         String username = req.getParameter("username");
    35. //        获取用户密码
    36.         String password = req.getParameter("password");
    37. //        拿到令牌
    38.         UsernamePasswordToken token = new UsernamePasswordToken(username,password);
    39. //        从安全管理器工具包中拿到登录的主体（用户）
    40.         Subject subject = SecurityUtils.getSubject();
    41. //        进行判断
    42.         try{
    43. //            匹配则转发进入主界面
    44.             subject.login(token);
    45.             req.getRequestDispatcher("/main.jsp").forward(req,resp);
    46.         }catch (Exception e){
    47. //            反之则进入登录界面
    48.             req.getRequestDispatcher("/login.jsp").forward(req,resp);
    49. //            提示
    50.             req.setAttribute("message","用户密码输入有误！！！");
    51.         }
    52.  
    53.     }
    54. }

    运行效果展示：

     当我们身份验证成功之后进入主界面（main.jsp）

     我们的shiro框架是一款权限管理框架，对于不同的用户可进行权限划分

     

     例如我们使用用户：zs进入

     OK，以上就是今天的分享内容，希望本期内容能帮助到您~~

    我们下期再见！

                                                            预告下期内容：Shiro认证。

  • 相关阅读:
    深入浅出了解华为云API网关的Gzip功能
    正则表达式小计
    swig封装C/C++实战-实现go调用C++然后C++在调用go
    Mindspore源码编译报错
    人工智能大会爆火的“数字员工”究竟是什么？
    美联储继续放鹰沪铜、棉花暴跌，沪铜认沽末日奇迹7天近200倍，棉花-PTA纺织套利持续下跌2022.6.24
    word页脚的页码全都一样
    浙江省内MBA项目奖学金盘点：给初试备考增添点动力～
    【问题处理小知识】jupyter notebook报错：500 internal server error的几种解决办法整理
    【C/C++】VS的cl命令 | 配置环境变量 | 使用命令行编译C/C++程序
  • 原文地址：https://blog.csdn.net/m0_67094505/article/details/126512392