Shiro快速入门实例（登录认证）

最新推荐文章于 2024-05-01 06:09:37 发布

Satisfy_555

最新推荐文章于 2024-05-01 06:09:37 发布

阅读量366

点赞数

分类专栏： Shiro

本文链接：https://blog.csdn.net/Satisfy_555/article/details/80394060

版权

Shiro 专栏收录该内容

0 篇文章 0 订阅

订阅专栏

说明：Shiro是Java的安全（权限框架），具体介绍我说不来也没必要多说，这是刚开始学习的一个东西，只是简单记录下已经测试可以运行的代码，这个示例还没有涉及到跟数据库的交互以及数据加密，暂时只是简单的认证功能。。目前正在学习这个框架……

================================

1.首先环境是使用 eclipse + Maven + Spring + SpringMVC + Shiro 搭建的。

首先是项目结构：

-------------------------------------------------------------

2.首先是pom.xml

<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.lin</groupId>
  <artifactId>Shiro_Spring_MavenTest</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>

  <dependencies>  
    <!-- spring begin -->  
    <!--spring-core-->    
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-core</artifactId>  
        <version>4.2.0.RELEASE</version>  
    </dependency>  
    <!-- spring-web-mvc -->  
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-webmvc</artifactId>  
        <version>4.2.0.RELEASE</version>  
    </dependency>  
    <!-- spring end -->  
      
      
    <!-- shiro begin -->
	<dependency>
	    <groupId>org.apache.shiro</groupId>
	    <artifactId>shiro-all</artifactId>
	    <version>1.3.2</version>
	</dependency>

    <!-- shiro end -->
    
    <!-- ehcache begin -->
	<dependency>
	    <groupId>net.sf.ehcache</groupId>
	    <artifactId>ehcache-core</artifactId>
	    <version>2.3.2</version>
	</dependency>
    <!-- ehcache end -->
    
    <!-- LOGGING begin -->
    
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>1.7.7</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.7.7</version>
		</dependency>
		<!-- common-logging 实际调用slf4j -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>jcl-over-slf4j</artifactId>
			<version>1.7.7</version>
		</dependency>
		<!-- java.util.logging 实际调用slf4j -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>jul-to-slf4j</artifactId>
			<version>1.7.7</version>
		</dependency>
		<!-- LOGGING end -->
  </dependencies>  
    
    
  <!-- 添加项目jdk编译插件 -->  
  <build>  
    <!-- 设置编译版本为1.8 -->  
    <plugins>  
        <plugin>  
            <groupId>org.apache.maven.plugins</groupId>  
            <artifactId>maven-compiler-plugin</artifactId>  
            <configuration>  
                <source>1.8</source>  
                <target>1.8</target>  
                <encoding>UTF-8</encoding>  
            </configuration>  
        </plugin>  
        <!-- 配置tomcat7的插件，如果使用maven的命令方式运行，则命令为：tomcat7:run ，  
             而不能是tomcat:run（如果使用该命令，还是会使用maven默认的tomcat来编译运行项目）。  
              
            可以直接使用eclipse中的tomcat来运行项目（就是原先没有使用maven时的那样运行项目就可以了，那样的话也不需要配这个插件了）。      
         -->  
        <plugin>    
            <groupId>org.apache.tomcat.maven</groupId>    
            <artifactId>tomcat7-maven-plugin</artifactId>    
            <version>2.1</version>    
        </plugin>  
    </plugins>  
  </build>  
</project>

web.xml（这里面配置了一个shiroFilter，详细见下说明）

<?xml version="1.0" encoding="UTF-8"?>
<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">
  <display-name>Shiro_Spring_MavenTest</display-name>
  
  <!-- 配置spring -->
  <context-param>
  	<param-name>contextConfigLocation</param-name>
  	<param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  <!-- 配置监听器 -->
  <listener>
  	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
 
  <!-- 定义Spring MVC的前端控制器 -->  
  <servlet>  
    <servlet-name>springmvc</servlet-name>  
    <servlet-class>  
        org.springframework.web.servlet.DispatcherServlet  
    </servlet-class>  
    <init-param>  
      <param-name>contextConfigLocation</param-name>  
      <param-value>classpath:springmvc-config.xml</param-value>  
    </init-param> 
  </servlet>  
    
  <!-- 让Spring MVC的前端控制器拦截所有请求 -->  
  <servlet-mapping>  
    <servlet-name>springmvc</servlet-name>  
    <url-pattern>/</url-pattern>  
  </servlet-mapping>  
    
    
  <!-- 
  	1.配置shiro的ShiroFilter
  	2.DelegatingFilterProxy实际上是Filter的一个代理对象，
  	默认情况下，Spring会到IOC容器中查找<filter-name>对
  	的filter bean，也可以通过targetBeanName的初始化参数来配置filter bean 的id
   -->
    <filter>
        <filter-name>shiroFilter</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
        <init-param>
            <param-name>targetFilterLifecycle</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>

    <filter-mapping>
        <filter-name>shiroFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
  
  <!-- 编码过滤器 -->  
  <filter>  
        <filter-name>characterEncodingFilter</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>characterEncodingFilter</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping>  
      
</web-app>

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"  
       xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"  
       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:context="http://www.springframework.org/schema/context"  
       xmlns:tx="http://www.springframework.org/schema/tx"  
       xsi:schemaLocation="http://www.springframework.org/schema/beans  
                              http://www.springframework.org/schema/beans/spring-beans-4.2.xsd  
                              http://www.springframework.org/schema/mvc  
                              http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd  
                              http://www.springframework.org/schema/context  
                              http://www.springframework.org/schema/context/spring-context-4.2.xsd  
                              http://www.springframework.org/schema/tx  
                              http://www.springframework.org/schema/tx/spring-tx-4.2.xsd  
                              http://mybatis.org/schema/mybatis-spring  
                              http://mybatis.org/schema/mybatis-spring.xsd">  


    <!-- 1. 配置securityManager -->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="cacheManager" ref="cacheManager"/>
        <property name="realm" ref="jdbcRealm"/>
    </bean>

    <!-- 
    	2.配置缓存管理器 CacheManager
    	2.1 需要加入ehcache的jar包及配置文件
    -->
    <bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
        <property name="cacheManagerConfigFile" value="classpath:ehcache.xml"/>
    </bean>

    <!-- 
    	3.配置Realm
    	3.1 直接配置实现了Realm接口的bean
     -->
    <bean id="jdbcRealm" class="com.lin.realm.RealmTest"></bean>

    <!-- 
    	4.配置lifecycleBeanPostProcessor，
    	可以自动的来调用配置在Spring IOC容器中shiro bean的生命周期方法
     -->
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>

    <!-- 
    	5.启用IOC容器中使用shiro的注解，但必须在配置了lifecycleBeanPostProcessor之后才可以使用
     -->
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
          depends-on="lifecycleBeanPostProcessor"/>
    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
        <property name="securityManager" ref="securityManager"/>
    </bean>

    <!-- 
    	6. 配置shiroFilter
    	6.1 id必须和web.xml中<filter-name>一致
    	6.2 
     -->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager"/>
        <!-- 配置登录页面 -->
        <property name="loginUrl" value="/login.jsp"/>
        <!-- 配置登录成功的页面 -->
        <property name="successUrl" value="/list.jsp"/>
        <!-- 配置没有权限的页面 -->
        <property name="unauthorizedUrl" value="/unauthorized.jsp"/>
        <!-- 
        	配置哪些页面需要受保护，
        	以及访问这些页面需要的权限。
        	1） anon表示 可以被匿名访问（anon实际上是一个过滤器）
        	2）authc表示 必须认证即登录后才可以访问的页面（authc也是一个过滤器）
         	3)logout表示登出
         -->
        <property name="filterChainDefinitions">
            <value>
                /login.jsp = anon
				/shiro/login = anon
				
				/shiro/logout = logout
				
                # everything else requires authentication:
                /** = authc
            </value>
        </property>
    </bean>

</beans>

springmvc-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"  
       xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"  
       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:context="http://www.springframework.org/schema/context"  
       xmlns:tx="http://www.springframework.org/schema/tx"  
       xsi:schemaLocation="http://www.springframework.org/schema/beans  
                              http://www.springframework.org/schema/beans/spring-beans-4.2.xsd  
                              http://www.springframework.org/schema/mvc  
                              http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd  
                              http://www.springframework.org/schema/context  
                              http://www.springframework.org/schema/context/spring-context-4.2.xsd  
                              http://www.springframework.org/schema/tx  
                              http://www.springframework.org/schema/tx/spring-tx-4.2.xsd  
                              http://mybatis.org/schema/mybatis-spring  
                              http://mybatis.org/schema/mybatis-spring.xsd">  
  
    <!-- 自动扫描该包，SpringMVC会将包下用@Controller注解的类注册为Spring的controller -->  
    <context:component-scan base-package="com.lin"/>  
      
    <!-- 设置默认配置方案 -->  
    <mvc:annotation-driven/>  
      
    <!-- 使用默认的Servlet来响应静态文件 -->  
    <mvc:default-servlet-handler/>  
      
    <!-- 视图解析器 -->  
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
        <!-- 前缀 -->  
        <property name="prefix">  
            <value>/WEB-INF/content/</value>  
        </property>  
        <!-- 后缀 -->  
        <property name="suffix">  
            <value>.jsp</value>  
        </property>  
    </bean>  
  
</beans>

还有缓存和日志的配置，这两个文件都是直接从别处拷过来的，暂时跟他们没有很大关系，这边也提供下

ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">  
   
    <diskStore path="java.io.tmpdir"/>  
  
    <!--  
    Mandatory Default Cache configuration. These settings will be applied to caches  
    created programmtically using CacheManager.add(String cacheName)  
    -->  
    <!--  
       name:缓存名称。  
       maxElementsInMemory：缓存最大个数。  
       eternal:对象是否永久有效，一但设置了，timeout将不起作用。  
       timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。  
       timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。  
       overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。  
       diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。  
       maxElementsOnDisk：硬盘最大缓存个数。  
       diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.  
       diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。  
       memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。  
       clearOnFlush：内存数量最大时是否清除。  
    -->  
    <defaultCache  
            maxElementsInMemory="10000"  
            eternal="false"  
            timeToIdleSeconds="120"  
            timeToLiveSeconds="120"  
            overflowToDisk="true"  
            maxElementsOnDisk="10000000"  
            diskPersistent="false"  
            diskExpiryThreadIntervalSeconds="120"  
            memoryStoreEvictionPolicy="LRU"  
            />  
</ehcache>

log4j.properties

# Global logging configuration
log4j.rootLogger=debug, stdout
# MyBatis logging configuration...
log4j.logger.org.fkit.mapper.UserMapper=DEBUG
log4j.logger.org.fkit.mapper.BookMapper=DEBUG
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

-------------------------------------------------------

3.为测试方便提供几个页面

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
	<h2>Login Page</h2>
	
	<form action="shiro/login" method="POST">
		username:<input type="text" name="username">
		<br><br>
		password:<input type="password" name="password">
		<br><br>
		<input type="submit" value="submit">
	</form>
</body>
</html>

list.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
	<h2>List Page</h2>
	<!-- 登出操作，为了方便测试，排查缓存影响-->
	<a href="shiro/logout">Logout</a>
</body>
</html>

unauthorized.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
	<h2>Unauthorized Page</h2>
</body>
</html>

user.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
	<h3>User Page</h3>
</body>
</html>

---------------------------------------------------------------

4.控制器ShiroController.java

package com.lin.controller;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
@RequestMapping("/shiro")
public class ShiroController {

	@RequestMapping("/login")
	public String login(@RequestParam String username,@RequestParam String password){
		//获取当前的Subject 。 调用SecurityUtils.getSubject()方法
		Subject currentUser = SecurityUtils.getSubject();
		
        //测试当前的用户是否是否已被认证，即是否登录
        //调用Subject的isAuthenticated()方法
        if (!currentUser.isAuthenticated()) {
        	//把用户名和密码封装为UsernamePasswordToken对象
            UsernamePasswordToken token = new UsernamePasswordToken(username, password);
            token.setRememberMe(true);
            try {
            	//此处调用的login方法中的参数token传到了我们自己实现的realm类中的token参数中
            	System.out.println("1."+token.hashCode());
            	//调用Subject的login()方法，执行登录（是否登录成功取决于配置文件中的用户名密码是否是上面配置的，此处可以登录成功！）
                currentUser.login(token);
            }
            //所有认证时异常的父类
            catch (AuthenticationException ae) {
               System.out.println("登录失败："+ ae.getMessage());
            }
        }
        
        return "redirect:/list.jsp";
	}
}

-------------------------------------------------------------

5.RealmTest.java

package com.lin.realm;

import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.LockedAccountException;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.realm.AuthenticatingRealm;

public class RealmTest extends AuthenticatingRealm{

	protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
//		//此处的参数是从Subject中的login方法传递过来的参数。
//		System.out.println("doGetAuthenticationInfo:"+"2."+token.hashCode());
		
		//1.把AuthenticationToken 转换为UsernamePasswordToken
		UsernamePasswordToken upToken = (UsernamePasswordToken) token;
		
		//2.从UsernamePasswordToken中来获取username
		String username = upToken.getUsername();
		
		//3.调用数据库的方法，从数据库中查询username对应的用户记录
		System.out.println("从数据库中获取username：" + username + "所对应的用户信息。");
		
		//4.若用户不存在，则可以抛出UnknownAccountException异常
		if("unknown".equals(username)){
			throw new UnknownAccountException("用户不存在！");
		}
		
		//5.根据用户信息的情况，决定是否需要抛出其他的AuthenticationException异常
		if("monster".equals(username)){
			throw new LockedAccountException("用户被锁定");
		}
		
		//6.根据用户的情况，来构建AuthenticationInfo对象并返回
		//以下信息是从数据库中获取的。
		//1)principals：认证的实体信息，可以是username，也可以是数据库表对应的用户的实体类对象
		Object principals = username;
		//2)credentials：密码
		Object credentials = "123456";
		//3)realmName：当前realm对象的name，调用父类的getName()方法即可
		String realmName = getName();
		
		SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(principals, credentials,realmName);
		
		return info;
	}	

}

====================================================

以上就是完整的代码，可运行。接下来测试一下：

这里注意一下在applicationContext.xml配置文件中配置的权限信息，如下

<!-- 
        	配置哪些页面需要受保护，
        	以及访问这些页面需要的权限。
        	1） anon表示 可以被匿名访问（anon实际上是一个过滤器）
        	2）authc表示 必须认证即登录后才可以访问的页面（authc也是一个过滤器）
         	3)logout表示登出
         -->
        <property name="filterChainDefinitions">
            <value>
                /login.jsp = anon
				/shiro/login = anon
				
				/shiro/logout = logout
				
                # everything else requires authentication:
                /** = authc
            </value>
        </property>

由上面可以知道，在没有登录通过之前，只能访问anon修饰的两个请求，也就是说，如果输入其他地址会重定向到login.jsp页面，这个过程由shiro来实现。。

登录成功后就可以在地址栏访问别的路径的页面了

Satisfy_555

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Shiro快速入门实例（登录认证）

说明：Shiro是Java的安全（权限框架），具体介绍我说不来也没必要多说，这是刚开始学习的一个东西，只是简单记录下已经测试可以运行的代码，这个示例还没有涉及到跟数据库的交互以及数据加密，暂时只是简单的认证功能。。目前正在学习这个框架……================================1.首先环境是使用 eclipse + Maven + Spring + Spring...
复制链接

扫一扫