shiro+ssm授权方式之xml文件授权

最新推荐文章于 2024-03-26 07:56:59 发布
最新推荐文章于 2024-03-26 07:56:59 发布
阅读量302 收藏
点赞数
文章标签： shiro+ssm授权方式之xml文件授权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45294725/article/details/101539916
版权

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

shiro+ssm给请求地址授权的方式有两种：
一是通过xml文件授权
二是通过注解方式授权

步骤一：配置pom.xml文件。直接将如下代码复制进你的pom.xml文件，要覆盖你的pom.xml文件。

框架核心步骤一

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 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>

这当中最重要的是其中的依赖。

步骤二：在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: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">

    <!--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><!--一位这这个包下面使用了注解，不一定要指定到具体哪一个包，像这里的com只是一个父包，真正使用注解的在它的子包中。但要记住一点，有注解的包就一定要在base-package中加进去，以逗号隔开。如<context:component-scan base-package="com.qf.util，com.weather">-->
    <!--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><!--用于指定mapper文件夹下的所有xml文件。我项目中的mapper下的xml文件一般定义dao层调用的查询数据库的sql语句-->
        <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>



   </beans>

注意其中的包路径和包的相对路径，我项目的包都是com.qf开头的，如果你想试验成功，包的框架搭建按最下面的框架图搭建。如果你理解当中的意思，可随便建。其次数据库是你肯定得根据自己情况修改的

步骤三：在entity包下创建数据库表sys_user对应的实体类SysUser，因为自定义Realm会用到

非核心步骤

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包下自定义Shiro的Realm文件。 用于如何验证用户和给用户授哪些权的

非核心步骤

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");
        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 List pers=new ArrayList();
pers.add(“item:select”);
pers.add(“user:delete”);
这是自定义Realm中要重点关注的代码。授予权限部分

步骤五：在util下创建MyFormFilter，用于将成功登陆的用户信息存储到session中。该类必须继承FormAuthenticationFilter类，重写它的onLoginSuccess方法即可

非核心步骤

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);
    }
}

文件的名字即MyFormFilter这个类名时随便取的但相应的位置一定要一致。之所以将用户存在session中，是为了在整个浏览器有用

步骤五：在resources下创建spring-shiro.xml。声明自定义的一些shiro要用到的bean对象。告诉shiro我们自定义的东西的存在。

框架核心步骤三

<?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: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">
<!--这个文件也可以直接写在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。注意这是没权限跳去的页面，而不是网页发生异常跳去的页面.另外，这个未授权而去访问的页面只对xml文件授权管用，注解授权需要单独的使用对应的注解去捕获处理-->
        <!--下面使用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-->


                <!--本案例重点关注代码-->
                /item/queryItem.action=perms[item:select]<!--/item/queryItem.action代表一个请求地址；perms[item:select]中perms是固定搭配，其中item:select是在访问/item/queryItem.action请求地址时该用户必须有item:select权限（用户的所有权限是在我们自定义Realm中那赋进去的）；/item/queryItem.action=perms[item:select]完整的意思是当登录用户发送/item/queryItem.action请求时，该用户还必须在自定义Realm（本例为MyRealm）那被授予了item:select权限才能执行/item/queryItem.action请求在Controller对应的方法。当zhangsan登录后，访问这个请求地址会通过UserController中的queryitem方法跳转去queryItem.jsp页面，由于我们没定义该页面，会报404-->
                /item/add.action=perms[item:create]<!--在本次案例中zhangsan这个用户只有[item:select]和[user:delete]权限。所以/item/add.action这个请求地址张三是访问不了的，没权限访问网页会跳去error.jsp，因为上面我们设置了unauthorizedUrl的属性值-->


                /**=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>

注意
/item/add.action=perms[item:create]
/item/queryItem.action=perms[item:select]
这两行是本案例中授权的重要代码

步骤六：上面就已经搭建完shiro+ssm的整合框架了，可以开始在执行类中测试了

在controller层创建名为UserController的类执行本次测试

package com.qf.controller;


import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.UnknownAccountException;
import org.springframework.stereotype.Controller;
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"。
    }


  // 本案例重点代码
    @RequestMapping("/item/queryItem.action")
    public String queryitem(){
        System.out.println("queryitem----");
        return "queryItem";
    }
    // 本案例重点代码
    @RequestMapping("/user/query.action")
    public String queryuser(){
        System.out.println("queryuser----");
        return "queryuser";
    }




 /*   //退出。因为shiro自带的退出功能即 /loginout=logout。所以这几行代码就被注释了。不需要我们写处理退出请求的方法
    @RequestMapping("/loginout")
    public String out(HttpSession session){
        System.out.println("----loginout");
        session.invalidate();//使存储的session失效，清除session中的信息
        return "redirect:/login.jsp";//注意这里跳转和上面return "login"跳转页面时的区别。return "login"是转发的跳转方式，转发是SSM默认的跳转方式。 return "redirect:/login.jsp"是重定向的跳转。即使在spring.xml文件中声明了前后缀，重定向依然要写全名。
    }*/


}

注意 // 本案例重点代码

该案例配套的jsp页面：以下三个页面一定要创建在webapp文件夹下

第一个登录的Jsp页面：命名为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>

第二个首页的Jsp页面：命名为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>

这是我本次案例的框架图
在这里插入图片描述

本文特别提示：想看懂在xml文件中授权的方式的案例，UserController、spring-shiro.xml、MyRealm这三个文件必须同时连在一起思考

Java 权限管理系统 shiro + ssm实现
05-05
Java 权限管理系统 shiro + ssm实现。 权限管理系统 shiro + ssm实现,实现菜单,有学习的可以下载哦!项目基于jdk1.8整合了springboot+mvc+mybatis(通用mapper)+druid+jsp+bootstrap等技术,springboot+Listener(监听器...
.net中xml文件的导入使用（包括创建xml和导入xml）
weixin_33951761的博客
01-03 169
上次有说到.net 创建xml文件的方法（一种固定方式，一种动态方法），这次记录一下怎样导入xml文件 1、导入xml文件的方法 1）xml文件格式 2) 窗体页面的样式 3）源码实例 3.1）创建xml文件的源码 /// &lt;summary&gt; /// 灵活方式模板 /// &lt;/summary&gt; /// ...
Shiro的配置文件.xml
u011607686的博客
03-16 1348
一、权限控制：两种说法 比如anon拦截器表示匿名访问（即不需要登录即可访问）； authc拦截器表示需要身份认证通过后才能访问； roles[admin]拦截器表示需要有admin角色授权才能访问； 而perms[“user:create”]拦截器表示需要有“user:create”权限才能访问。 1、authc 表示需要认证的链接 2、perms[/url] 表示该链接需要拥有对应...
java访问xml配置文件
weixin_55850954的博客
06-14 868
xml访问
5.传统Spring中使用Shiro（XML）
相互学习 共同进步
06-28 1036
传统Spring使用Shiro（XML） 1.导入依赖 <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-core</artifactId> <version>1.5.3</version> </dependency> <dependency> <groupId>org.apache.shiro&
权限管理系统 shiro + ssm实现
09-22
权限管理系统 shiro + ssm实现,实现菜单,有学习的可以下载哦!项目基于jdk1.8整合了springboot+mvc+mybatis(通用mapper)+druid+jsp+bootstrap等技术,springboot+Listener(监听器),Filter(过滤器),Interceptor(拦截器)...
maven+SSM+shiro简单的授权和认证
12-26
SSM提供了全面的MVC功能和持久层支持，而Shiro则专注于应用程序的安全管理，包括认证和授权。下面我们将详细探讨如何使用Maven来管理和构建一个包含SSM和Shiro的项目。 **1. Maven项目管理** Maven是一个强大的...
springboot+权限管理系统 shiro + ssm实现 实现菜单,自用
07-09
权限管理系统 shiro + ssm实现,实现菜单,有学习的可以下载哦!项目基于jdk1.8整合了springboot+mvc+mybatis(通用mapper)+druid+jsp+bootstrap等技术,springboot+Listener(监听器),Filter(过滤器),Interceptor(拦截器)...
shiro+SSM实现安全登录的项目
06-19
- `shiro.xml`：Shiro的配置文件，包括Realm配置和过滤器链定义。 - `Spring配置文件`：如`spring-context.xml`，包含了Shiro Bean的配置。 - `web.xml`：Web应用的部署描述符，配置Shiro Filter和Spring ...
SSM+Shiro实现权限角色控制
11-07
SSM+Shiro实现权限角色控制，+Maven+Tomcat+Mysql，项目可直接在eclipse上跑，数据库表也附件在压缩包中。
ssm-shiro权限管理（一）
01-08
基于ssm快速整合shiro权限
spring-shiro-xml
09-28
shiro中的与spring结合的核心代码，可以使用缓存进行存储用户信息
ssm+shiro整合的一个项目适合初学者
03-05
这是一个ssm项目和shiro整合的一个项目，配置和jar包都特别的完整完全可以直接拿过来用
shiro 配置文件
01-06
从web.xml到spring 配置shiro的使用
springmvc 整合shiro 例子（一）
hins
08-26 1294
Shiro的maven依赖配置 pom.xml org.apache.shiro shiro-core ${shiro.version} org.apache.shiro shiro-web ${shiro.version} org.apache.shiro shiro-cas ${shiro.versio
最简单的XML Android权限声明
最新发布
2402_83870126的博客
03-26 126
permission name="获取网络状态连接状态" />
spring-shiro.xml
gsc1456的博客
09-21 524
&lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;!--自定义Realm--&gt; &lt;bean id="myRealm" class="com.flt.shiro.realm.myRealm"&gt; &lt;property name="credentialsMatcher" ref=&
Shiro安全框架简介
04-07
本课程讲解了shiro权限验证在web环境中的使用。适合具有spring+springMVC+mybatis开发web网站基础的编程人员学习网站权限开发。课程讲解由浅入深，从静态权限到动态角色菜单的分配和维护。适用于开发企业管理后 台、oa系统等。
SSM+Shiro+Maven+Bootstrap图书馆管理系统源码
资源摘要信息:"基于SSM+shiro+maven+bootstrap的图书馆管理系统源码.zip" 本资源包包含了一个完整的基于Java语言开发的图书馆管理系统源码。该系统采用了SSM框架，即Spring, Spring MVC和MyBatis的集成框架。同时，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值