Shiro之Realm认证授权介绍(三)

验证的理论过程

1、先获取当前的subject

//获取当前的subject
Subject currentUser = SecurityUtils.getSubject();

2、校验当前的subject是否已经被认证

currentUser.isAuthenticated()

3、若没有被认证
把用户名和密码封装为UsernamePasswordToken对象

  • 创建一个表单页面

  • 将请求提交到spring mvc的handler对象

  • 获取用户名和密码

4、执行登录。执行subject的login(AuthenticationToken)方法

5、自定义Realm方法,从数据库中获取对应的记录,返回给shiro

  • 实际上需要继承org.apache.shiro.realm.AuthorizingRealm类

  • 实现doGetAuthenticationInfo(AuthenticationToken authcToken)方法

6、由shiro完成对密码的比对

补充:

1)密码的比对是通过AuthorizingRealm的 credetialsMatcher属性来进行的密码比对

2)加密对比:

1、如何将一个字符串密码进行加密成MD5

2、替换当前Realm的credentialsMatcher属性,直接使用HashedCredentialsMatcher进行加密设置

操作实现

1、创建一个login.jsp

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>登录页面</title>
</head>
<body>
	<h1>login</h1>
	<form action="shiro/login" method="post">
		username:<input  type = "text" name = "username"/><br/><br/>
		password:<input  type = "text" name = "password"/><br/><br/>
		<input type="submit" value = "submit">
	</form>
</body>
</html>

2、创建一个handler(类似controller)

package com.example.handlers;

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 ShiroHandler {
	/**
	 * 登录方法,登录成功返回success页面
	 * 
	 * @param username:用户名
	 * @param password:密码
	 * @return
	 */
	@RequestMapping("/login")
	public String login(@RequestParam("username") String username, @RequestParam("password") String password) {
		Subject currentUser = SecurityUtils.getSubject();
		// 测试当前的用户是否登录,也就是是否被认证
		if (!currentUser.isAuthenticated()) {
			// 把用户名和密码封装为UsernamePasswordToken对象
			UsernamePasswordToken token = new UsernamePasswordToken(username, password);
			// RememberMe
			token.setRememberMe(true);
			try {
				// 执行登录
				currentUser.login(token);
			}
			// 认证的所有异常处理
			catch (AuthenticationException ae) {
				System.out.println("登录失败:"+ae.toString());
			}
		}
		return "redirect:/success.jsp";
	}
}

3、创建一个Realm,来实现登录(要在applicationContext-shiro中进行配置)
继承AuthenticatingRealm接口(若只实现认证)

继承AuthorizingRealm接口(实现认证和授权)

public class ShiroRealm extends AuthorizingRealm {

	@Override
	protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection arg0) {
		return null;
	}
	//认证回调函数 
	@Override
	protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
		System.out.println("doGetAuthenticationInfo:"+token);
		//1、把AuthenticationToken强转为UsernamePasswordToken
		UsernamePasswordToken t = (UsernamePasswordToken) token;
		//2、从t中获取用户名和密码
		String username = t.getUsername();
		//3、调用数据库的方法,从数据库查询对应的用户记录
		System.out.println("从数据库中取数据:"+username+"的用户信息为");
		//3.1小试一下就是来静态数据
		
		//4、若用户名不存在,抛出异常
		if (username.equals("unknown")) {
			System.out.println("登录失败,用户不存在");
			throw new UnknownAccountException("用户不存在");
		} 
		//5、根据用户信息的情况,看是否抛出其他异常
		if (username.equals("status_disable")) {
			System.out.println("登录失败,用户被禁用");
			throw new LockedAccountException("用户被禁用");
		} 
		//6、根据用户的情况,来构建AuthenticationToken对象并返回
		//6.1以下信息是从数据库中获取的
		//principals:认证的实体信息,可以是数据库中的实体类对象,可以是username
		Object principals = username;
		//credentials:从数据库获取的密码
		Object credentials = "123456";
		//realmName:当前realm对象的name,直接调用父类的getName()方法即可
		String realmName = getName();
		SimpleAuthenticationInfo simInfo = new SimpleAuthenticationInfo(principals, credentials,realmName);
		return simInfo;
	}

}

4、拦截设置(登录请求被拦截了)(在applicationContext-shiro配置中设置的)

<property name="filterChainDefinitions">
	<value>
		/login.jsp = anon
		/shiro/login = anon
        /shiro/loginout = logout
		/** = authc
	</value>
</property>

补充:(关于Realm的操作,对加密密码进行对比)
1、如何将一个字符串密码进行加密成MD5
2、替换当前Realm的credentialsMatcher属性,直接使用HashedCredentialsMatcher进行加密设置
在applicationContext-shiro.xml中配置Realm的时候进行配置

<!-- 3、配置realm,新建一个ShiroRealm类,实现Realm接口 -->
	<bean id="jdbcRealm" class="com.example.realms.ShiroRealm" >
		<property name="credentialsMatcher">
			<bean class = "org.apache.shiro.authc.credential.HashedCredentialsMatcher">
				<!-- 加密的算法 -->
				<property name="hashAlgorithmName" value="MD5"></property>
				<!-- 加密的次数 -->
				<property name="hashIterations" value="1024"></property>
			</bean>
		</property>
	
	</bean>

得知一个密码加密后的密码:

public static void main(String[] args) {
		String hashAlgorithmName = "MD5";
		Object credentials = "123456";
		Object salt = null;
		int hashIterations = 1024;
		System.out.println("加密前的密码:"+credentials);
		SimpleHash hash = new SimpleHash(hashAlgorithmName,credentials,salt,hashIterations);
		System.out.println("加密后的密码:"+hash);
	}

利用salt来实现盐值加密(两个用户密码相同,加密后的到的密码不同)

ByteSource.Util.bytes(username):一般使用唯一的那一个属性来进行加盐

//6、根据用户的情况,来构建AuthenticationToken对象并返回
//6.1以下信息是从数据库中获取的
//principals:认证的实体信息,可以是数据库中的实体类对象,可以是username
Object principals = username;
//credentials:从数据库获取的密码
Object credentials = "123456";
//realmName:当前realm对象的name,直接调用父类的getName()方法即可
String realmName = getName();
//salt来实现盐值加密,若username唯一,可以使用username来加盐
ByteSource credentialsSalt = ByteSource.Util.bytes(username)
SimpleAuthenticationInfo simInfo = new SimpleAuthenticationInfo(principals, credentials,credentialsSalt,realmName);
return simInfo;

多Realm

1、建立两个Realm(ShiroRealm与LoginRealm)

2、配置Realm(在applicationContext-shiro.xml文件中配置)

执行顺序会与配置文件中list中配置realm的顺序相同

	<bean id="securityManager"
		class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
		<property name="cacheManager" ref="cacheManager" />
		<property name="sessionMode" value="native" />
		<property name="authenticator" ref="modularRealmAuthenticator" />
	</bean>
 
     <!-- 认证器 -->
	<bean id="modularRealmAuthenticator" class="org.apache.shiro.authc.pam.ModularRealmAuthenticator">
		<property name="realms">
			<list>
				<ref bean="shiroRealm"/>
				<ref bean="loginRealm"/>
			</list>
		</property>
	</bean>


<!-- 3、配置realm,新建一个ShiroRealm类,实现Realm接口 -->
	<bean id="shiroRealm" class="com.example.realms.ShiroRealm" >
		<property name="credentialsMatcher">
			<bean class = "org.apache.shiro.authc.credential.HashedCredentialsMatcher">
				<!-- 加密的算法 -->
				<property name="hashAlgorithmName" value="MD5"></property>
				<!-- 加密的次数 -->
				<property name="hashIterations" value="1024"></property>
			</bean>
		</property>
	</bean>
	
	<bean id="loginRealm" class="com.example.realms.LoginRealm" >
		<property name="credentialsMatcher">
			<bean class = "org.apache.shiro.authc.credential.HashedCredentialsMatcher">
				<!-- 加密的算法 -->
				<property name="hashAlgorithmName" value="SHA1"></property>
				<!-- 加密的次数 -->
				<property name="hashIterations" value="1024"></property>
			</bean>
		</property>
	</bean>

认证策略 Authentication Strategy

Authentication Strategy接口的默认实现

  • FirstSuccessfulStrategy:只要有一个Ream验证成功即可,只返回笫一个Ream身份验证成功的认证信息,其他的忽略;

  • AtLeastoneSuccessfulStrategy:只要有一个Ream验证成功即可,和FirstSuccessful Strategy不同,将返回所有 Realm身份验证成功的认证信息

  • AllSuccessfulStrategy:所有Ream验证或功才算成功,且返回所有Ream身份验证成功的认证信息,如果有个失败就失败了。

默认是 AtLeastone SuccessfulStrateagy策略

<!-- 认证器 -->
<bean id="modularRealmAuthenticator" class="org.apache.shiro.authc.pam.ModularRealmAuthenticator">
	<property name="realms">
		<list>
			<ref bean="shiroRealm"/>
			<ref bean="loginRealm"/>
		</list>
	</property>
<!--该属性来修改认证策略-->
	<property name="authenticationStrategy" >
		<bean class="org.apache.shiro.authc.pam.FirstSuccessfulStrategy"></bean>
	</property>
</bean>

另一种方法就是全部写好,自己转换

<bean id="modularRealmAuthenticator" class="org.apache.shiro.authc.pam.ModularRealmAuthenticator">
    	<property name="authenticationStrategy" ref="firstSuccessfulStrategy"></property>
	</bean>
	<bean id="atLeastOneSuccessfulStrategy" class="org.apache.shiro.authc.pam.AtLeastOneSuccessfulStrategy"></bean><!-- 多realm策略:只要有一个(或更多)的Realm验证成功,那么认证将被视为成功 -->
	<bean id="firstSuccessfulStrategy" class="org.apache.shiro.authc.pam.FirstSuccessfulStrategy"></bean><!-- 多realm策略:第一个Realm验证成功,整体认证将被视为成功,且后续Realm将被忽略 -->
	<bean id="allSuccessfulStrategy" class="org.apache.shiro.authc.pam.AllSuccessfulStrategy"></bean><!-- 多realm策略:所有Realm成功,认证才视为成功 -->

授权

授权,也叫访问控制,即在应用中控制谁访问哪些资源〔如访问页面/编辑数据/面操作,在授权中需了解的几个关键对象:主体( Subject)、资源( Resource)、权限( Permission)、角色(Role)

  • 主体( Subject):访问应用的用户,在 Shiro中使用 Subject代表该用户。用户只有授权后才允许访问相应的资源。

  • 资源( Resource):在应用中用户可以访问的URL,比如访问JSP页面、查看/编辑某些数据、访问某个业务方法、打印文本等等都是资源。用户只要授权后才能访问。

  • 权限( Permission):安全策略中的原子授权单位,通过权限我们可以表示在应用中用户有没有操作某个资源的权力。即权限表示在应用中用户能不能访问某个资源,如:访问用户列表页面查看/新增/修改倗删除用户数据〔即很多时候都是CRUD(增查改删)式权限控制)等。权限代表了用户有没有操作某个资源的权利,即反映在某个资源上的操作允不允限〔如用户模块的所有权限)和细粒度权限

  • 角色(Role):一般情况下会赋予用户角色而不是权限,即这样用户可以拥有组权限,赋予权限时比较方便。典型的如:项目经理、技术总监、CTO、开发工程师等都是角色,不同的角色拥有一组不同的权限。
    在这里插入图片描述

在securityManager与modularRealmAuthenticator都可以进行Realm的配置
若想进行授权,需要在securityManager中配置而不是在modularRealmAuthenticator中配置

<bean id="securityManager"
	class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
		<property name="cacheManager" ref="cacheManager" />
		<property name="sessionMode" value="native" />
		<property name="authenticator" ref="modularRealmAuthenticator" />
		<property name="realms">
			<list>
				<ref bean="shiroRealm"/>
				<ref bean="loginRealm"/>
			</list>
		</property>
</bean>

授权需要继承AuthorizingRealm类,同时实现认证和授权

//用于授权的方法
	@Override
	protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principal) {
		//1、从principal获取用户登录信息
		Object primaryPrincipal = principal.getPrimaryPrincipal();
		//2、利用登录的用户信息来获取当前用户的信息和权限
		Set<String> roles = new HashSet<String>();
		roles.add("user");
		if(primaryPrincipal.equals("admin")) {
			roles.add("a");
		}
		//3、利用SimpleAuthorizationInfo,并设置roles属性
		SimpleAuthorizationInfo info = new SimpleAuthorizationInfo(roles);
		//4、返回SimpleAuthorizationInfo对象
		return info;
	}


public class ShiroRealm extends AuthorizingRealm {
	//用于授权的方法
	@Override
	protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principal) {
		//1、从principal获取用户登录信息
		Object primaryPrincipal = principal.getPrimaryPrincipal();
		//2、利用登录的用户信息来获取当前用户的信息和权限
		Set<String> roles = new HashSet<String>();
		roles.add("user");
		if(primaryPrincipal.equals("admin")) {
			roles.add("a");
		}
		//3、利用SimpleAuthorizationInfo,并设置roles属性
		SimpleAuthorizationInfo info = new SimpleAuthorizationInfo(roles);
		//4、返回SimpleAuthorizationInfo对象
		return info;
	}
	//认证回调函数 
	@Override
	protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
		System.out.println("第二个Relam:ShiroRealm");
		//1、把AuthenticationToken强转为UsernamePasswordToken
		UsernamePasswordToken t = (UsernamePasswordToken) token;
		//2、从t中获取用户名和密码
		String username = t.getUsername();
		//3、调用数据库的方法,从数据库查询对应的用户记录
		System.out.println("从数据库中取数据:"+username+"的用户信息为");
		//3.1小试一下就是来静态数据
		
		//4、若用户名不存在,抛出异常
		if (username.equals("unknown")) {
			System.out.println("登录失败,用户不存在");
			throw new UnknownAccountException("用户不存在");
		} 
		//5、根据用户信息的情况,看是否抛出其他异常
		if (username.equals("status_disable")) {
			System.out.println("登录失败,用户被禁用");
			throw new LockedAccountException("用户被禁用");
		} 
		//6、根据用户的情况,来构建AuthenticationToken对象并返回
		//6.1以下信息是从数据库中获取的
		//principals:认证的实体信息,可以是数据库中的实体类对象,可以是username
		Object principals = username;
		//credentials:从数据库获取的密码
		Object credentials = "123456";
		//realmName:当前realm对象的name,直接调用父类的getName()方法即可
		String realmName = getName();
		SimpleAuthenticationInfo simInfo = new SimpleAuthenticationInfo(principals, credentials,realmName);
		return simInfo;
	}
	public static void main(String[] args) {
		String hashAlgorithmName = "MD5";
		Object credentials = "123456";
		Object salt = null;
		int hashIterations = 1024;
		System.out.println("加密前的密码:"+credentials);
		SimpleHash hash = new SimpleHash(hashAlgorithmName,credentials,salt,hashIterations);
		System.out.println("加密后的密码:"+hash);
	}
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值