Shiro

最新推荐文章于 2023-06-01 18:13:51 发布
最新推荐文章于 2023-06-01 18:13:51 发布
阅读量200 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hou_yi_tao/article/details/102882824
版权

Shiro简介

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

2. 在应用程序角度来观察如何使用Shiro完成工作(图01)
Subject：主体，代表了当前“用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是Subject，如网络爬虫，机器人等；即一个抽象概念；所有Subject 都绑定到SecurityManager，与Subject的所有交互都会委托给SecurityManager；可以把Subject认为是一个门面；SecurityManager才是实际的执行者；
SecurityManager：安全管理器；即所有与安全有关的操作都会与SecurityManager 交互；且它管理着所有Subject；可以看出它是Shiro 的核心，它负责与后边介绍的其他组件进行交互，如果学习过SpringMVC，你可以把它看成DispatcherServlet前端控制器；
Realm：域，Shiro从从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源。
在这里插入图片描述

  1. shiro架构(图02)
    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、导入相关依赖
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>
        <!-- 配置日志文件输出目录 ${sys:user.home} -->
        <Property name="LOG_HOME">/root/workspace/lucenedemo/logs</Property>
        <property name="ERROR_LOG_FILE_NAME">/root/workspace/lucenedemo/logs/error</property>
        <property name="WARN_LOG_FILE_NAME">/root/workspace/lucenedemo/logs/warn</property>
        <property name="PATTERN">%d{yyyy-MM-dd HH:mm:ss.SSS} [%t-%L] %-5level %logger{36} - %msg%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="INFO"></logger>
        <logger name="org.mybatis" level="INFO"></logger>

        <!-- 第三方日志系统 -->
        <logger name="org.springframework" level="ERROR" />
        <logger name="org.hibernate" level="ERROR" />
        <logger name="org.apache.struts2" level="ERROR" />
        <logger name="com.opensymphony.xwork2" level="ERROR" />
        <logger name="org.jboss" 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.houyitao</groupId>
  <artifactId>shiro</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>shiro</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

ShiroTest.java

package com.houyitao.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 HYT
 * @site www.hyt.com
 * @company 阿里巴巴
 * @create  2019-11-03 14:59
 */
public class Demo1 {

    public static void main(String[] args) {
        /*
            1、读取数据源
            2、获取安全管理器
            3、安全管理器交给securityutil进行管理
            4、从securityutil中获取subject登录主体
            5、获取jsp传递过来的用户名密然后形成一个token令牌
            6、登录操作
         */
        IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro.ini");
        SecurityManager securityManager = (SecurityManager) factory.getInstance();
        SecurityUtils.setSecurityManager(securityManager);
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken token = new UsernamePasswordToken("zs","123");
        subject.login(token);
        System.out.println("login success");
        subject.logout();
        System.out.println("logout success");

    }
    }

Shiro与web容器的集成
预先准备好的jsp
在这里插入图片描述

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

shiro-web.in

[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.houyitao.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 HYT
 * @site www.hyt.com
 * @company 阿里巴巴
 * @create  2019-11-03 15:08
 */
@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");
        UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(username, password);
        Subject subject = SecurityUtils.getSubject();
        try {
            subject.login(usernamePasswordToken);
            req.getRequestDispatcher("main.jsp").forward(req, resp);
            req.getSession().setAttribute("username",username);

        } catch (Exception e) {
            req.setAttribute("message", "您的用户名密码输入有误！！！");
            req.getRequestDispatcher("login.jsp").forward(req, resp);
        }
    }
}

LogoutServlet.java

package com.houyitao.shiro;

import javax.servlet.http.HttpServlet;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
 * @author HYT
 * @site www.hyt.com
 * @company 阿里巴巴
 * @create  2019-11-03 15:09
 */
    @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");
        }
}

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

hou_yi_tao
关注
shiro入门
trasewell的博客
09-25 931
目录： 1.pom.xml 2.applicationContext.xml 3.applicationContext-mybatis.xml 4.SpringBaseTest 5.优化分页 1.pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4...
shiro简介及入门
qq_44847231的博客
10-13 597
文章目录shiro简介1. 什么是shiro2. 在应用程序角度来观察如何使用Shiro完成工作3. shiro架构Shiro入门案例Shiro与web容器的集成 shiro简介 1. 什么是shiro shiro是apache的一个开源框架，是一个权限管理的框架，实现 用户认证、用户授权。 spring中有spring security (原名Acegi)，是一个权限框架，它和spring依赖过...
shiro入门（一）
qq_43059674的博客
10-12 164
Shiro简介 1. 什么是shiro shiro是apache的一个开源框架，是一个权限管理的框架，实现 用户认证、用户授权。 spring中有spring security (原名Acegi)，是一个权限框架，它和spring依赖过于紧密，没有shiro使用简单。 shiro不依赖于spring，shiro不仅可以实现 web应用的权限管理，还可以实现c/s系统， 分布式系统权限管理，shi...
Shiro入门(一)
小狐狸的博客
04-04 831
0. Shiro是什么？ 简单的来说 Apache Shiro 是一个强大灵活的开源安全框架，可以完全处理身份验证、授权、加密和会话管理。 shiro的四大基石 Authentication（认证）：用户身份识别，通常被称为用户“登录” Authorization（授权）： 访问控制。比如某个用户是否具有某个操作的使用权限。 Session Management（会话管理)： 特定于用户的会话管理,甚至在非web 或 EJB 应用程序。 Cryptography（加密）： 在对数据源使用加密
shiro 入门
客人
02-28 267
一、概述Apache Shiro是Java的一个安全框架，旨在简化身份验证和授权。Shiro在JavaSE和JavaEE项目中都可以使用。它主要用来处理身份认证，授权，企业会话管理和加密等。Shiro的具体功能点如下：（1）身份认证/登录，验证用户是不是拥有相应的身份； （2）授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或...
shiro(shiro1.3.2)
03-21
Apache Shiro是一个强大且易用的Java安全框架，主要用于处理认证、授权、加密以及会话管理等核心安全性问题。在给定的压缩包"shiro1.3.2"中，包含了Shiro的一个核心组件库"shiro-all-1.3.2.jar"以及两个日志管理库...
Apache shiro 1.13.0源码
最新发布
01-17
Apache Shiro 是一个强大且易用的Java安全框架，提供了认证、授权、加密和会话管理功能，简化了企业级应用的安全实现。Shiro 1.13.0 是其一个重要的版本，包含了多项更新和改进。在这个版本中，开发者可以深入理解其...
shiro
04-30
Apache Shiro 是一个强大且易用的 Java 安全框架，提供身份认证、授权、会话管理和加密等核心功能。这个框架旨在简化企业级应用的安全实施，让开发者能够更专注于业务逻辑，而不是复杂的安全实现。从给定的标签"源码...
Shiro反序列化漏洞，Shiro版本升级资源
06-22
shiro使用的版本是1.2.4，存在反序列化漏洞，我们采取的办法是手动升级到了1.2.6版本，但苦于无法验证是否解决了问题，后来发现了一款测试工具，ShiroExploit。 测试工具下载地址 ... 反序列化漏洞是如何产生的？...
shiro-attack-4.7.0-SNAPSHOT-all.zip
10-24
Apache Shiro是一个强大的Java安全框架，它提供了身份验证（Authentication）、授权（Authorization）以及会话管理（Session Management）等功能，广泛应用于各种类型的Java应用程序中。标题提到的"shiro-attack-...
Shiro入门使用
yjt520557的博客
02-19 388
1. 什么是shiro  shiro是apache的一个开源框架，是一个权限管理的框架，实现 用户认证、用户授权。    spring中有spring security (原名Acegi)，是一个权限框架，它和spring依赖过于紧密，没有shiro使用简单。    shiro不依赖于spring，shiro不仅可以实现 web应用的权限管理，还可以实现c/s系统，    分布式系统权限管...
shiro权限框架简单快速入门
dong_pongkk999的专栏
03-19 590
声明本文只适合初学者，本人也是刚接触而已，经过一段时间的研究小有收获，特来分享下希望和大家互相交流学习。 首先配置我们的web.xml代码如下，固定格式，记死就成           shiroFilter                        org.springframework.web.filter.DelegatingFilterProxy              
快速入门Shiro
JunDong的博客
06-01 2885
讲解结合案例，Shiro入门，看这篇就够了。
Shiro快速入门
gaoqing17的博客
09-23 158
简介 Shiro是一个强大的简单易用的Java安全框架，主要用来更便捷的认证，授权，加密，会话管理。Shiro首要的和最重要的目标就是容易使用并且容易理解。 Shiro是一个有许多特性的全面的安全框架，下面这幅图可以了解Shiro的特性： 可以看出shiro除了基本的认证，授权，会话管理，加密之外，还有许多额外的特性。 Shiro 的目标是 Shiro 开发团队所说的"应用安全的四大基石" - 身份验证、授权、会话管理和密码学： 身份验证：有时被称为"登录"，这是证明用户是谁，他们说他们的
Apache Shiro 安全框架教程
Apache Shiro 教程 Apache Shiro 是一个 Java 安全框架，目前越来越多的人使用它，因为它相当简单，对比 Spring Security，可能没有 Spring Security 做的功能强大，但是在实际工作时可能并不需要那么复杂的东西，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值