shiro+ssm授权方式之@RequiresPermissions（）注解授权

最新推荐文章于 2024-04-19 15:44:18 发布

首先使代码正确运行，然后再提高代码的速度

最新推荐文章于 2024-04-19 15:44:18 发布

阅读量2.9k

点赞数 2

文章标签： shiro+ssm授权方式之@RequiresPermissions（

本文链接：https://blog.csdn.net/m0_45294725/article/details/101553960

版权

此案例使用IDEA创建的maven的web项目

步骤一：在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.qf</groupId>
  <artifactId>ssm0923</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>ssm0923 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>
    <springversion>5.0.8.RELEASE</springversion>
  </properties>

  <dependencies>
    <!--shiro依赖-->
    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-core</artifactId>
      <version>1.2.3</version>
    </dependency>
    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-web</artifactId><!--基于shiro的web开发的包-->
      <version>1.2.3</version>
    </dependency>
    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-spring</artifactId><!--shiro和spring框架的整合包-->
      <version>1.2.3</version>
    </dependency>
    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-ehcache</artifactId><!--缓存包-->
      <version>1.2.3</version>
    </dependency>
    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-aspectj</artifactId><!--切面包-->
      <version>1.2.3</version>
    </dependency>
    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-quartz</artifactId>
      <version>1.2.3</version>
    </dependency>

<!--ssm依赖-->

    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-ehcache</artifactId>
      <version>1.2.3</version>
    </dependency>

    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-quartz</artifactId>
      <version>1.2.3</version>
    </dependency>
    <!-- 加入ServletAPI -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>

    <!-- MySQL依赖 start -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.38</version>
    </dependency>

    <!-- 加入MyBatis 依赖 start -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.2.8</version>
    </dependency>

    <!-- 引入Spring(包含SpringMVC) 依赖 start -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${springversion}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${springversion}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-oxm</artifactId>
      <version>${springversion}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${springversion}</version>
    </dependency>


    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${springversion}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${springversion}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${springversion}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>${springversion}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${springversion}</version>
    </dependency>

    <!-- 引用c3p0 依赖 start
    <dependency>
        <groupId>com.mchange</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.2.1</version>
    </dependency>
     -->
    <!-- 引用插件依赖：MyBatis整合Spring,如果mybatis版本在3.4及以上版本
       mybatis-spring的版本要在1.3以上	  -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.2.2</version>
    </dependency>

    <!-- JSTL -->
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>

    <!-- 德鲁伊数据连接池 -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.0.9</version>
    </dependency>

    <!-- pagehelper -->
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>4.1.6</version>
    </dependency>
    <!--处理json-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.5</version>
    </dependency>
    <!--导出excel-->
    <dependency>
      <groupId>org.apache.poi</groupId>
      <artifactId>poi</artifactId>
      <version>3.6</version>
    </dependency>
    <!--javaee-->
    <dependency>
      <groupId>javax</groupId>
      <artifactId>javaee-api</artifactId>
      <version>7.0</version>
      <scope>provided</scope>
    </dependency>
    <!--文件上传下载-->
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.3.1</version>
    </dependency>

    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.4</version>
    </dependency>
    <dependency>
      <groupId>joda-time</groupId>
      <artifactId>joda-time</artifactId>
      <version>2.9.9</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis.generator</groupId>
      <artifactId>mybatis-generator-core</artifactId>
      <version>1.3.5</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.5</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.12</version>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
    <dependency>
      <groupId>org.apache.poi</groupId>
      <artifactId>poi</artifactId>
      <version>3.6</version>
    </dependency>
  </dependencies>

  <build>
    <finalName>ssm0923</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <plugin>
          <groupId>org.mybatis.generator</groupId>
          <artifactId>mybatis-generator-maven-plugin</artifactId>
          <version>1.3.5</version>
          <configuration>
            <!--配置文件的路径-->
            <configurationFile>src/main/resources/generatorConfig.xml</configurationFile>
            <overwrite>true</overwrite>
          </configuration>
          <dependencies>
            <dependency>
              <groupId>org.mybatis.generator</groupId>
              <artifactId>mybatis-generator-core</artifactId>
              <version>1.3.5</version>
            </dependency>
          </dependencies>
        </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>

主要关注/dependencies中的内容即可，实在配不好直接将我的文件覆盖你的pom.xml文件

步骤二：将如下代码覆盖你的web.xml文件（该文件在WEB-INF下）

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5"><!--头信息一定要是2.5的-->
  <display-name>Archetype Created Web Application</display-name>
    <welcome-file-list>
      <welcome-file>login.jsp</welcome-file><!--启动项目后TOMCAT自动打开的的页面-->
    </welcome-file-list>


  <!--这两种加载文件的方式会经常放在一起使用，但以下两种加载文件的方式在一起同时使用就会产生父子容器问题
     子容器可以访问父容器对象，但父容器不能访问子容器对象
    DispatcherServlet加载的文件属于子容器
    ContextLoaderListener加载的文件属于父容器
     --><!--在spring.xml被拆分成好几个文件时容易遇到父子容器文件的问题-->


  <!--第一种加载spring文件的方式-->
  <!--加载我们定义的spring-shiro.xml文件-->
  <listener>
    <listener-class>
      org.springframework.web.context.ContextLoaderListener
    </listener-class>
  </listener>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring-shiro.xml</param-value><!--加载文件-->
  </context-param>


  <!--第二种加载spring文件的方式-->
  <!--这个也是加载spring.xml文件-->
  <!--DispatcherServlet核心控制器-->
  <servlet>
    <servlet-name>aa</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring.xml</param-value><!--加载文件-->
    </init-param>
  </servlet>


  <servlet-mapping>
    <servlet-name>aa</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
  <filter>

    <!--编码过滤器-->
    <filter-name>bb</filter-name>
    <filter-class>
      org.springframework.web.filter.CharacterEncodingFilter
    </filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>utf-8</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>bb</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>


<!--shiro过滤器，是shiro自带的，.DelegatingFilterProxy会从spring容器中找shiroFilter-->
  <filter>
    <filter-name>cc</filter-name>
    <filter-class>
      org.springframework.web.filter.DelegatingFilterProxy
    </filter-class><!--代理类工具类-->
    <!--filter生命周期由spring管理-->
    <init-param>
      <param-name>targetFilterLifecycle</param-name>
      <param-value>true</param-value><!--true代表当前shiro一些对象的创建声明周期都有spring管理-->
    </init-param>
  </filter>
    <filter-mapping>
      <filter-name>cc</filter-name>
      <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>

步骤三：在entity包下创建数据库用户表sys_user对应的实体类

该实体类命名为：SysUser

package com.qf.entity;


public class SysUser {
    private String id;
    private String userCode;
    private String userName;
    private String passWord;
    private String salt;
    private int locked;



    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getUserCode() {
        return userCode;
    }

    public void setUserCode(String userCode) {
        this.userCode = userCode;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

    public String getSalt() {
        return salt;
    }

    public void setSalt(String salt) {
        this.salt = salt;
    }

    public int getLocked() {
        return locked;
    }

    public void setLocked(int locked) {
        this.locked = locked;
    }
}

步骤四：在util包下创建自定义的Realm用于认证和授权

我将该类命名为：MyRealm

package com.qf.util;

import com.qf.entity.SysUser;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;

import java.util.ArrayList;
import java.util.List;
//自定义MyRealm作用，验证前后台用户名和密码是否一致（即认证方法部分），给认证通过的用户赋予数据库中存储的对应的权限和角色信息（即授权方法部分）
public class MyRealm extends AuthorizingRealm {
    @Override
    //授权
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //在本案例中授权这个方法几乎没用到。主要用到的是下面的认证方法。写授权是作为示范
       //创建集合添加用户对应的真实权限



         // <!--本案例重点关注代码-->
        List pers=new ArrayList();
        pers.add("item:select");//这些权限的添加，后期我们可以和数据库相连，调用dao层方法，获取mapper文件中sql语句查询的数据库信息放在此处。
        pers.add("user:delete");



        //创建向前台传递权限的SimpleAuthorizationInfo对象
        SimpleAuthorizationInfo simpleAuthorizationInfo=new SimpleAuthorizationInfo();
        //调用addStringPermissions方法将装有权限的集合作为参数赋给SimpleAuthorizationInfo对象传给前台
        simpleAuthorizationInfo.addStringPermissions(pers);//有角色还可以在这加角色
        return simpleAuthorizationInfo;
    }

    @Override
    //认证
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
      String username = (String)authenticationToken.getPrincipal();//前台传过来的用户名，用于比对和数据库的用户名
      if (username.equals("zhangsan")){//张三代表数据库中正确的用户名，这里为了例子简单，没有比对密码
          SysUser sysUser=new SysUser();// SysUser使我们在entity中创建数据库中sys_user表对应的实体类。该对象用于存储登录用户信息，传给我们重写的过滤器MyFormFilter，用于将其存储到session中
          sysUser.setUserName("张三");
          return new SimpleAuthenticationInfo(sysUser,"123","myrealm");//123位数据库中的真实密码，直接通过SimpleAuthenticationInfo对象传给调用该方法的controller层
      }
        return null;
    }
}

注意自定义的Realm一定要继承AuthorizingRealm

步骤五：在util包下创建一个类，将自定义中传递的用户信息存在Session中。该类继承FormAuthenticationFilter，重写 onLoginSuccess方法即可。

我将该类命名为：MyFormFilter

package com.qf.util;

import com.qf.entity.SysUser;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.authc.FormAuthenticationFilter;
import org.apache.shiro.web.util.WebUtils;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

//写该类是为了在此处将登录成功的用户信息存储在session中。注意该类是继承FormAuthenticationFilter类重写，重写它的onLoginSuccess即shiro登录成功后的处理方法。
public class MyFormFilter extends FormAuthenticationFilter {
    @Override
    protected boolean onLoginSuccess(AuthenticationToken token, Subject subject, ServletRequest request, ServletResponse response) throws Exception {
        //得到认证通过的主体，获取自定义的Realm中SimpleAuthenticationInfo对象传的用户信息，通过getPrincipal获取
        SysUser user=(SysUser)subject.getPrincipal();//获取自定义realm（即本案例的MyRealm）中SimpleAuthenticationInfo存储的用户名。获取密码是subject.getCredentials()
        //然后将获取到的信息存储到Session中
        HttpServletRequest httpServletRequest= WebUtils.toHttp(request);//将ServletRequest 转化成HttpServletRequest，ServletRequest似乎是HttpServletRequest的父类
        HttpSession session = httpServletRequest.getSession();//获取session对象
        session.setAttribute("user1",user);
        return super.onLoginSuccess(token, subject, request, response);
    }
}

步骤六：在resources下创建spring.xml文件，将如下代码复制进去

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"

       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
                           http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/tx
                           http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop.xsd
">


    <!--1.连接数据库-->
    <bean id="db" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="password" value="root"/>
        <property name="username" value="root"/>
        <property name="url" value="jdbc:mysql://localhost:3306/day06"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    </bean>
    <!--2.扫描注解包-->
   <context:component-scan base-package="com"></context:component-scan>
    <!--3.创建视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>
    <!--4.加载注解驱动-->
    <mvc:annotation-driven/>
    <!--5.创建sqlsession工厂-->
    <bean id="fac" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="db"></property>
      <!--  <property name="mapperLocations" value="classpath:mapper/*.xml"></property>
        <property name="configLocation" value="classpath:mybatis-config.xml"></property>-->
    </bean>

    <!--6.扫描dao层接口-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.qf.dao"></property>
        <property name="sqlSessionFactoryBeanName" value="fac"></property>
    </bean>
    <!--7.事务-->
    <bean id="mytx" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="db"></property>
    </bean>
    <tx:annotation-driven transaction-manager="mytx"></tx:annotation-driven>
   <!--8.静态资源-->
    <mvc:default-servlet-handler></mvc:default-servlet-handler>


    <!--使用注解授权的第一个步骤：在子容器中加载该注解授权，不能再父容器中加载，因为子容器可以访问父容器，父容器不能访问子容器。因此该案例中开启aop对类代理、开启shiro注解支持这两步一定不能放在spring-shiro.xml文件中，因为他是父容器。  DispatcherServlet加载的文件属于子容器。ContextLoaderListener加载的文件属于父容器，具体见web.xml文件-->
    <!-- 开启aop对类代理。记得添加上面的aop命名空间 -->
    <aop:config proxy-target-class="true"></aop:config>
    <!-- 开启shiro注解支持 -->
    <bean  class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
        <property name="securityManager" ref="manager"></property><!--除了ref属性值manager是上面SecurityManager对象的id值外其他都是固定搭配-->
    </bean>


   </beans>

注解授权第一个真实步骤在这个文件中，当我们设置了权限但依然能访问时，就考虑是否父子容器加载配置文件问题

步骤七：在resources下创建spring-shiro.xml将如下代码赋值进去

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
                           http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/tx
                           http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--这个文件也可以直接写在spring.xml文件中。之所以单独拿出来是为了专门写shiro的先关信息-->


    <!--上面可以不改，下面的几乎每行都要改动-->


    <!--创建自定义的realm的bean对象-->
    <bean id="myrealm" class="com.qf.util.MyRealm"></bean><!--class的值是自定义的Realm的类路径（包名加类名），id名随便取-->
    <!--创建SecurityManager对象-->
    <bean id="manager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager"><!--manager随便取，class的值为DefaultWebSecurityManager的类路径（包名加类名）-->
        <property name="realm" ref="myrealm"></property><!--realm是DefaultWebSecurityManager类自带的属性，myrealm是上面我们创建的自定义的Realm的bean对象的id名-->
    </bean>
     <!--配置shiro过滤器，id等于web.xml文件中的filter-name标签定义的名字相同,在那我们定义的叫cc-->
    <bean id="cc" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean"><!--id一定要和web.xml中的shiro过滤器的 <filter-name>标签的名字即 <filter-name>cc</filter-name>一样。class的值是ShiroFilterFactoryBean的类路径（即包名加类名）-->
        <property name="securityManager" ref="manager"></property><!--securityManager是ShiroFilterFactoryBean类的属性，manager则是上面创建的SecurityManager对象的id名-->
        <property name="loginUrl" value="/tologin"></property><!--loginUrl是ShiroFilterFactoryBean类的属性，value值是我们web项目的登录成功后发送的请求地址（此案例该请求地址是/tologin，可去login.jsp查看）。这个似乎可以不要-->
        <property name="unauthorizedUrl" value="/error.jsp"></property><!--unauthorizedUrl是ShiroFilterFactoryBean类的属性。当用户访问我们项目中该用户没有权限的页面时要跳去的页面，该案例我们将该页面命名为的是error.jsp。注意这是没权限跳去的页面，而不是网页发生异常跳去的页面-->
        <!--下面使用shiro相当于是个拦截器的作用，意味着shiro自带拦截器-->
        <property name="filterChainDefinitions"><!--name的值是ShiroFilterFactoryBean的一个属性-->
            <!--注意shiro+ssm登录成功后跳转页面的规律：默认跳转的是上一次请求的页面路径-->
            <value><!--匿名地址在上，公共地址在下，顺序不能乱。匿名地址：也叫公开地址，即不登录就可以通过网址访问的页面;公共地址：必须要登录后才能访问的地址-->
                /favicon.ico=anon <!--anon代表匿名访问地址，请求地址=anon代表该页面允许匿名访问，即该页面不用登录就可以访问。而此处/favicon.ico也有特殊意义，这个请求是浏览器发送的，当页面不存在或没权限时就会跳去的页面-->
                /loginout=logout<!--等号左边的/loginout代表请求地址，我们将这个请求地址写在index.jsp页面的退出那的。等号右边的logout是shiro自带的退出功能，默认跳到登录页面。因此在shiro中只需要在此处加/loginout=logout这行代码就可以代替原本的退出功能。原来我们是要在UserController中专门写一个处理退出请求的放大，使用shiro后就不用写了-->
             <!--   /js/**=anon
                /images/**=anon
                /styles/**=anon-->



                /**=authc<!--authc代表公共访问地址，请求地址。/**=authc代表除了上面被声明为匿名地址的剩下的所有的都是公共访问地址了，即必须登录后才能访问的地址或资源-->

            </value>
        </property>

        <!--修改默认的过滤器-->
        <property name="filters"><!--固定名-->
            <map>
                <entry key="authc" value-ref="myform"></entry><!--key=authc即公共地址，value-ref的值就是下面我们创建的id="myform"的bean对象告诉过滤器加载我们重写的onLoginSuccess方法-->
            </map>
        </property>
    </bean>
    <!--创建表单过滤器对象，告诉shiro我们重写MyFormFilter类的存在。执行我们重写的onLoginSuccess方法-->
    <bean id="myform" class="com.qf.util.MyFormFilter">
        <property name="usernameParam" value="username"></property><!--name的属性值和value的属性值是固定的，这是shiro底层固定了的，即在shiro自带的FormAuthenticationFilter类中固定的-->
        <property name="passwordParam" value="password"></property><!--name的属性值和value的属性值是固定的，这是shiro底层固定了的，即在shiro自带的FormAuthenticationFilter类中固定的-->
    </bean>



</beans>

步骤八：上面框架都搭建完了，可以在controller层创建类使用shiro的注解授权了

package com.qf.controller;


import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authz.AuthorizationException;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RequestMapping;


import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;


//登录
@Controller
public class UserController {
    @RequestMapping("/tologin")
    public String login(HttpServletRequest request) throws Exception {
        //这只是判断登录出错问题，并不会判断其他出错的问题
        //shiro+ssm框架中会处理成功的情况，我们在登录请求中之用处理用户名和密码比对失败的情况
        //从FormAuthenticationFilter中获取认证失败的错误信息。因为shiro比对用户名和密码不一致，返回的不是false，而是异常，因此需要我们在处理失败的情况时捕获该异常，然后进行处理
        String failure = (String) request.getAttribute("shiroLoginFailure");//shiroLoginFailure是shiro底层捕获比对错误的属性
        if (failure!=null){//failure!=null意味着shiro底层比对failure产生了值，也就是发生了错误
            if (UnknownAccountException.class.getName().equals(failure)){//shiro中前台和数据库用户名不一致，就是报UnknownAccountException异常
                throw new Exception("用户名错误");
            }else if (IncorrectCredentialsException.class.getName().equals(failure)){//shiro中前台和数据库密码不一致，就是报IncorrectCredentialsException异常
                throw  new Exception("密码错误");
            }else {
                throw new Exception("未知错误");
            }
        }
        //没发生错，就跳转登录页面
return "login";//注意这里原本应该是return "/login.jsp",但因为我们在spring.xml文件中的第三步<!--3.创建视图解析器-->声明了前后缀，所以才写return "login"。
    }


/*使用注解授权的第二个步骤：使用@RequiresPermissions("权限")标记发送该请求的用户需要哪些权限*/

    //  id ->11->张三
    @RequestMapping("/item/queryItem.action")
    @RequiresPermissions("item:select")//这个意思是当某个登录用户想发送/item/queryItem.action请求地址时，该用户还必须有item:select权限才行
    public String queryitem(){
        System.out.println("queryitem----");
        return "queryItem";
    }
    //id ->21->李四
    @RequestMapping("/user/query.action")
    @RequiresPermissions("item:update")//我们自定义的zhangsan在MyRealm我们只给它添加了"item:select"；"user:delete"这两个权限因此这一个方法进不去。输入http://localhost:8080/user/query.action访问会报没权访问的异常。但因为下面@ExceptionHandler注解捕获了该异常，因此注解的异常会跳去dd.jsp这个页面
    public String queryuser(){
        System.out.println("queryuser----");
        return "queryuser";
    }


    /*使用注解授权的第三个步骤：在Controller层使用 @ExceptionHandler捕获无权访问处理产生的AuthorizationException异常*/

    //捕获有注解授权产生的无权访问的异常，并给定对应的处理方法
    @ExceptionHandler(AuthorizationException.class)//注意该注解是@RequiresPermissions注解授权无权访问的固定搭配，因为注解无权访问异常报的就是AuthorizationException这个错误。下面是该异常的处理方法
    public String dd(){

        return "error";//跳转去error.jsp页面
    }
}

注解授权第二三个个真实步骤在这个文件中，除开这三个步骤其它都是框架的搭建

以下是本次注解授权要用到的jsp页面

这些页面都创建在webapp

第一个登录页面：
命名为：login.jsp

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2019/9/23
  Time: 14:07
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>login.jsp</h1>
<form action="/tologin" method="post"><%--action的值是代表将表单信息发去controller层的那个方法进行处理--%>
    <%--在项目运行成功后，登录时记得我们在自定义Realm中假设的用户名叫zhangsan，密码是123--%>
    username:<input type="text" name="username"><br><%--用了shiro后这个用户名由于并不用我们来验证而是由shiro框架来接收并验证，而它底层接收用户名的属性名就是username，因此输入用户名的控件的name属性值必须等于username，要么重写shiro当中的FormAuthenticationFilter类，重新定义username这个属性--%>
    password:<input typ e="text" name="password"><br><%--用了shiro后这个密码由于并不用我们来验证而是由shiro框架来接收并验证，而它底层接收用户名的属性名就是password，因此输入用户名的控件的name属性值必须等于password，要么重写shiro当中的FormAuthenticationFilter类，重新定义username这个属性--%>

    <input type="submit" name="登录">
</form>
</body>
</html>

第二个登录首页：
命名为：index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>
<h2>index.jsp</h2>
<h1>当前用户:${sessionScope.user1.userName}</h1>
<a href="/loginout">退出</a>
</body>
</html>

第三个异常跳转页面：
命名为：error.jsp

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2019/9/25
  Time: 10:08
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
   <h1>权限不足</h1>
</body>
</html>

以下是我本次案例的项目框架图：
在这里插入图片描述
文章特别提示：测试请求地址：http://localhost:8080/user/query.action（localhost代表本地IP，8080代表Tomcat那设的端口号），这个请求地址是zhangsan没有权限的地址。其他几个请求地址模仿这个就行了
另外注意：由于shiro的默认访问登录前访问的地址这一特殊属性，因此在登录前先输入你想去的请求地址，然后再输入正确的用户名（zhangsan）和密码（123）

首先使代码正确运行，然后再提高代码的速度

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
shiro+ssm授权方式之@RequiresPermissions（）注解授权

此案例使用IDEA创建的maven的web项目步骤一：在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" x...
复制链接

扫一扫