概述
简介
Shiro
是Apache旗下的一个开源项目,它是一个非常易用的安全框架,提供了包括认证、授权、加密、会话管理等功能,与Spring Security一样属基于权限的安全框架
,但是与Spring Security 相比,Shiro使用了比较简单易懂易于使用的授权方式。Shiro属于轻量级框架,相对于Spring Security简单很多,并没有security那么复杂。
Apache Shiro
是一个强大且易用的Java安全框架
可以完成身份验证、授权、密码和会话管理
Shiro 不仅可以用在 JavaSE 环境中,也可以用在 JavaEE 环境中
官网: http://shiro.apache.org/
功能
Authentication:身份认证/登录,验证用户是不是拥有相应的身份;
Authorization:授权,即权限验证,验证某个已认证的用户是否拥有某个权限;即判断用户是否能做事情,常见的如:验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限;
Session Manager:会话管理,即用户登录后就是一次会话,在没有退出之前,它的所有信息都在会话中;会话可以是普通JavaSE环境的,也可以是如Web环境的;
Cryptography:加密,保护数据的安全性,如密码加密存储到数据库,而不是明文存储;
Web Support:Web支持,可以非常容易的集成到Web环境;
Caching:缓存,比如用户登录后,其用户信息、拥有的角色/权限不必每次去查,这样可以提高效率;
Concurrency:shiro支持多线程应用的并发验证,即如在一个线程中开启另一个线程,能把权限自动传播过去;
Testing:提供测试支持;
Run As:允许一个用户假装为另一个用户(如果他们允许)的身份进行访问;
Remember Me:记住我,这个是非常常见的功能,即一次登录后,下次再来的话不用登录了。
从外部看(三个部分)
应用代码直接交互的对象是Subject,也就是说Shiro的对外API核心就是Subject;其每个API的含义:
Subject:主体,代表了当前“用户”,这个用户不一定是一个具体的人,与当前应用交互的任何东西都是Subject,如网络爬虫,机器人等;即一个抽象概念;所有Subject都绑定到SecurityManager,与Subject的所有交互都会委托给SecurityManager;可以把Subject认为是一个门面;SecurityManager才是实际的执行者;
SecurityManager:安全管理器;即所有与安全有关的操作都会与SecurityManager交互;且它管理着所有Subject;可以看出它是Shiro的核心,它负责与后边介绍的其他组件进行交互,如果学习过SpringMVC,你可以把它看成DispatcherServlet前端控制器;
Realm:域,Shiro从从Realm获取安全数据(如用户、角色、权限),就是说SecurityManager要验证用户身份,那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法;也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作;可以把Realm看成DataSource,即安全数据源。
也就是说对于我们而言,最简单的一个Shiro应用:
-
应用代码通过Subject来进行认证和授权,而Subject又委托给SecurityManager;
-
我们需要给Shiro的SecurityManager注入Realm,从而让SecurityManager能得到合法的用户及其权限进行判断。
从以上也可以看出,Shiro不提供维护用户/权限,而是通过Realm让开发人员自己注入.
外部架构
Subject:主体,可以看到主体可以是任何可以与应用交互的“用户”;
SecurityManager:相当于SpringMVC中的DispatcherServlet或者Struts2中的FilterDispatcher;是Shiro的心脏;所有具体的交互都通过SecurityManager进行控制;它管理着所有Subject、且负责进行认证和授权、及会话、缓存的管理。
Authenticator:认证器,负责主体认证的,这是一个扩展点,如果用户觉得Shiro默认的不好,可以自定义实现;其需要认证策略(Authentication Strategy),即什么情况下算用户认证通过了;
Authrizer:授权器,或者访问控制器,用来决定主体是否有权限进行相应的操作;即控制着用户能访问应用中的哪些功能;
Realm:可以有1个或多个Realm,可以认为是安全实体数据源,即用于获取安全实体的;可以是JDBC实现,也可以是LDAP实现,或者内存实现等等;由用户提供;注意:Shiro不知道你的用户/权限存储在哪及以何种格式存储;所以我们一般在应用中都需要实现自己的Realm;
SessionManager:如果写过Servlet就应该知道Session的概念,Session呢需要有人去管理它的生命周期,这个组件就是SessionManager;而Shiro并不仅仅可以用在Web环境,也可以用在如普通的JavaSE环境、EJB等环境;所有呢,Shiro就抽象了一个自己的Session来管理主体与应用之间交互的数据;这样的话,比如我们在Web环境用,刚开始是一台Web服务器;接着又上了台EJB服务器;这时想把两台服务器的会话数据放到一个地方,这个时候就可以实现自己的分布式会话(如把数据放到Memcached服务器);
SessionDAO:DAO大家都用过,数据访问对象,用于会话的CRUD,比如我们想把Session保存到数据库,那么可以实现自己的SessionDAO,通过如JDBC写到数据库;比如想把Session放到Memcached中,可以实现自己的Memcached SessionDAO;另外SessionDAO中可以使用Cache进行缓存,以提高性能;
CacheManager:缓存控制器,来管理如用户、角色、权限等的缓存的;因为这些数据基本上很少去改变,放到缓存中后可以提高访问的性能
Cryptography:密码模块,Shiro提高了一些常见的加密组件用于如密码加密/解密的
认证流程
用户 提交 身份信息、凭证信息 封装成 令牌 交由 安全管理器 认证
快速入门
1. 拷贝案例(我们通过官网入门案例去学习)
1、按照官网提示找到 快速入门案例
GitHub地址:
shiro/samples/quickstart/
,从GitHub 的文件中可以看出这个快速入门案例是一个 Maven 项目
2、新建一个 Maven 工程,删除其 src 目录,将其作为父工程
3、在父工程中新建一个 Maven 模块
4、复制快速入门案例 POM.xml 文件中的依赖 (版本号自选)
<dependencies>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
<version>1.4.1</version>
</dependency>
<!-- configure logging -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>1.7.21</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.21</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
</dependencies>
5、把快速入门案例中的 resource 下的log4j.properties 复制下来(shiro默认的日志支持是org/apache/commons-logging
)
6、复制一下 shiro.ini 文件
7、复制一下 Quickstart.java 文件
如果有导包的错误,把那两个错误的包删掉,就会自动导对的包了,快速入门案例中用的方法过时了
8、运行 Quickstart.java,得到结果
2. 分析案例
Quickstart.java
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.Factory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Simple Quickstart application showing how to use Shiro's API.
*
* @since 0.9 RC2
*/
public class Quickstart {
private static final transient Logger log = LoggerFactory.getLogger(Quickstart.class);
public static void main(String[] args) {
// The easiest way to create a Shiro SecurityManager with configured
// realms, users, roles and permissions is to use the simple INI config.
// We'll do that by using a factory that can ingest a .ini file and
// return a SecurityManager instance:
// Use the shiro.ini file at the root of the classpath
// (file: and url: prefixes load from files and urls respectively):
Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");
SecurityManager securityManager = factory.getInstance();
// for this simple example quickstart, make the SecurityManager
// accessible as a JVM singleton. Most applications wouldn't do this
// and instead rely on their container configuration or web.xml for
// webapps. That is outside the scope of this simple quickstart, so
// we'll just do the bare minimum so you can continue to get a feel
// for things.
SecurityUtils.setSecurityManager(securityManager);
// Now that a simple Shiro environment is set up, let's see what you can do:
// get the currently executing user:
Subject currentUser = SecurityUtils.getSubject();
// Do some stuff with a Session (no need for a web or EJB container!!!)
Session session = currentUser.getSession();
session.setAttribute("someKey", "aValue");
String value = (String) session.getAttribute("someKey");
if (value.equals("aValue")) {
log.info("Retrieved the correct value! [" + value + "]");
}
// let's login the current user so we can check against roles and permissions:
if (!currentUser.isAuthenticated()) {
UsernamePasswordToken token = new UsernamePasswordToken("lonestarr", "vespa");
token.setRememberMe(true);
try {
currentUser.login(token);
} catch (UnknownAccountException uae) {
log.info("There is no user with username of " + token.getPrincipal());
} catch (IncorrectCredentialsException ice) {
log.info("Password for account " + token.getPrincipal() + " was incorrect!");
} catch (LockedAccountException lae) {
log.info("The account for username " + token.getPrincipal() + " is locked. " +
"Please contact your administrator to unlock it.");
}
// ... catch more exceptions here (maybe custom ones specific to your application?
catch (AuthenticationException ae) {
//unexpected condition? error?
}
}
//say who they are:
//print their identifying principal (in this case, a username):
log.info("User [" + currentUser.getPrincipal() + "] logged in successfully.");
//test a role:
if (currentUser.hasRole("schwartz")) {
log.info("May the Schwartz be with you!");
} else {
log.info("Hello, mere mortal.");
}
//test a typed permission (not instance-level)
if (currentUser.isPermitted("lightsaber:wield")) {
log.info("You may use a lightsaber ring. Use it wisely.");
} else {
log.info("Sorry, lightsaber rings are for schwartz masters only.");
}
//a (very powerful) Instance Level permission:
if (currentUser.isPermitted("winnebago:drive:eagle5")) {
log.info("You are permitted to 'drive' the winnebago with license plate (id) 'eagle5'. " +
"Here are the keys - have fun!");
} else {
log.info("Sorry, you aren't allowed to drive the 'eagle5' winnebago!");
}
//all done - log out!
currentUser.logout();
System.exit(0);
}
}
1、通过 SecurityUtils 获取当前执行的用户Subject
Subject currentUser = SecurityUtils.getSubject();
2、通过 当前用户拿到 Session
Session session = currentUser.getSession();
3、用 Session 存值取值
// 存值
session.setAttribute("someKey", "aValue");
//取值
String value = (String) session.getAttribute("someKey");
4、判断用户是否被认证
currentUser.isAuthenticated()
5、执行登录操作
currentUser.login(token);
6、打印其标识主体
currentUser.getPrincipal()
7、注销
currentUser.logout();
8、总览(Quickstart.java)
备注:我们学习如何使用的时候可以下载她的源码,然后找到samples目录下,有很多对应的案例!
3. SpringBoot 集成 Shiro
1. 编写配置文件
-
在刚刚的父项目中新建一个 springboot 模块
-
导入 SpringBoot 和 Shiro 整合包的依赖
<!--SpringBoot 和 Shiro 整合包-->
<!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-spring-boot-web-starter -->
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring-boot-web-starter</artifactId>
<version>1.6.0</version>
</dependency>
注: 编写配置文件Shiro 三大要素(重要)
- 用户subject ->对应: ShiroFilterFactoryBean类
- 管理所有用户securityManager ->对应: DefaultWebSecurityManager类
- 连接数据realm
实际操作中三个类对象创建的顺序 : realm -> securityManager -> subject
- 编写自定义的 realm ,需要继承 AuthorizingRealm
//自定义的 Realm
public class UserRealm extends AuthorizingRealm {
//授权
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
//打印一个提示
System.out.println("执行了授权方法");
return null;
}
//认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
//打印一个提示
System.out.println("执行了认证方法");
return null;
}
}
2. 新建一个 ShiroConfig配置类
创建的顺序 : realm -> securityManager -> subject
- 创建 Realm
//这就是realm
//让 spring 托管自定义的 realm 类
@Bean
public UserRealm userRealm(){
return new UserRealm();
}
- 创建 securityManager, 且需要传入一个 Realm
// securityManager ->对应 DefaultWebSecurityManager
// @Qualifier("userRealm") 指定 Bean 的名字为 userRealm
// spring 默认的 BeanName 就是方法名
// name 属性 指定 BeanName
@Bean(name = "SecurityManager")
public DefaultWebSecurityManager getDefaultWebSecurity(@Qualifier("userRealm") UserRealm userRealm){
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
//需要关联自定义的 Realm,通过参数把 Realm 对象传递过来
securityManager.setRealm(userRealm);
return securityManager;
}
- 创建 subject,且需要传入一个 securityManager
// subject ->对应 ShiroFilterFactoryBean
// @Qualifier("securityManager") 指定 Bean 的名字为 securityManager
@Bean(name = "shiroFilterFactoryBean")
public ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("SecurityManager") DefaultWebSecurityManager securityManager){
ShiroFilterFactoryBean subject = new ShiroFilterFactoryBean();
//设置安全管理器
//需要关联 securityManager ,通过参数把 securityManager 对象传递过来
subject.setSecurityManager(securityManager);
return subject;
}
完整代码:(这是死套路)
3. 搭建简单测试环境
- 新建一个登录页面
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<H1>登录页面</H1>
<form >
用户名<input type="text" name="username">
密码<input type="password" name="password">
<input type="submit">
</form>
</body>
</html>
- 新建一个
首页index.html
,
首页上有三个链接,一个登录,一个增加用户,一个更新用户
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>首页</h1>
<h1 th:text="${msg}"></h1>
<a th:href="@{/user/add}">add</a>
<hr>
<a th:href="@{/user/update}">update</a>
</body>
</html>
- 新建一个增加用户页面
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>add</h1>
</body>
</html>
4.新建一个更新用户页面
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>update</h1>
</body>
</html>
- 编写对应的 Controller
package com.example.shirospringboot.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class MyController {
@RequestMapping({"/","index"})
public String index(Model model){
model.addAttribute("msg","hello shiro");
return "index";
}
@RequestMapping("/user/add")
public String add(){
return "user/add";
}
@RequestMapping("/user/update")
public String update(){
return "user/update";
}
@RequestMapping("/tologin")
public String login(){
return "login";
}
}
访问主页后:
4. 使用shiro / 加入shiro集成
加入登录拦截功能
- 加入登录拦截
getShiroFilterFactoryBean
在getShiroFilterFactoryBean 方法
中加上需要拦截的登录请求
@Bean(name = "shiroFilterFactoryBean")
public ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("SecurityManager") DefaultWebSecurityManager securityManager){
ShiroFilterFactoryBean subject = new ShiroFilterFactoryBean();
subject.setSecurityManager(securityManager);
//添加 Shiro 的 5种内置过滤器=======================
/*
anon : 无需认证,就可以访问
authc : 必须认证,才能访问
user : 必须拥有 “记住我”功能才能用
perms : 拥有对某个资源的权限才能访问
role : 拥有某个角色权限才能访问
*/
Map<String, String> map = new LinkedHashMap<>();
// 设置 /user/addUser 这个请求,只有认证过才能访问
// map.put("/user/addUser","authc");
// map.put("/user/deleteUser","authc");
// 设置 /user/ 下面的所有请求,只有认证过才能访问
map.put("/user/*","authc");
subject.setFilterChainDefinitionMap(map);
// 设置登录的请求
subject.setLoginUrl("/tologin");
//============================================
return subject;
}
测试:点击 addUser 链接,不会跳到 addUser 页面,而是跳到登录页,拦截成功,因为getShiroFilterFactoryBean 方法中设置了!
加入用户认证功能
- 在 Controller 中新增一个登录的Controller
//登录的方法
@RequestMapping("/login")
public String login(String username, String password, Model model) {
//获取当前用户
Subject subject = SecurityUtils.getSubject();
//没有认证过
//封装用户的登录数据,获得令牌
UsernamePasswordToken token = new UsernamePasswordToken(username, password);
System.out.println("执行了获取token方法");
//登录 及 异常处理
try {
//用户登录
subject.login(token); //这句代码底层调用了UserRealm 中的 AuthenticationInfo
return "index";
} catch (UnknownAccountException uae) {
//如果用户名不存在
System.out.println("账户不存在");
model.addAttribute("exception", "账户不存在");
return "login";
} catch (IncorrectCredentialsException ice) {
//如果密码错误
System.out.println("密码错误");
model.addAttribute("exception", "密码错误");
return "login";
}
}
-
重启,访问http://www.localhost:8080/,然后点击add页面
输入账号密码登录后,查询控制台输出:
结论:点击add,(因为getShiroFilterFactoryBean 拦截)进入登录页面后,输入账户密码点击提交操作:代码先执行了Controller中的UsernamePasswordToken token = new UsernamePasswordToken(username, password);再执行subject.login(token)登录的相关操作(//这句代码底层先调用了UserRealm 中的 AuthenticationInfo),即先执行了获取token,然后去自定义的 UserRealm 中的 AuthenticationInfo 方法中去获取用户信息
-
修改 UserRealm 中的 AuthenticationInfo
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
//打印一个提示
System.out.println("执行了认证方法");
// 用户名密码(暂时先自定义一个做测试)
String name = "root";
String password = "1234";
//通过参数获取登录的控制器中生成的 令牌
UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
//用户名认证
if (!token.getUsername().equals(name)){
// return null 就表示控制器中抛出的相关异常
return null;
}
//密码认证, Shiro 自己做,为了避免和密码的接触
//最后返回一个 AuthenticationInfo 接口的实现类,这里选择 SimpleAuthenticationInfo
// 三个参数:获取当前用户的认证 ; 密码 ; 认证名
return new SimpleAuthenticationInfo("", password, "");
}
- 测试:
- 输入错误的密码时:
- 输入正确的密码时,登录成功,且可以进入add和update这两个页面
加入退出登录功能
- 在控制器controller中添加一个退出登录的方法
//退出登录
@RequestMapping("/logout")
public String logout(){
Subject subject = SecurityUtils.getSubject();
subject.logout();
return "login";
}
- 测试,发现测试成功!
4、整合数据库(mybatis)
1.导入 Mybatis 相关依赖
<!-- 引入 myBatis,这是 MyBatis官方提供的适配 Spring Boot 的,而不是Spring
Boot自己的-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.0</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.12</version>
</dependency>
2.编写配置文件 -连接配置application.yml,及log4j配置文件(略)
spring:
datasource:
username: root
password: 123456
#?serverTimezone=UTC解决时区的报错
url: jdbc:mysql://localhost:3306/springboot?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
driver-class-name: com.mysql.cj.jdbc.Driver
type: com.alibaba.druid.pool.DruidDataSource
#Spring Boot 默认是不注入这些属性值的,需要自己绑定
#druid 数据源专有配置
initialSize: 5
minIdle: 5
maxActive: 20
maxWait: 60000
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 300000
validationQuery: SELECT 1 FROM DUAL
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
poolPreparedStatements: true
#配置监控统计拦截的filters,stat:监控统计、log4j:日志记录、wall:防御sql注入
#如果允许时报错 java.lang.ClassNotFoundException: org.apache.log4j.Priority
#则导入 log4j 依赖即可,Maven 地址:https://mvnrepository.com/artifact/log4j/log4j
filters: stat,wall,log4j
maxPoolPreparedStatementPerConnectionSize: 20
useGlobalDataSourceStat: true
connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
3.编写mybatis的配置
4.编写实体类 ,引入Lombok
5.编写Mapper接口[这里的mapper即之前的Dao层]
6.编写Mapper配置文件
7. 编写UserService 层
8. 一口气写了这些常规操作,可以去测试一下了,保证能够从数据库中查询出来。
完全OK,成功查询出来了!
9.改造UserRealm,连接到数据库进行真实的操作!
controller.java不变
package com.example.shirospringboot.controller;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class MyController {
@RequestMapping({"/","index"})
public String index(Model model){
model.addAttribute("msg","hello shiro");
return "index";
}
@RequestMapping("/user/add")
public String add(){
return "user/add";
}
@RequestMapping("/user/update")
public String update(){
return "user/update";
}
@RequestMapping("/tologin")
public String toLogin(){
return "login";
}
@PostMapping("/login")
public String login(String username,String password,Model model){
Subject subject = SecurityUtils.getSubject();
UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(username, password);
System.out.println("执行了获取token方法");
try {
subject.login(usernamePasswordToken);
return "index";
} catch (
UnknownAccountException uae) {
System.out.println("账户不存在");
model.addAttribute("msg","账户不存在");
return "login";
} catch (
IncorrectCredentialsException ice) {
model.addAttribute("msg","密码错误");
return "login";
}
}
}
- ShiroConfig.java不变
package com.example.shirospringboot.config;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
@Configuration
public class ShiroConfig {
@Bean(name = "shiroFilterFactoryBean")
public ShiroFilterFactoryBean getShiroFilterFactoryBean( DefaultWebSecurityManager securityManager){
ShiroFilterFactoryBean subject = new ShiroFilterFactoryBean();
//设置安全管理器
//需要关联 securityManager ,通过参数把 securityManager 对象传递过来
subject.setSecurityManager(securityManager);
//添加 Shiro 的内置过滤器=======================
/*
anon : 无需认证,就可以访问
authc : 必须认证,才能访问
user : 必须拥有 “记住我”功能才能用
perms : 拥有对某个资源的权限才能访问
role : 拥有某个角色权限才能访问
*/
Map<String, String> map = new LinkedHashMap<>();
map.put("/user/add","authc");
map.put("/user/update","authc");
subject.setFilterChainDefinitionMap(map);
subject.setLoginUrl("/tologin");
return subject;
}
@Bean(name = "securityManager")
public DefaultSecurityManager getDefaultSecurityManager(@Qualifier("userRealm") UserRealm userRealm){
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
//需要关联自定义的 Realm,通过参数把 Realm 对象传递过来
securityManager.setRealm(userRealm);
return securityManager;
}
@Bean(name = "userRealm")
public UserRealm userRealm(){
return new UserRealm();
}
}
测试流程:①首先进入http://www.localhost:8080/
②点击add,进入登录页面
③输入数据库中已有的账户和密码,点击提交,登录成功,进入index.html,且点击add,可以进去add页面
测试项目目录:
个人理解:
5、用户授权
首先在getShiroFilterFactoryBean方法
中加入授权代码:
package com.example.shirospringboot.config;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
@Configuration
public class ShiroConfig {
@Bean(name = "shiroFilterFactoryBean")
public ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("securityManager")DefaultWebSecurityManager securityManager){
ShiroFilterFactoryBean subject = new ShiroFilterFactoryBean();
//设置安全管理器
//需要关联 securityManager ,通过参数把 securityManager 对象传递过来
subject.setSecurityManager(securityManager);
//添加 Shiro 的内置过滤器=======================
/*
anon : 无需认证,就可以访问
authc : 必须认证,才能访问
user : 必须拥有 “记住我”功能才能用
perms : 拥有对某个资源的权限才能访问
role : 拥有某个角色权限才能访问
*/
//必须认证才能访问
Map<String, String> map = new LinkedHashMap<>();
map.put("/user/add","authc"); //authc : 必须认证,才能访问
map.put("/user/update","authc");
subject.setFilterChainDefinitionMap(map);
subject.setLoginUrl("/tologin");
//授权过滤器
map.put("/user/add","perms[user:add]"); //perms : 拥有对某个资源的权限才能访问
subject.setUnauthorizedUrl("/noauth"); //在shiroFilterFactoryBean中配置一个未授权的请求页面!不配置的话,shiro会自动跳转到未授权界面,但是我们没有这个界面,所以会报错401
return subject;
}
@Bean(name = "securityManager")
public DefaultSecurityManager getDefaultSecurityManager(@Qualifier("userRealm") UserRealm userRealm){
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
//需要关联自定义的 Realm,通过参数把 Realm 对象传递过来
securityManager.setRealm(userRealm);
return securityManager;
}
@Bean(name = "userRealm")
public UserRealm userRealm(){
return new UserRealm();
}
}
在controller代码中加入
@RequestMapping("/noauth")
@ResponseBody
public String noauth(){
return "未授权不能访问";
}
启动测试:
进入首页,点击add,弹出登录框,登录成功,返回index页面,然后点击add(因为没有权限),页面跳转提示:“未授权不能访问”
当代码不加 subject.setUnauthorizedUrl("/noauth");
时,进入add就会显示这样:
现在我们在UserRealm中给用户授权:
package com.example.shirospringboot.config;
import com.example.shirospringboot.pojo.User;
import com.example.shirospringboot.service.UserService;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.authc.credential.Md5CredentialsMatcher;
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 org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
//自定义realm
public class UserRealm extends AuthorizingRealm {
@Autowired
UserService userService;
//授权
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
System.out.println("执行了授权方法");
SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
simpleAuthorizationInfo.addStringPermission("user:add");
return simpleAuthorizationInfo;
}
//认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
System.out.println("执行了认证方法");
// String username = "yff";
// String password = "123456";
UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
User user = userService.queryUserByName(token.getUsername());
if (user == null) {
return null;
}
// if (!token.getUsername().equals(username)){
// return null;
// }
// Subject subject = SecurityUtils.getSubject();
// Object principal = subject.getPrincipal();
// this.setCredentialsMatcher(new Md5CredentialsMatcher());
return new SimpleAuthenticationInfo(user, user.getPwd(), "");
}
}
这里授权写死了,所有的用户都会走这个方法,都会进去add页面,这是一个问题,我们可以通过在数据库中user对象增加权限字段perms,通过数据库取值:
ShiroConfig.java
package com.example.shirospringboot.config;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
@Configuration
public class ShiroConfig {
@Bean(name = "shiroFilterFactoryBean")
public ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("securityManager")DefaultWebSecurityManager securityManager){
ShiroFilterFactoryBean subject = new ShiroFilterFactoryBean();
//设置安全管理器
//需要关联 securityManager ,通过参数把 securityManager 对象传递过来
subject.setSecurityManager(securityManager);
//添加 Shiro 的内置过滤器=======================
/*
anon : 无需认证,就可以访问
authc : 必须认证,才能访问
user : 必须拥有 “记住我”功能才能用
perms : 拥有对某个资源的权限才能访问
role : 拥有某个角色权限才能访问
*/
//必须认证才能访问
Map<String, String> map = new LinkedHashMap<>();
map.put("/user/add","authc");
map.put("/user/update","authc");
subject.setFilterChainDefinitionMap(map);
subject.setLoginUrl("/tologin");
//授权过滤器
map.put("/user/add","perms[user:add]"); //perms : 拥有对某个资源的权限才能访问
map.put("/user/update","perms[user:update]"); //perms : 拥有对某个资源的权限才能访问
subject.setUnauthorizedUrl("/noauth");
return subject;
}
@Bean(name = "securityManager")
public DefaultSecurityManager getDefaultSecurityManager(@Qualifier("userRealm") UserRealm userRealm){
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
//需要关联自定义的 Realm,通过参数把 Realm 对象传递过来
securityManager.setRealm(userRealm);
return securityManager;
}
@Bean(name = "userRealm")
public UserRealm userRealm(){
return new UserRealm();
}
}
UserRealm.java
package com.example.shirospringboot.config;
import com.example.shirospringboot.pojo.User;
import com.example.shirospringboot.service.UserService;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.authc.credential.Md5CredentialsMatcher;
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 org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
//自定义realm
public class UserRealm extends AuthorizingRealm {
@Autowired
UserService userService;
//授权
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
System.out.println("执行了授权方法");
SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
// simpleAuthorizationInfo.addStringPermission("user:add");
Subject subject = SecurityUtils.getSubject(); //获取当前对象
User currentUser = (User) subject.getPrincipal(); //拿到user对象
simpleAuthorizationInfo.addStringPermission(currentUser.getPerms()); //添加授权,直接在数据库中拿到perms字段的值,与getShiroFilterFactoryBean进行授权对比,ok可以访问
return simpleAuthorizationInfo;
}
//认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
System.out.println("执行了认证方法");
// String username = "yff";
// String password = "123456";
UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
User user = userService.queryUserByName(token.getUsername());
if (user == null) {
return null;
}
// if (!token.getUsername().equals(username)){
// return null;
// }
// Subject subject = SecurityUtils.getSubject();
// Object principal = subject.getPrincipal();
// this.setCredentialsMatcher(new Md5CredentialsMatcher());
return new SimpleAuthenticationInfo(user, user.getPwd(), ""); //修改这里在Principal存放了user对象,可以在授权中拿到
}
}
测试,进入首页点击add,使用test账户登录成功,返回首页,点击add和update,出现不同页面:
数据库:
点击add(有权限)
点击update(没权限)
6、整合Thymeleaf
(根据权限展示不同的前端页面)
1、添加依赖
(类似SpringSecurity的jar:thymeleaf-extras-springsecurity5):
<dependency>
<groupId>com.github.theborakompanioni</groupId>
<artifactId>thymeleaf-extras-shiro</artifactId>
<version>2.0.0</version>
</dependency>
2、配置一个shiro的Dialect ,在shiro的配置中增加一个Bean(必须要)
//配置ShiroDialect:方言,用于 thymeleaf 和 shiro 标签配合使用
@Bean
public ShiroDialect getShiroDialect(){
return new ShiroDialect();
}
3、修改前端index.html(仔细看里面逻辑)
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" xmlns:shiro="http://www.thymeleaf.org/thymeleaf-extras-shiro">
//导入thymeleaf-extras-shiro命名空间
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>首页</h1>
<h1 th:text="${msg}"></h1>
<div th:if="${session.loginuser == null}"> //从session中取值进行判断,是否显示“登录”的按钮
<a th:href="@{tologin}">登录</a>
</div>
<div shiro:hasPermission="user:add"> //有权限才显示add链接
<a th:href="@{/user/add}">add</a>
</div>
<hr>
<div shiro:hasPermission="user:update"> //有权限才显示update链接
<a th:href="@{/user/update}">update</a>
</div>
</body>
</html>
4、在UserRealm类的doGetAuthenticationInfo方法中,加入session:
测试:
登录的账户有什么权限就显示什么页面,登录成功后,登录按钮也不会再显示!
Shiro完结寄语:
今天花了一天时间给大家讲解了 SpringSecurity 和 Shiro 两个安全的框架,主要是想让大家多一些思路,其实什么都不用,我们靠拦截器也可以实现这些功能对吧,但是可能需要花费大量的时间和代码, 还有就是Bug 多,思考不全,而现在,我们两个框架都会使用了,也给大家对比的进行学习了,当然真实的工作中,可能代码会更加的复杂。需要大家在工作中再多去练习和使用,将这些框架可以运用到自己的项目中才是王道,不然学了也是白学对吧,几天就忘记了,没有什么用,关于底层的实现原理,也希望大家下去可以多看源码学习,
感谢观看!!