精华内容
下载资源
问答
  • shiro 入门

    2019-10-12 21:17:08
    2、Shiro入门案例 3、Shiro与web容器的集成 Shiro 简介 什么是shiro shiro 是 apache 的一个开源框架,是一个 权限管理 的框架,实现 用户认证、用户授权。 spring中有spring security (原名Acegi),是一个权限...

    本章目标:
    1、shiro简介
    2、Shiro入门案例
    3、Shiro与web容器的集成

    Shiro 简介

    1. 什么是shiro
      shiroapache 的一个开源框架,是一个 权限管理 的框架,实现 用户认证、用户授权。

      spring中有spring security (原名Acegi),是一个权限框架,它和spring依赖过于紧密,没有shiro使用简单。

      shiro 不依赖于spring,shiro不仅可以 实现 web 应用的权限管理 ,还可以实现 c/s 系统,

      分布式系统权限管理,shiro属于轻量框架,越来越多企业项目开始使用shiro。

    2. 在应用程序角度来观察如何使用Shiro完成工作
      在这里插入图片描述
      Subject:主体
      代表了当前“用户”,这个用户不一定是一个具体的人,与当前应用交互的任何东西都是Subject,如网络爬虫,机器人等;即一个抽象概念;所有Subject 都绑定到SecurityManager,与Subject的所有交互都会委托给SecurityManager;可以把Subject认为是一个门面;SecurityManager才是实际的执行者;

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

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

    3. shiro架构
      在这里插入图片描述
      3.1 subject:主体,可以是用户也可以是程序,主体要访问系统,系统需要对主体进行认证、授权。

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

      3.3 authenticator:认证器,主体进行认证最终通过authenticator进行的。

      3.4 authorizer:授权器,主体进行授权最终通过authorizer进行的。

      3.5 sessionManager:web应用中一般是用web容器(中间件tomcat)对session进行管理,shiro也提供一套session管理的方式。
      shiro不仅仅可以用于web管理,也可以用于cs管理,所以他不用web容器的session管理。

      3.6 SessionDao: 通过SessionDao管理session数据,针对个性化的session数据存储需要使用sessionDao
      (如果用tomcat管理session就不用SessionDao,如果要分布式的统一管理session就要用到SessionDao)。

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

      3.8 realm:域,领域,相当于数据源,通过realm存取认证、授权相关数据(原来是通过数据库取的)。
      注意:authenticator认证器和authorizer授权器调用realm中存储授权和认证的数据和逻辑。

      3.9 cryptography:密码管理,比如md5加密,提供了一套加密/解密的组件,方便开发。比如提供常用的散列、加/解密等功能。比如 md5散列算法(md5只有加密没有解密)。


    Shiro 入门案例

    准备工作:
    1、导入相关依赖
    2、编写shiro.ini文件

    log4j2.xml

    <?xml version="1.0" encoding="UTF-8"?>
    
    <!-- status : 指定log4j本身的打印日志的级别.ALL< Trace < DEBUG < INFO < WARN < ERROR
       < FATAL < OFF。 monitorInterval : 用于指定log4j自动重新配置的监测间隔时间,单位是s,最小是5s. -->
    <Configuration status="WARN" monitorInterval="30">
        <Properties>
            <!--window配置-->
            <!--配置日志文件输出目录 ${sys:user.home}-->
            <Property name="LOG_HOME">${sys:user.home}/logs</Property>
            <property name="ERROR_LOG_FILE_NAME">${sys:user.home}/logs/error</property>
            <property name="WARN_LOG_FILE_NAME">${sys:user.home}/logs/warn</property>
    
            <!--linux ubuntu配置-->
            <!--请在操作系统中配置环境变量catalina_home-->
            <!--<Property name="LOG_HOME">${catalina_home}/logs</Property>-->
            <!--<property name="ERROR_LOG_FILE_NAME">${catalina_home}/logs/error</property>-->
            <!--<property name="WARN_LOG_FILE_NAME">${catalina_home}/logs/warn</property>-->
    
            <!--配置日志格式-->
            <property name="PATTERN">%d{yyyy-MM-dd HH:mm:ss.SSS} [%t-%L] %-5level %logger{36} - %msg%n</property>
            <!--<property name="PATTERN">%n  Level: %p%n   Time: %d%n Method: %l%nMessage: %m%n</property>-->
        </Properties>
    
        <Appenders>
            <!--这个输出控制台的配置 -->
            <Console name="Console" target="SYSTEM_OUT">
                <!-- 控制台只输出level及以上级别的信息(onMatch),其他的直接拒绝(onMismatch) -->
                <ThresholdFilter level="trace" onMatch="ACCEPT"
                                 onMismatch="DENY"/>
                <!-- 输出日志的格式 -->
                <!-- %d{yyyy-MM-dd HH:mm:ss, SSS} : 日志生产时间 %p : 日志输出格式 %c : logger的名称
                    %m : 日志内容,即 logger.info("message") %n : 换行符 %C : Java类名 %L : 日志输出所在行数 %M
                    : 日志输出所在方法名 hostName : 本地机器名 hostAddress : 本地ip地址 -->
                <PatternLayout pattern="${PATTERN}"/>
            </Console>
    
            <!--文件会打印出所有信息,这个log每次运行程序会自动清空,由append属性决定,这个也挺有用的,适合临时测试用 -->
            <!--append为TRUE表示消息增加到指定文件中,false表示消息覆盖指定的文件内容,默认值是true -->
            <File name="log" fileName="logs/test.log" append="false">
                <PatternLayout
                        pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
            </File>
            <!-- 这个会打印出所有的info及以下级别的信息,每次大小超过size, 则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩,作为存档 -->
            <RollingFile name="RollingFileInfo" fileName="${LOG_HOME}/info.log"
                         filePattern="${LOG_HOME}/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log">
                <!--控制台只输出level及以上级别的信息(onMatch),其他的直接拒绝(onMismatch) -->
                <ThresholdFilter level="info" onMatch="ACCEPT"
                                 onMismatch="DENY"/>
                <PatternLayout
                        pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
                <Policies>
                    <!-- 基于时间的滚动策略,interval属性用来指定多久滚动一次,默认是1 hour。 modulate=true用来调整时间:比如现在是早上3am,interval是4,那么第一次滚动是在4am,接着是8am,12am...而不是7am. -->
                    <!-- 关键点在于 filePattern后的日期格式,以及TimeBasedTriggeringPolicy的interval, 日期格式精确到哪一位,interval也精确到哪一个单位 -->
                    <!-- log4j2的按天分日志文件 : info-%d{yyyy-MM-dd}-%i.log -->
                    <TimeBasedTriggeringPolicy interval="1"
                                               modulate="true"/>
                    <!-- SizeBasedTriggeringPolicy:Policies子节点, 基于指定文件大小的滚动策略,size属性用来定义每个日志文件的大小. -->
                    <!-- <SizeBasedTriggeringPolicy size="2 kB" /> -->
                </Policies>
            </RollingFile>
    
            <RollingFile name="RollingFileWarn" fileName="${WARN_LOG_FILE_NAME}/warn.log"
                         filePattern="${WARN_LOG_FILE_NAME}/$${date:yyyy-MM}/warn-%d{yyyy-MM-dd}-%i.log">
                <ThresholdFilter level="warn" onMatch="ACCEPT"
                                 onMismatch="DENY"/>
                <PatternLayout
                        pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
                <Policies>
                    <TimeBasedTriggeringPolicy/>
                    <SizeBasedTriggeringPolicy size="2 kB"/>
                </Policies>
                <!-- DefaultRolloverStrategy属性如不设置,则默认为最多同一文件夹下7个文件,这里设置了20 -->
                <DefaultRolloverStrategy max="20"/>
            </RollingFile>
    
            <RollingFile name="RollingFileError" fileName="${ERROR_LOG_FILE_NAME}/error.log"
                         filePattern="${ERROR_LOG_FILE_NAME}/$${date:yyyy-MM}/error-%d{yyyy-MM-dd-HH-mm}-%i.log">
                <ThresholdFilter level="error" onMatch="ACCEPT"
                                 onMismatch="DENY"/>
                <PatternLayout
                        pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
                <Policies>
                    <!-- log4j2的按分钟 分日志文件 : warn-%d{yyyy-MM-dd-HH-mm}-%i.log -->
                    <TimeBasedTriggeringPolicy interval="1"
                                               modulate="true"/>
                    <!-- <SizeBasedTriggeringPolicy size="10 MB" /> -->
                </Policies>
            </RollingFile>
    
        </Appenders>
    
        <!--然后定义logger,只有定义了logger并引入的appender,appender才会生效 -->
        <Loggers>
            <!-- 第三方日志系统 -->
            <!--过滤掉spring和mybatis的一些无用的DEBUG信息 -->
            <logger name="org.springframework" level="ERROR"></logger>
            <logger name="org.mybatis" level="ERROR"></logger>
            <logger name="org.apache.ibatis" level="ERROR"></logger>
            <logger name="net.sf" level="ERROR"/>
            <logger name="org.jboss" level="ERROR"/>
            <logger name="org.apache.shiro" level="ERROR"/>
    
    
            <!-- 配置日志的根节点 -->
            <root level="all">
                <appender-ref ref="Console"/>
                <!--<appender-ref ref="RollingFileInfo" />-->
                <!--<appender-ref ref="RollingFileWarn" />-->
                <!--<appender-ref ref="RollingFileError" />-->
            </root>
        </Loggers>
    
    </Configuration>
    
    

    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>
    
      <groupId>com.dj</groupId>
      <artifactId>shiro01</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>war</packaging>
    
      <name>shiro01 Maven Webapp</name>
      <!-- FIXME change it to the project's website -->
      <url>http://www.example.com</url>
    
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
        <maven.compiler.plugin.version>3.7.0</maven.compiler.plugin.version>
    
        <!-- 添加相关依赖 -->
        <junit.version>4.12</junit.version><!-- 做测试 -->
        <servlet.version>4.0.0</servlet.version><!-- shiro 与 web容器 的整合 -->
        <!--  日志  -->
        <log4j2.version>2.9.1</log4j2.version>
        <slf4j.version>1.7.7</slf4j.version>
        <log4j2.disruptor.version>3.2.0</log4j2.disruptor.version>
        <!--  shiro 的依赖  -->
        <shiro.version>1.2.5</shiro.version>
      </properties>
    
    
      <dependencies>
        <!-- shiro核心包 -->
        <dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-core</artifactId>
          <version>${shiro.version}</version>
        </dependency>
        <!-- 添加shiro web支持 -->
        <dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-web</artifactId>
          <version>${shiro.version}</version>
        </dependency>
        <!--**********junit**********-->
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>${junit.version}</version>
          <scope>test</scope>
        </dependency>
        <!--**********servlet**********-->
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>${servlet.version}</version>
          <scope>provided</scope>
        </dependency>
        <!-- **********************  日志配置  ********************** -->
        <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>slf4j-api</artifactId>
          <version>${slf4j.version}</version>
        </dependency>
        <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>jcl-over-slf4j</artifactId>
          <version>${slf4j.version}</version>
          <scope>runtime</scope>
          <exclusions>
            <exclusion>
              <artifactId>slf4j-api</artifactId>
              <groupId>org.slf4j</groupId>
            </exclusion>
          </exclusions>
        </dependency>
        <!--2) 用于与slf4j保持桥接-->
        <dependency>
          <groupId>org.apache.logging.log4j</groupId>
          <artifactId>log4j-slf4j-impl</artifactId>
          <version>${log4j2.version}</version>
          <exclusions>
            <exclusion>
              <artifactId>slf4j-api</artifactId>
              <groupId>org.slf4j</groupId>
            </exclusion>
          </exclusions>
        </dependency>
        <!--3) 核心log4j2jar包-->
        <dependency>
          <groupId>org.apache.logging.log4j</groupId>
          <artifactId>log4j-api</artifactId>
          <version>${log4j2.version}</version>
        </dependency>
        <dependency>
          <groupId>org.apache.logging.log4j</groupId>
          <artifactId>log4j-core</artifactId>
          <version>${log4j2.version}</version>
        </dependency>
        <!--4) web工程需要包含log4j-web,非web工程不需要-->
        <dependency>
          <groupId>org.apache.logging.log4j</groupId>
          <artifactId>log4j-web</artifactId>
          <version>${log4j2.version}</version>
          <scope>runtime</scope>
        </dependency>
        <!--5) 需要使用log4j2的AsyncLogger需要包含disruptor-->
        <dependency>
          <groupId>com.lmax</groupId>
          <artifactId>disruptor</artifactId>
          <version>${log4j2.disruptor.version}</version>
        </dependency>
    
      </dependencies>
    
    
      <build>
        <finalName>shiro01</finalName>
        <resources>
          <!--解决mybatis-generator-maven-plugin运行时没有将XxxMapper.xml文件放入target文件夹的问题-->
          <resource>
            <directory>src/main/java</directory>
            <includes>
              <include>**/*.xml</include>
            </includes>
          </resource>
          <!--解决mybatis-generator-maven-plugin运行时没有将jdbc.properites文件放入target文件夹的问题-->
          <resource>
            <directory>src/main/resources</directory>
            <includes>
              <include>*.properties</include>
              <include>*.xml</include>
              <include>*.ini</include>
            </includes>
          </resource>
        </resources>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
          <plugins>
            <!-- 编码和编译和JDK版本 -->
            <plugin>
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-compiler-plugin</artifactId>
              <version>${maven.compiler.plugin.version}</version>
              <configuration>
                <source>${maven.compiler.source}</source>
                <target>${maven.compiler.target}</target>
                <encoding>${project.build.sourceEncoding}</encoding>
              </configuration>
            </plugin>
    
    
            <plugin>
              <artifactId>maven-clean-plugin</artifactId>
              <version>3.1.0</version>
            </plugin>
            <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
            <plugin>
              <artifactId>maven-resources-plugin</artifactId>
              <version>3.0.2</version>
            </plugin>
            <plugin>
              <artifactId>maven-compiler-plugin</artifactId>
              <version>3.8.0</version>
            </plugin>
            <plugin>
              <artifactId>maven-surefire-plugin</artifactId>
              <version>2.22.1</version>
            </plugin>
            <plugin>
              <artifactId>maven-war-plugin</artifactId>
              <version>3.2.2</version>
            </plugin>
            <plugin>
              <artifactId>maven-install-plugin</artifactId>
              <version>2.5.2</version>
            </plugin>
            <plugin>
              <artifactId>maven-deploy-plugin</artifactId>
              <version>2.8.2</version>
            </plugin>
          </plugins>
        </pluginManagement>
      </build>
    
    </project>
    
    

    shiro.ini

    		[users]
    		zs=123
    		ls=456
    		ww=789
    

    Shiro的认证初体验:

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

    Demo01.java

    package com.dj.shiro;
    
    import org.apache.shiro.SecurityUtils;
    import org.apache.shiro.authc.UsernamePasswordToken;
    import org.apache.shiro.config.IniSecurityManagerFactory;
    import org.apache.shiro.mgt.SecurityManager;
    import org.apache.shiro.subject.Subject;
    
    /**
     * @author dj
     * @company xxx公司
     * @create 2019- 10 - 12 - 20:18
     */
    public class Demo1 {
        public static void main(String[] args) {
            /**
             * Shiro的认证初体验:
             * 1、读取ini数据源文件,得到安全管理工厂securityManagerFactory
             * 2、获取安全管理器securityManager
             * 3、将安全管理器securityManager交给工具类securityutil进行管理
             * 4、通过securityutil获取登入用户主体subject
             * 5、创建登入令牌token
             * 6、利用主体subject进行登入
             * 7、处理登陆结果(登陆成功? 登陆失败?)
             */
    
            //获得安全管理工厂
            IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro.ini");
    
            //获得安全管理器
            SecurityManager securityManager = factory.getInstance();
    
            //将安全管理器securityManager交给工具类securityutil进行管理
            SecurityUtils.setSecurityManager(securityManager);
    
            //通过securityutil获取登入用户主体subject
            Subject subject = SecurityUtils.getSubject();
    
            //模拟接收到了从前端jsp传递过来的用户名密码完成登陆操作
            String uname = "zs";
            String pwd = "123";
    
            //创建登入令牌token
            UsernamePasswordToken token = new UsernamePasswordToken(uname,pwd);
    
            try {
                //利用主体subject进行登录
                subject.login(token);
    
                System.out.println("登陆成功!!!");
            }catch (Exception e){
                System.out.println("登陆失败处理!!!!!!");
            }
    
            subject.logout();
            System.out.println("登出成功!!");
    
        }
    }
    
    

    Shiro 与 web 容器的集成

    预先准备好的 jsp 界面:(如图)
    在这里插入图片描述

    集成测试步骤:

    1、准备一个shiro-web.ini文件
    2、通过web.xml将shiro与web容器进行集成
    3、编写servlet
    4、测试

    shiro-web.ini

    			[main]
    			#定义身份认证失败后的请求url映射,loginUrl是身份认证过滤器中的一个属性
    			authc.loginUrl=/login
    			#定义角色认证失败后的请求url映射,unauthorizedUrl是角色认证过滤器中的一个属性
    			roles.unauthorizedUrl=/unauthorized.jsp
    			#定义权限认证失败后请求url映射,unauthorizedUrl是角色认证过滤器中的一个属性
    			perms.unauthorizedUrl=/unauthorized.jsp
    			
    			[users]
    			zs=123,role1
    			ls=123,role2
    			ww=123,role3
    			zdm=123,admin
    			
    			
    			[roles]
    			role1=user:create
    			role2=user:create,user:update
    			role3=user:create,user:update,user:delete,user:view,user:load
    			admin=user:*
    			
    			
    			
    			#定义请求的地址需要做什么验证
    			[urls]
    			#请求login的时候不需要权限,游客身份即可(anon)
    			/login.do=anon
    			
    			#请求/user/updatePwd.jsp的时候,需要身份认证(authc)
    			/user/updatePwd.jsp=authc
    			
    			#请求/admin的时候,需要角色认证,必须是拥有admin角色的用户才行
    			/admin/*.jsp=roles[admin]
    			
    			#请求/teacher的时候,需要权限认证,必须是拥有user:create权限的角色的用户才行
    			/user/teacher.jsp=perms["user:update"]
    

    Web.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
             version="3.1">
      <display-name>Archetype Created Web Application</display-name>
      <context-param>
        <param-name>shiroConfigLocations</param-name>
        <param-value>classpath:shiro-web.ini</param-value>
      </context-param>
    <!-- 监听器 -->
      <listener>
        <!--  监听数据源  -->
        <listener-class>org.apache.shiro.web.env.EnvironmentLoaderListener</listener-class>
      </listener>
    
      <filter>
        <filter-name>ShiroFilter</filter-name>
        <filter-class>org.apache.shiro.web.servlet.ShiroFilter</filter-class>
      </filter>
      <filter-mapping>
        <filter-name>ShiroFilter</filter-name>
        <url-pattern>/*</url-pattern>
      </filter-mapping>
    
    </web-app>
    
    

    LoginServlet.java

    package com.dj.shiro;
    
    import org.apache.shiro.SecurityUtils;
    import org.apache.shiro.authc.UsernamePasswordToken;
    import org.apache.shiro.subject.Subject;
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    /**
     * @author dj
     * @company xxx公司
     * @create 2019- 10 - 12 - 20:50
     */
    @WebServlet("/login")
    public class LoginServlet extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doPost(req,resp);
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            String username = req.getParameter("username");
            String password = req.getParameter("password");
            //token 令牌
            UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(username, password);
            Subject subject = SecurityUtils.getSubject();
            try {
                subject.login(usernamePasswordToken);
                req.getRequestDispatcher("main.jsp").forward(req, resp);
            } catch (Exception e) {
                req.setAttribute("message", "您的用户名密码输入有误!!!");
                req.getRequestDispatcher("login.jsp").forward(req, resp);
            }
        }
    }
    
    

    LogoutServlet.java

    package com.dj.shiro;
    
    import org.apache.shiro.SecurityUtils;
    import org.apache.shiro.subject.Subject;
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    /**
     * @author dj
     * @company xxx公司
     * @create 2019- 10 - 12 - 20:55
     */
    @WebServlet("/logout")
    public class LogoutServlet extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doPost(req, resp);
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            Subject subject = SecurityUtils.getSubject();
            subject.logout();
            resp.sendRedirect(req.getContextPath()+"/login.jsp");
        }
    }
    
    

    导入前面准备好的jsp页面进行测试
    测试一下几点:
    1、身份认证成功与失败的结果
    2、角色认证成功与失败的结果
    3、权限认证成功与失败的结果

    效果:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • Shiro入门

    2020-10-22 23:50:36
    Shiro入门前言Shiro简介Shiro的优点Shiro比较重要的几个点为什么要使用Shiro在应用程序中如何使用ShiroShiro入门案例总结 前言 今天为大家分享的是Shiro的相关知识,一起来看看趴~ Shiro简介 shiro是apache的一个...

    前言

    今天为大家分享的是Shiro的相关知识,一起来看看趴~

    Shiro简介

    shiro是apache的一个开源框架,是一个权限管理的框架,实现用户认证、用户授权。

    Shiro的优点

    • spring中有spring security (原名Acegi),是一个权限框架,它和spring依赖过于紧密,没有shiro使用简单

    • shiro不依赖于spring,shiro不仅可以实现 web应用的权限管理,还可以实现c/s系统

    • 分布式系统权限管理,shiro属于轻量框架,越来越多企业项目开始使用shiro。

    Shiro比较重要的几个点

    认证

    授权

    Session Manager session管理

    Cache Manager 缓存管理

    为什么要使用Shiro

    因为Shiro的安全性高,这一点离不开Shiro中的SecurityManager(安全管理器)!并且Shiro能够支持多种语言!

    在这里插入图片描述

    在应用程序中如何使用Shiro

    如图所示

    在这里插入图片描述
    其中最重要的就是这三个

    概念名称 作用
    Subject 主体
    SecurityManager 安全管理器 (实际的执行者!
    Realm 域(Realm用来获取数据库的数据

    当然,我们也可以把Shiro中的Subject看作是一个用户,也可以是一个抽象的概念!

    而SecurityManager安全管理器,能够提高我们使用的应用程序的安全性!

    就是说SecurityManager要验证用户身份,那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法;

    也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作;可以把Realm看成DataSource,安全数据源。

    三者之中,Realm起到了存储数据库数据的作用!

    Shiro入门案例

    导入pom依赖

    <?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>
      <groupId>com.wangqiuping</groupId>
      <artifactId>Shiro01</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>war</packaging>
    
      <name>shiro Maven Webapp</name>
      <!-- FIXME change it to the project's website -->
      <url>http://www.example.com</url>
    
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
        <maven.compiler.plugin.version>3.7.0</maven.compiler.plugin.version>
    
    
        <!-- 添加相关依赖 -->
        <junit.version>4.12</junit.version>
        <servlet.version>4.0.0</servlet.version>
        <log4j2.version>2.9.1</log4j2.version>
        <slf4j.version>1.7.7</slf4j.version>
        <log4j2.disruptor.version>3.2.0</log4j2.disruptor.version>
        <shiro.version>1.2.5</shiro.version>
      </properties>
    
      <dependencies>
        <!-- shiro核心包 -->
        <dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-core</artifactId>
          <version>${shiro.version}</version>
        </dependency>
        <!-- 添加shiro web支持 -->
        <dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-web</artifactId>
          <version>${shiro.version}</version>
        </dependency>
        <!--**********junit**********-->
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>${junit.version}</version>
          <scope>test</scope>
        </dependency>
        <!--**********servlet**********-->
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>${servlet.version}</version>
          <scope>provided</scope>
        </dependency>
        <!-- **********************  日志配置  ********************** -->
        <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>slf4j-api</artifactId>
          <version>${slf4j.version}</version>
        </dependency>
        <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>jcl-over-slf4j</artifactId>
          <version>${slf4j.version}</version>
          <scope>runtime</scope>
          <exclusions>
            <exclusion>
              <artifactId>slf4j-api</artifactId>
              <groupId>org.slf4j</groupId>
            </exclusion>
          </exclusions>
        </dependency>
        <!--2) 用于与slf4j保持桥接-->
        <dependency>
          <groupId>org.apache.logging.log4j</groupId>
          <artifactId>log4j-slf4j-impl</artifactId>
          <version>${log4j2.version}</version>
          <exclusions>
            <exclusion>
              <artifactId>slf4j-api</artifactId>
              <groupId>org.slf4j</groupId>
            </exclusion>
          </exclusions>
        </dependency>
        <!--3) 核心log4j2jar包-->
        <dependency>
          <groupId>org.apache.logging.log4j</groupId>
          <artifactId>log4j-api</artifactId>
          <version>${log4j2.version}</version>
        </dependency>
        <dependency>
          <groupId>org.apache.logging.log4j</groupId>
          <artifactId>log4j-core</artifactId>
          <version>${log4j2.version}</version>
        </dependency>
        <!--4) web工程需要包含log4j-web,非web工程不需要-->
        <dependency>
          <groupId>org.apache.logging.log4j</groupId>
          <artifactId>log4j-web</artifactId>
          <version>${log4j2.version}</version>
          <scope>runtime</scope>
        </dependency>
        <!--5) 需要使用log4j2的AsyncLogger需要包含disruptor-->
        <dependency>
          <groupId>com.lmax</groupId>
          <artifactId>disruptor</artifactId>
          <version>${log4j2.disruptor.version}</version>
        </dependency>
      </dependencies>
    
      <build>
        <finalName>Shiro01</finalName>
        <resources>
          <!--解决mybatis-generator-maven-plugin运行时没有将XxxMapper.xml文件放入target文件夹的问题-->
          <resource>
            <directory>src/main/java</directory>
            <includes>
              <include>**/*.xml</include>
            </includes>
          </resource>
          <!--解决mybatis-generator-maven-plugin运行时没有将jdbc.properites文件放入target文件夹的问题-->
          <resource>
            <directory>src/main/resources</directory>
            <includes>
              <include>*.properties</include>
              <include>*.xml</include>
              <include>*.ini</include>
            </includes>
          </resource>
        </resources>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
          <plugins>
            <!-- 编码和编译和JDK版本 -->
            <plugin>
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-compiler-plugin</artifactId>
              <version>${maven.compiler.plugin.version}</version>
              <configuration>
                <source>${maven.compiler.source}</source>
                <target>${maven.compiler.target}</target>
                <encoding>${project.build.sourceEncoding}</encoding>
              </configuration>
            </plugin>
          </plugins>
        </pluginManagement>
      </build>
    </project>
    

    导入依赖之后记得先run maven test一下,测试项目能够正常运行起来再继续下一步操作!

    导入log4j2.xml文件

    方便查看打印的日志信息

    <?xml version="1.0" encoding="UTF-8"?>
    
    <!-- status : 指定log4j本身的打印日志的级别.ALL< Trace < DEBUG < INFO < WARN < ERROR 
    	< FATAL < OFF。 monitorInterval : 用于指定log4j自动重新配置的监测间隔时间,单位是s,最小是5s. -->
    <Configuration status="WARN" monitorInterval="30">
        <Properties>
            <!--window配置-->
            <!--配置日志文件输出目录 ${sys:user.home}-->
            <Property name="LOG_HOME">${sys:user.home}/logs</Property>
            <property name="ERROR_LOG_FILE_NAME">${sys:user.home}/logs/error</property>
            <property name="WARN_LOG_FILE_NAME">${sys:user.home}/logs/warn</property>
    
            <!--linux ubuntu配置-->
            <!--请在操作系统中配置环境变量catalina_home-->
            <!--<Property name="LOG_HOME">${catalina_home}/logs</Property>-->
            <!--<property name="ERROR_LOG_FILE_NAME">${catalina_home}/logs/error</property>-->
            <!--<property name="WARN_LOG_FILE_NAME">${catalina_home}/logs/warn</property>-->
    
            <!--配置日志格式-->
            <property name="PATTERN">%d{yyyy-MM-dd HH:mm:ss.SSS} [%t-%L] %-5level %logger{36} - %msg%n</property>
            <!--<property name="PATTERN">%n  Level: %p%n   Time: %d%n Method: %l%nMessage: %m%n</property>-->
        </Properties>
    
        <Appenders>
            <!--这个输出控制台的配置 -->
            <Console name="Console" target="SYSTEM_OUT">
                <!-- 控制台只输出level及以上级别的信息(onMatch),其他的直接拒绝(onMismatch) -->
                <ThresholdFilter level="trace" onMatch="ACCEPT"
                                 onMismatch="DENY"/>
                <!-- 输出日志的格式 -->
                <!-- %d{yyyy-MM-dd HH:mm:ss, SSS} : 日志生产时间 %p : 日志输出格式 %c : logger的名称
                    %m : 日志内容,即 logger.info("message") %n : 换行符 %C : Java类名 %L : 日志输出所在行数 %M
                    : 日志输出所在方法名 hostName : 本地机器名 hostAddress : 本地ip地址 -->
                <PatternLayout pattern="${PATTERN}"/>
            </Console>
    
            <!--文件会打印出所有信息,这个log每次运行程序会自动清空,由append属性决定,这个也挺有用的,适合临时测试用 -->
            <!--append为TRUE表示消息增加到指定文件中,false表示消息覆盖指定的文件内容,默认值是true -->
            <File name="log" fileName="logs/test.log" append="false">
                <PatternLayout
                        pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
            </File>
            <!-- 这个会打印出所有的info及以下级别的信息,每次大小超过size, 则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩,作为存档 -->
            <RollingFile name="RollingFileInfo" fileName="${LOG_HOME}/info.log"
                         filePattern="${LOG_HOME}/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log">
                <!--控制台只输出level及以上级别的信息(onMatch),其他的直接拒绝(onMismatch) -->
                <ThresholdFilter level="info" onMatch="ACCEPT"
                                 onMismatch="DENY"/>
                <PatternLayout
                        pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
                <Policies>
                    <!-- 基于时间的滚动策略,interval属性用来指定多久滚动一次,默认是1 hour。 modulate=true用来调整时间:比如现在是早上3am,interval是4,那么第一次滚动是在4am,接着是8am,12am...而不是7am. -->
                    <!-- 关键点在于 filePattern后的日期格式,以及TimeBasedTriggeringPolicy的interval, 日期格式精确到哪一位,interval也精确到哪一个单位 -->
                    <!-- log4j2的按天分日志文件 : info-%d{yyyy-MM-dd}-%i.log -->
                    <TimeBasedTriggeringPolicy interval="1"
                                               modulate="true"/>
                    <!-- SizeBasedTriggeringPolicy:Policies子节点, 基于指定文件大小的滚动策略,size属性用来定义每个日志文件的大小. -->
                    <!-- <SizeBasedTriggeringPolicy size="2 kB" /> -->
                </Policies>
            </RollingFile>
    
            <RollingFile name="RollingFileWarn" fileName="${WARN_LOG_FILE_NAME}/warn.log"
                         filePattern="${WARN_LOG_FILE_NAME}/$${date:yyyy-MM}/warn-%d{yyyy-MM-dd}-%i.log">
                <ThresholdFilter level="warn" onMatch="ACCEPT"
                                 onMismatch="DENY"/>
                <PatternLayout
                        pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
                <Policies>
                    <TimeBasedTriggeringPolicy/>
                    <SizeBasedTriggeringPolicy size="2 kB"/>
                </Policies>
                <!-- DefaultRolloverStrategy属性如不设置,则默认为最多同一文件夹下7个文件,这里设置了20 -->
                <DefaultRolloverStrategy max="20"/>
            </RollingFile>
    
            <RollingFile name="RollingFileError" fileName="${ERROR_LOG_FILE_NAME}/error.log"
                         filePattern="${ERROR_LOG_FILE_NAME}/$${date:yyyy-MM}/error-%d{yyyy-MM-dd-HH-mm}-%i.log">
                <ThresholdFilter level="error" onMatch="ACCEPT"
                                 onMismatch="DENY"/>
                <PatternLayout
                        pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
                <Policies>
                    <!-- log4j2的按分钟 分日志文件 : warn-%d{yyyy-MM-dd-HH-mm}-%i.log -->
                    <TimeBasedTriggeringPolicy interval="1"
                                               modulate="true"/>
                    <!-- <SizeBasedTriggeringPolicy size="10 MB" /> -->
                </Policies>
            </RollingFile>
    
        </Appenders>
    
        <!--然后定义logger,只有定义了logger并引入的appender,appender才会生效 -->
        <Loggers>
            <!-- 第三方日志系统 -->
            <!--过滤掉spring和mybatis的一些无用的DEBUG信息 -->
            <logger name="org.springframework" level="ERROR"></logger>
            <logger name="org.mybatis" level="ERROR"></logger>
            <logger name="org.apache.ibatis" level="ERROR"></logger>
            <logger name="net.sf" level="ERROR"/>
            <logger name="org.jboss" level="ERROR"/>
            <logger name="org.apache.shiro" level="ERROR"/>
    
    
            <!-- 配置日志的根节点 -->
            <root level="all">
                <appender-ref ref="Console"/>
                <!--<appender-ref ref="RollingFileInfo" />-->
                <!--<appender-ref ref="RollingFileWarn" />-->
                <!--<appender-ref ref="RollingFileError" />-->
            </root>
        </Loggers>
    </Configuration>
    

    在resources目录下新建shiro.ini文件
    ini文件就相当于Realm

    [users]
    zs=123
    ls=456
    ww=789
    

    shiro的英文学习文档

    shiro的中文学习文档

    编写测试类

    package com.wangqiuping;
    
    import org.apache.shiro.SecurityUtils;
    import org.apache.shiro.authc.UsernamePasswordToken;
    import org.apache.shiro.config.IniSecurityManagerFactory;
    import org.apache.shiro.mgt.SecurityManager;
    import org.apache.shiro.subject.Subject;
    import java.util.Map;
    
    /**
     * @author sunnyWang
     * @site 公司的网址
     * @company xxx公司
     * @create  2020-10-22 23:08
     */
    public class Demo {
        public static void main(String[] args){
            /**
             * 1、获取到安全管理器工厂securityManager
             * 2、回去到安全管理器
             * 3、将安全管理器交给securityutil工具类
             * 4、从securityutil中获取subject
             * 5、通过subject主体做登录
             * 6、处理登录结果(登录成功?登录失败)
             */
    
            //首先实例化一个ini的子类  也就是ini的安全管理器工厂
            IniSecurityManagerFactory factory=new IniSecurityManagerFactory("classpath:shiro.ini");
            SecurityManager securityManager = factory.getInstance();//获取到安全管理器
            SecurityUtils.setSecurityManager(securityManager);
            Subject subject = SecurityUtils.getSubject();
            //模拟接收到了jsp从前端jsp传递过来的用户密码去完成登录操作
            String  uname="zs";
            String  upwd="1234";
            UsernamePasswordToken token=new UsernamePasswordToken(uname,upwd);
            try{
                //如果登录成功
                subject.login(token);//方法里面放令牌
                System.out.println("恭喜你登录成功!");
            }catch(Exception e){
                //否则登录失败
                System.out.println("您已登录失败,请重新登录!!");
            }
            subject.logout();//退出系统的操作
            System.out.println("退出系统成功!");
    
    
        }
    }
    
    

    登录成功

    在这里插入图片描述

    登录失败

    Submitted credentials for token [org.apache.shiro.authc.UsernamePasswordToken - zs, rememberMe=false] did not match the expected credentials.

    在这里插入图片描述

    提交的凭证,也就是用户信息和ini中的信息不一致,所以才会登录失败!

    将登录的结果放在try catch 捕捉异常中进行处理,就能看到该提示!

    在这里插入图片描述

    登录失败退出系统

    subject.logout();//退出系统的操作
    

    在这里插入图片描述

    总结

    Shiro入门的基本知识点就分享到这了,拜拜~

    展开全文
  • shiro入门

    2019-10-12 20:59:34
    shiro入门简介什么是shiro在应用程序角度来观察如何使用Shiro完成工作shiro架构入门案例Shiro与web容器的集成 简介 什么是shiro shiro是apache的一个开源框架,是一个权限管理的框架,实现 用户认证、用户授权。 ...

    简介

    什么是shiro

    shiro是apache的一个开源框架,是一个权限管理的框架,实现 用户认证、用户授权。
    spring中有spring security (原名Acegi),是一个权限框架,它和spring依赖过于紧密,没有shiro使用简单。
    shiro不依赖于spring,shiro不仅可以实现 web应用的权限管理,还可以实现c/s系统,
    分布式系统权限管理,shiro属于轻量框架,越来越多企业项目开始使用shiro。

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

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

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

    Realm:域,Shiro从从Realm获取安全数据(如用户、角色、权限),就是说SecurityManager要验证用户身份,那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法;也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作;可以把Realm看成DataSource,即安全数据源。
    在这里插入图片描述

    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只有加密没有解密)。

    在这里插入图片描述

    入门案例

    log4j2.xml

    <?xml version="1.0" encoding="UTF-8"?>
    
    <!-- status : 指定log4j本身的打印日志的级别.ALL< Trace < DEBUG < INFO < WARN < ERROR
       < FATAL < OFF。 monitorInterval : 用于指定log4j自动重新配置的监测间隔时间,单位是s,最小是5s. -->
    <Configuration status="WARN" monitorInterval="30">
        <Properties>
            <!--window配置-->
            <!--配置日志文件输出目录 ${sys:user.home}-->
            <Property name="LOG_HOME">${sys:user.home}/logs</Property>
            <property name="ERROR_LOG_FILE_NAME">${sys:user.home}/logs/error</property>
            <property name="WARN_LOG_FILE_NAME">${sys:user.home}/logs/warn</property>
    
            <!--linux ubuntu配置-->
            <!--请在操作系统中配置环境变量catalina_home-->
            <!--<Property name="LOG_HOME">${catalina_home}/logs</Property>-->
            <!--<property name="ERROR_LOG_FILE_NAME">${catalina_home}/logs/error</property>-->
            <!--<property name="WARN_LOG_FILE_NAME">${catalina_home}/logs/warn</property>-->
    
            <!--配置日志格式-->
            <property name="PATTERN">%d{yyyy-MM-dd HH:mm:ss.SSS} [%t-%L] %-5level %logger{36} - %msg%n</property>
            <!--<property name="PATTERN">%n  Level: %p%n   Time: %d%n Method: %l%nMessage: %m%n</property>-->
        </Properties>
    
        <Appenders>
            <!--这个输出控制台的配置 -->
            <Console name="Console" target="SYSTEM_OUT">
                <!-- 控制台只输出level及以上级别的信息(onMatch),其他的直接拒绝(onMismatch) -->
                <ThresholdFilter level="trace" onMatch="ACCEPT"
                                 onMismatch="DENY"/>
                <!-- 输出日志的格式 -->
                <!-- %d{yyyy-MM-dd HH:mm:ss, SSS} : 日志生产时间 %p : 日志输出格式 %c : logger的名称
                    %m : 日志内容,即 logger.info("message") %n : 换行符 %C : Java类名 %L : 日志输出所在行数 %M
                    : 日志输出所在方法名 hostName : 本地机器名 hostAddress : 本地ip地址 -->
                <PatternLayout pattern="${PATTERN}"/>
            </Console>
    
            <!--文件会打印出所有信息,这个log每次运行程序会自动清空,由append属性决定,这个也挺有用的,适合临时测试用 -->
            <!--append为TRUE表示消息增加到指定文件中,false表示消息覆盖指定的文件内容,默认值是true -->
            <File name="log" fileName="logs/test.log" append="false">
                <PatternLayout
                        pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
            </File>
            <!-- 这个会打印出所有的info及以下级别的信息,每次大小超过size, 则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩,作为存档 -->
            <RollingFile name="RollingFileInfo" fileName="${LOG_HOME}/info.log"
                         filePattern="${LOG_HOME}/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log">
                <!--控制台只输出level及以上级别的信息(onMatch),其他的直接拒绝(onMismatch) -->
                <ThresholdFilter level="info" onMatch="ACCEPT"
                                 onMismatch="DENY"/>
                <PatternLayout
                        pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
                <Policies>
                    <!-- 基于时间的滚动策略,interval属性用来指定多久滚动一次,默认是1 hour。 modulate=true用来调整时间:比如现在是早上3am,interval是4,那么第一次滚动是在4am,接着是8am,12am...而不是7am. -->
                    <!-- 关键点在于 filePattern后的日期格式,以及TimeBasedTriggeringPolicy的interval, 日期格式精确到哪一位,interval也精确到哪一个单位 -->
                    <!-- log4j2的按天分日志文件 : info-%d{yyyy-MM-dd}-%i.log -->
                    <TimeBasedTriggeringPolicy interval="1"
                                               modulate="true"/>
                    <!-- SizeBasedTriggeringPolicy:Policies子节点, 基于指定文件大小的滚动策略,size属性用来定义每个日志文件的大小. -->
                    <!-- <SizeBasedTriggeringPolicy size="2 kB" /> -->
                </Policies>
            </RollingFile>
    
            <RollingFile name="RollingFileWarn" fileName="${WARN_LOG_FILE_NAME}/warn.log"
                         filePattern="${WARN_LOG_FILE_NAME}/$${date:yyyy-MM}/warn-%d{yyyy-MM-dd}-%i.log">
                <ThresholdFilter level="warn" onMatch="ACCEPT"
                                 onMismatch="DENY"/>
                <PatternLayout
                        pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
                <Policies>
                    <TimeBasedTriggeringPolicy/>
                    <SizeBasedTriggeringPolicy size="2 kB"/>
                </Policies>
                <!-- DefaultRolloverStrategy属性如不设置,则默认为最多同一文件夹下7个文件,这里设置了20 -->
                <DefaultRolloverStrategy max="20"/>
            </RollingFile>
    
            <RollingFile name="RollingFileError" fileName="${ERROR_LOG_FILE_NAME}/error.log"
                         filePattern="${ERROR_LOG_FILE_NAME}/$${date:yyyy-MM}/error-%d{yyyy-MM-dd-HH-mm}-%i.log">
                <ThresholdFilter level="error" onMatch="ACCEPT"
                                 onMismatch="DENY"/>
                <PatternLayout
                        pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
                <Policies>
                    <!-- log4j2的按分钟 分日志文件 : warn-%d{yyyy-MM-dd-HH-mm}-%i.log -->
                    <TimeBasedTriggeringPolicy interval="1"
                                               modulate="true"/>
                    <!-- <SizeBasedTriggeringPolicy size="10 MB" /> -->
                </Policies>
            </RollingFile>
    
        </Appenders>
    
        <!--然后定义logger,只有定义了logger并引入的appender,appender才会生效 -->
        <Loggers>
            <!-- 第三方日志系统 -->
            <!--过滤掉spring和mybatis的一些无用的DEBUG信息 -->
            <logger name="org.springframework" level="ERROR"></logger>
            <logger name="org.mybatis" level="ERROR"></logger>
            <logger name="org.apache.ibatis" level="ERROR"></logger>
            <logger name="net.sf" level="ERROR"/>
            <logger name="org.jboss" level="ERROR"/>
            <logger name="org.apache.shiro" level="ERROR"/>
    
    
            <!-- 配置日志的根节点 -->
            <root level="all">
                <appender-ref ref="Console"/>
                <!--<appender-ref ref="RollingFileInfo" />-->
                <!--<appender-ref ref="RollingFileWarn" />-->
                <!--<appender-ref ref="RollingFileError" />-->
            </root>
        </Loggers>
    
    </Configuration>
    
    
    

    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>
    
      <groupId>com.shl</groupId>
      <artifactId>shiro01</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>war</packaging>
    
      <name>shiro01 Maven Webapp</name>
      <!-- FIXME change it to the project's website -->
      <url>http://www.example.com</url>
    
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
        <maven.compiler.plugin.version>3.7.0</maven.compiler.plugin.version>
    
        <!-- 添加相关依赖 -->
        <junit.version>4.12</junit.version>
        <servlet.version>4.0.0</servlet.version>
        <log4j2.version>2.9.1</log4j2.version>
        <slf4j.version>1.7.7</slf4j.version>
        <log4j2.disruptor.version>3.2.0</log4j2.disruptor.version>
    
        <shiro.version>1.2.5</shiro.version>
      </properties>
    
    
      <dependencies>
        <!-- shiro核心包 -->
        <dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-core</artifactId>
          <version>${shiro.version}</version>
        </dependency>
        <!-- 添加shiro web支持 -->
        <dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-web</artifactId>
          <version>${shiro.version}</version>
        </dependency>
        <!--**********junit**********-->
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>${junit.version}</version>
          <scope>test</scope>
        </dependency>
        <!--**********servlet**********-->
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>${servlet.version}</version>
          <scope>provided</scope>
        </dependency>
        <!-- **********************  日志配置  ********************** -->
        <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>slf4j-api</artifactId>
          <version>${slf4j.version}</version>
        </dependency>
        <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>jcl-over-slf4j</artifactId>
          <version>${slf4j.version}</version>
          <scope>runtime</scope>
          <exclusions>
            <exclusion>
              <artifactId>slf4j-api</artifactId>
              <groupId>org.slf4j</groupId>
            </exclusion>
          </exclusions>
        </dependency>
        <!--2) 用于与slf4j保持桥接-->
        <dependency>
          <groupId>org.apache.logging.log4j</groupId>
          <artifactId>log4j-slf4j-impl</artifactId>
          <version>${log4j2.version}</version>
          <exclusions>
            <exclusion>
              <artifactId>slf4j-api</artifactId>
              <groupId>org.slf4j</groupId>
            </exclusion>
          </exclusions>
        </dependency>
        <!--3) 核心log4j2jar包-->
        <dependency>
          <groupId>org.apache.logging.log4j</groupId>
          <artifactId>log4j-api</artifactId>
          <version>${log4j2.version}</version>
        </dependency>
        <dependency>
          <groupId>org.apache.logging.log4j</groupId>
          <artifactId>log4j-core</artifactId>
          <version>${log4j2.version}</version>
        </dependency>
        <!--4) web工程需要包含log4j-web,非web工程不需要-->
        <dependency>
          <groupId>org.apache.logging.log4j</groupId>
          <artifactId>log4j-web</artifactId>
          <version>${log4j2.version}</version>
          <scope>runtime</scope>
        </dependency>
        <!--5) 需要使用log4j2的AsyncLogger需要包含disruptor-->
        <dependency>
          <groupId>com.lmax</groupId>
          <artifactId>disruptor</artifactId>
          <version>${log4j2.disruptor.version}</version>
        </dependency>
    
      </dependencies>
    
    
      <build>
        <finalName>shiro01</finalName>
        <resources>
          <!--解决mybatis-generator-maven-plugin运行时没有将XxxMapper.xml文件放入target文件夹的问题-->
          <resource>
            <directory>src/main/java</directory>
            <includes>
              <include>**/*.xml</include>
            </includes>
          </resource>
          <!--解决mybatis-generator-maven-plugin运行时没有将jdbc.properites文件放入target文件夹的问题-->
          <resource>
            <directory>src/main/resources</directory>
            <includes>
              <include>*.properties</include>
              <include>*.xml</include>
              <include>*.ini</include>
            </includes>
          </resource>
        </resources>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
          <plugins>
            <!-- 编码和编译和JDK版本 -->
            <plugin>
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-compiler-plugin</artifactId>
              <version>${maven.compiler.plugin.version}</version>
              <configuration>
                <source>${maven.compiler.source}</source>
                <target>${maven.compiler.target}</target>
                <encoding>${project.build.sourceEncoding}</encoding>
              </configuration>
            </plugin>
    
    
            <plugin>
              <artifactId>maven-clean-plugin</artifactId>
              <version>3.1.0</version>
            </plugin>
            <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
            <plugin>
              <artifactId>maven-resources-plugin</artifactId>
              <version>3.0.2</version>
            </plugin>
            <plugin>
              <artifactId>maven-compiler-plugin</artifactId>
              <version>3.8.0</version>
            </plugin>
            <plugin>
              <artifactId>maven-surefire-plugin</artifactId>
              <version>2.22.1</version>
            </plugin>
            <plugin>
              <artifactId>maven-war-plugin</artifactId>
              <version>3.2.2</version>
            </plugin>
            <plugin>
              <artifactId>maven-install-plugin</artifactId>
              <version>2.5.2</version>
            </plugin>
            <plugin>
              <artifactId>maven-deploy-plugin</artifactId>
              <version>2.8.2</version>
            </plugin>
          </plugins>
        </pluginManagement>
      </build>
    
    </project>
    
    

    shiro.ini

    [users]
    zs=123
    ls=456
    ww=789
    
    

    Demo1

    package com.shl.shiro;
    
    import org.apache.shiro.SecurityUtils;
    import org.apache.shiro.authc.UsernamePasswordToken;
    import org.apache.shiro.config.IniSecurityManagerFactory;
    import org.apache.shiro.mgt.SecurityManager;
    import org.apache.shiro.subject.Subject;
    
    /**
     * @author 狗蛋
     * @create 2019-10-12-20:11
     */
    public class Demo1 {
        public static void main(String[] args) {
            /*
            * 1.获取到安全管理器工厂
            * 2.获取到安全管理器
            * 3.将安全管理器交给securityutil工具类
            * 4.从securityutil中获取subject
            * 5.通过subject主体登入
            * 6.处理登录结果
            * */
            IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro.ini");
            SecurityManager securityManager = factory.getInstance();
            SecurityUtils.setSecurityManager(securityManager);
            Subject subject = SecurityUtils.getSubject();
            //模拟接收到了jsp传递过来的用户密码完成登录
            String uname = "zs";
            String pwd = "123";
            UsernamePasswordToken token = new UsernamePasswordToken(uname,pwd);
            try {
                subject.login(token);
                System.out.println("登录成功");
            }catch (Exception e){
                System.out.println("登录失败");
            }
            subject.logout();
            System.out.println("退出系统");
    
    
        }
    }
    
    

    在这里插入图片描述

    Shiro与web容器的集成

    shiro-web.ini

    [main]
    #定义身份认证失败后的请求url映射,loginUrl是身份认证过滤器中的一个属性
    authc.loginUrl=/login
    #定义角色认证失败后的请求url映射,unauthorizedUrl是角色认证过滤器中的一个属性
    roles.unauthorizedUrl=/unauthorized.jsp
    #定义权限认证失败后请求url映射,unauthorizedUrl是角色认证过滤器中的一个属性
    perms.unauthorizedUrl=/unauthorized.jsp
    
    [users]
    zs=123,role1
    ls=123,role2
    ww=123,role3
    zdm=123,admin
    
    
    [roles]
    role1=user:create
    role2=user:create,user:update
    role3=user:create,user:update,user:delete,user:view,user:load
    admin=user:*
    
    
    
    #定义请求的地址需要做什么验证
    [urls]
    #请求login的时候不需要权限,游客身份即可(anon)
    /login.do=anon
    
    #请求/user/updatePwd.jsp的时候,需要身份认证(authc)
    /user/updatePwd.jsp=authc
    
    #请求/admin的时候,需要角色认证,必须是拥有admin角色的用户才行
    /admin/*.jsp=roles[admin]
    
    #请求/teacher的时候,需要权限认证,必须是拥有user:create权限的角色的用户才行
    /user/teacher.jsp=perms["user:update"]
    
    
    

    Web.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
             version="3.1">
      <display-name>Archetype Created Web Application</display-name>
      <context-param>
        <param-name>shiroConfigLocations</param-name>
        <param-value>classpath:shiro-web.ini</param-value>
      </context-param>
      <listener>
        <listener-class>org.apache.shiro.web.env.EnvironmentLoaderListener</listener-class>
      </listener>
    
      <filter>
        <filter-name>ShiroFilter</filter-name>
        <filter-class>org.apache.shiro.web.servlet.ShiroFilter</filter-class>
      </filter>
      <filter-mapping>
        <filter-name>ShiroFilter</filter-name>
        <url-pattern>/*</url-pattern>
      </filter-mapping>
    
    </web-app>
    
    
    

    LoginServlet

    package com.shl.shiro;
    
    import org.apache.shiro.SecurityUtils;
    import org.apache.shiro.authc.UsernamePasswordToken;
    import org.apache.shiro.subject.Subject;
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    /**
     * @author 狗蛋
     * @create 2019-10-12-20:37
     */
    @WebServlet("/login")
    public class LoginServlet extends HttpServlet {
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doPost(req,resp);
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            Subject subject = SecurityUtils.getSubject();
            String uname = req.getParameter("username");
            String pwd = req.getParameter("password");
            UsernamePasswordToken token = new UsernamePasswordToken(uname,pwd);
            try {
                subject.login(token);
                req.getRequestDispatcher("main.jsp").forward(req,resp);
            }catch (Exception e){
                req.setAttribute("message","用户名或者密码错误");
                req.getRequestDispatcher("login.jsp").forward(req,resp);
    
            }
        }
    }
    
    

    LogoutServlet

    package com.shl.shiro;
    
    import org.apache.shiro.SecurityUtils;
    import org.apache.shiro.subject.Subject;
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    /**
     * @author 狗蛋
     * @create 2019-10-12-20:37
     */
    @WebServlet("/logout")
    public class LogoutServlet extends HttpServlet {
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doPost(req,resp);
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            Subject subject = SecurityUtils.getSubject();
            subject.logout();
            resp.sendRedirect("login.jsp");
        }
    }
    
    

    main.jsp

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <%@taglib prefix="r" uri="http://shiro.apache.org/tags" %>
    <html>
    <head>
        <title>Title</title>
    </head>
    <body>
    <h1>主界面<%=System.currentTimeMillis()%>,欢迎您:[${sessionScope.username}]</h1>
    <ul>
        系统功能列表
        <li>
            <a href="admin/addUser.jsp">用户新增</a>
        </li>
        <li>
            <a href="admin/listUser.jsp">用户查询</a>
        </li>
        <li>
            <a href="admin/resetPwd.jsp">重置用户密码</a>
        </li>
        <li>
            <a href="admin/updateUser.jsp">用户修改</a>
        </li>
        <li>
            <a href="user/updatePwd.jsp">个人密码修改</a>
        </li>
        <li>
            <a href="user/teacher.jsp">老师简介</a>
        </li>
        <li>
            <a href="${pageContext.request.contextPath}/logout">退出系统</a>
        </li>
    </ul>
    <ul>
        shiro标签
        <li>
    
            <r:hasPermission name="user:create">
                <a href="admin/addUser.jsp">用户新增</a>
            </r:hasPermission>
        </li>
        <li>
            <a href="admin/listUser.jsp">用户查询</a>
        </li>
        <li>
            <a href="admin/resetPwd.jsp">重置用户密码</a>
        </li>
        <li>
            <!-- 用户有这个权限才会有这个按钮 -->
            <r:hasPermission name="user:update">
                <a href="admin/updateUser.jsp">用户修改</a>
            </r:hasPermission>
        </li>
        <li>
            <a href="user/updatePwd.jsp">个人密码修改</a>
        </li>
        <li>
            <a href="${pageContext.request.contextPath}/logout">退出系统</a>
        </li>
    </ul>
    </body>
    </html>
    
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,367
精华内容 1,346
关键字:

shiro入门