Apache shiro 安全框架入门学习
目录
前言
此文章为自己学习Shiro框架做学习笔记之用，从shiro涉及到的几个概念的讲解，到简单的单元测试，最后实现权限框架的搭建及测试 ,文中涉及到的项目GitHub地址:https://github.com/1216656953/conm.git
一、什么是Apache Shiro？
Apache Shiro 是ASF旗下的一款开源软件，它是一个功能强大且易于使用的Java安全框架。Shiro将目标集中于Shiro开发团队所称的“四大安全基石”-认证（Authentication）、授权（Authorization）、会话管理（Session Management）和加密（Cryptography）
二、核心概念介绍及架构
1.整体框架图
2.核心概念
1、subject（主题）：代表了正在操作的当前“用户”，这个用户并不一定是人也也可以指第三方系统或任何类似的东西。一旦您获得了主题，您就可以立即访问当前用户使用Shiro想要做的90%的事情，比如登录、注销、访问他们的会话、执行授权检查等。
2、securityManager(安全管理器)：它是shiro的核心，所有与安全有关的操作都会与securityManager进行交互，他管理shiro架构图中的所有模块，包括缓存管理，会话管理 ,Realm等等。
3、realm（数据域）：可以看作是JDBC，充当Shiro和应用程序安全数据之间的“桥梁”，当实际需要与安全相关的数据(如用户帐户)进行交互以执行身份验证(登录)和授权(访问控制)时，Shiro会从一个或多个为应用程序配置的领域中查找这些内容。realm可以有多个，但是至少得有一个。Shiro提供了开箱即用的realm，可以连接到许多安全数据源，如LDAP、关系数据库(JDBC)、文本配置源(如INI)和属性文件，等等。如果默认的realm(固定数据库表结构)不满足您的需求，可以添加您自己的领域实现来表示自定义数据源。
4、Authenticator（登录认证器）：负责主体登录认证的，如果用户觉得 Shiro 默认的 不好，可以自定义实现；其需要认证策略（Authentication Strategy），即什么情况下算用户认证通过了
5、Authrizer（访问控制器）：用来决定主题是否有权限进行相应的操作，即控制什么角色的主题或什么权限的主题能进行当前操作
6、SessionManager（会话管理器）：Session 需要有人去管理 它的生命周期，这个组件就是 SessionManager；而 Shiro 并不仅仅可以用在 Web 环境，也 可以用在如普通的 JavaSE 环境、EJB 等环境；所有呢，Shiro 就抽象了一个自己的 Session 来管理主体与应用之间交互的数据；这样的话，比如我们在 Web 环境用，刚开始是一台 Web 服务器；接着又上了台 EJB 服务器；这时想把两台服务器的会话数据放到一个地方， 这个时候就可以实现自己的分布式会话（如把数据放到 Rediscached 服务器）
7、SessionDAO（会话持久）：DAO 大家都用过，数据访问对象，用于会话的CRUD，比如我们想把 Session 保存到数据库，那么可以实现自己的 SessionDAO，通过JDBC 写到数据库；还可以把 Session 放到缓存 中，可以在SessionDao中设置RedisCacheManager缓存管理器 ，当服务重启的时候，当前登录的用户就不用因为session丢失而重新登录
8、CacheManager（缓存控制器）：管理如会话、用户、角色、权限等的缓存的；因为这些数据基本 上很少去改变，放到缓存中后可以提高访问的性能
9、Cryptography：密码模块，Shiro 提高了一些常见的加密组件用于如密码加密/解密的
3.整体功能
1、Authentication：身份认证
2、Authorization：权限校验
3、AuthorizationFilter：过滤器
4、SessionManager：会话管理，用户从登录到退出是一次会话，所有的信息都保存在会话中。普通的java se环境中也支持
5、cryptography：数据加密，如对用户密码进行加密，避免将密码明文存入数据库中。
6、Web support：非常容易集成到web环境中。
7、Caching：缓存，将用户信息和角色权限等缓存起来，不必每次去查
8、Concurrency：支持多线程，在一个线程中开启新的线程，能把权限传过去。
9、Testing：提供测试功能
10、Run As：允许一个用户假装为另一个用户的身份进行访问。
11、Remember me： 记住用户，一次登录后下次不用登录。
三、功能详解
1、Authentication：身份认证（登录）
使用principals（身份，也就是账号）和credentials（证明，密码或者证书）来对用户进行认证。
①.身份认证的流程图
②.身份认证的具体流程
- 首先用户在Controller层中获取用户输入的账号及密码，根据账号信息，初始化一个UsernamePasswordToken
- 调用 Subject.login(token)进行登录，其会自动委托给 SecurityManager
- SecurityManager 负责真正的身份验证逻辑；它会委托给他所管理的 Authenticator 进行身份验证；
- Authenticator 才是真正的身份验证者，Shiro API 中核心的身份认证入口点，开发者可以自定义插入自己的实现；
- Authenticator 可能会委托给相应的 AuthenticationStrategy 进行多 Realm 身份验证，默认ModularRealmAuthenticator 会调用 AuthenticationStrategy 进行多 Realm 身份验证；
- Authenticator 会把相应的 token 传入 Realm，这里的Realm一般都是根据自己的业务需求自定义的Realm，Realm从数据库或ini文件中获取用户的真实credentials（密码），此处可以配置多个 Realm，将按照相应的顺序及策略进行访问。Realm再根据其中的CredentialsMatcher进行密码校验
- CredentialsMatcher是realm中的密码校验器，默认类型SimpleCredentialsMatcher只比较realm中token的密码和数据库查找出来的密码文本内容是否一致，而现实业务中的密码不可能明文存储，一般都是加密过后的，需要自定义CredentialsMatcher，比如HashedCredentialsMatcher，如果密码匹配通过则返回True,否则抛出异常。开发需要在subject.login外层加try-catch捕获这些异常，从而来判断是否登录成功，是否密码错误或用户不存在等各种情况
2、权限校验
①.授权相关的几个关键对象：
- 主体（Subject）：在 Shiro 中使用 Subject 代表该用户。用户只有授权后才允许访 问相应的资源
- 资源（Resource）：系统中所有可以访问的东西，如页面、按钮、链接、数据等
- 权限（Permission）：安全策略中的原子授权单位，通过权限我们可以表示在应用中用户有没有操作某个资源的 权力。即权限表示在应用中用户能不能访问某个资源
- 角色（Role）：可以理解为权限集合，一般情况下我们会赋予用户角色而不是权 限，即这样用户可以拥有一组权限，赋予权限时比较方便
②.授权流程图
③.授权流程详细
- 首先调用 Subject.isPermitted*/hasRole*接口，其会委托给 SecurityManager，而 SecurityManager 接着会委托给 Authorizer
- Authorizer 是真正的授权者，如果我们调用如 isPermitted(“user:view”)，其首先会通过 PermissionResolver 把字符串转换成相应的 Permission 实例
- 在进行授权之前，其会调用相应的 Realm 获取 Subject 相应的角色/权限用于匹配传入的 角色/权限
- Authorizer 会判断 Realm 的角色/权限是否和传入的匹配，如果有多个 Realm，会委托给 ModularRealmAuthorizer 进行循环判断，如果匹配如 isPermitted*/hasRole*会返回 true，否则返回 false 表示授权失败
④.ModularRealmAuthorizer 进行多 Realm 匹配流程：
- 首先检查相应的 Realm 是否实现了实现了 Authorizer；
- 如果实现了 Authorizer，那么接着调用其相应的 isPermitted*/hasRole*接口进行匹配；
- 如果有一个 Realm 匹配那么将返回 true，否则返回 false；
⑤.如果 Realm 进行授权的话，应该继承 AuthorizingRealm，其流程是：
- 如果调用 hasRole()，则直接获取 AuthorizationInfo.getRoles()与传入的角色比较即可；
- 首先如果调用如 isPermitted(“user:view”)，首先通过 PermissionResolver 将权限字符串 转换成相应的 Permission 实例，默认使用 WildcardPermissionResolver，即转换为通配符的 WildcardPermission
- 通 过 AuthorizationInfo.getObjectPermissions() 得 到 Permission 实 例 集 合 ；通过 AuthorizationInfo. getStringPermissions()得到字符串集合并通过 PermissionResolver 解析为 Permission 实例；然后获取用户的角色，并通过 RolePermissionResolver 解析角色对应的权 限集合（默认没有实现，可以自己提供）；通过上面的三种情况获取了所有的权限集合。
- 接着调用 Permission. implies(Permission p)逐个与传入的权限比较，如果有匹配的则返回 true，否则 false；
四、代码展示
1、新建SpringBoot + Maven + Mybatis-Plus + Redis +Apache shiro 项目,具体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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.2.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.scmc</groupId>
<artifactId>conm</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<name>conm</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.3.2</version>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-generator</artifactId>
<version>3.3.2</version>
</dependency>
<dependency>
<groupId>org.apache.velocity</groupId>
<artifactId>velocity-engine-core</artifactId>
<version>2.0</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.49</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
<exclusions>
<exclusion>
<groupId>org.apache.tomcat</groupId>
<artifactId>tomcat-jdbc</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.59</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.10</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.4.0</version>
</dependency>
<dependency>
<groupId>org.crazycake</groupId>
<artifactId>shiro-redis</artifactId>
<version>3.1.0</version>
</dependency>
<!-- freemarker模板 -->
<dependency>
<groupId>org.freemarker</groupId>
<artifactId>freemarker</artifactId>
<version>2.3.30</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
2、先来一个简单的单元测试，快速熟悉下shiro的使用吧
1⃣️使用shiro的第一步永远都是先初始化shiro的环境，shiro的环境是由SecurityManager管理的，所以我们需要先初始化SecurityManager,然后配置其管理的桥接器：Realm，Realm有很多种，我们选择可以直接录入账户和密码的账户型SimpleAccountRealm，此realm中的用户名和密码就是模拟数据库中存储的用户名和密码，然后再利用shiro的工具类SecurityUtils把管理器设置到shiro环境中去
2⃣️接下来我们在@Test 里面模拟用户登录操作，同样在工具类中得到当前要进行登录操作的主题subject，然后根据用户名和密码初始化一个token令牌，在subject进行登录操作的时候我们传入这个token，shiro会帮我们对比token和realm中的账户和用户名是否匹配，若匹配成功则结束，失败则抛异常，我们需要通过捕获具体的异常来自己判断是用户名不存在还是密码错误。由于subject的login方法没有返回值，要打印是否登录成功，我们可以调用subject.isAuthenticated来打印输出登录结果。
import com.alibaba.druid.pool.DruidDataSource;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.realm.SimpleAccountRealm;
import org.apache.shiro.realm.jdbc.JdbcRealm;
import org.apache.shiro.subject.Subject;
import org.junit.Before;
import org.junit.Test;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
public class SpringBootShiroTest {
DefaultSecurityManager manager = new DefaultSecurityManager();
SimpleAccountRealm realm = new SimpleAccountRealm();
@Before
public void init(){
//1.构建shiro环境
realm.addAccount("liming","liming");
manager.setRealm(realm);
SecurityUtils.setSecurityManager(manager);
}
/**
* 测试登录
*/
@Test
public void loginTest(){
Subject subject = SecurityUtils.getSubject();
UsernamePasswordToken token = new UsernamePasswordToken("liming","liming");
subject.login(token);
System.out.println("登录结果："+subject.isAuthenticated());
}
}3、上面的案例，我们在代码中写死了用户名和密码，接下来我们通过配置shiro.ini文件方式进行shiro的学习和使用
1⃣️先贴出shiro.ini文件，shiro.ini文件在resource的根目录下
#格式，用户名 = 密码 ，角色
[users]
admin = admin , root
liming = xiaoming , user
#格式 角色 = 模块1：权限1， 模块1：权限2 ，或模块：* 表示全功能
[roles]
user = cart:view , cart:add
root = cart:*
2⃣️具体的ini文件内容格式已经在上面贴出，接下来我们用单测继续模拟用户登录，此时的Realm数据源不再是代码，而是ini文件
/**
* 从ini文件获取SecurityManager环境
*/
@Test
public void roleAuthTest(){
//工厂模式+shiro.ini方式初始化SecurityManager
IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro.ini");
SecurityManager manager = factory.getInstance();
SecurityUtils.setSecurityManager(manager);
Subject subject = SecurityUtils.getSubject();
UsernamePasswordToken token = new UsernamePasswordToken("liming","liming");
subject.login(token);
System.out.println("登录结果："+subject.isAuthenticated());
System.out.println("是否管理员："+subject.hasRole("root"));
System.out.println("是否普通用户："+subject.hasRole("user"));
System.out.println("用户名："+subject.getPrincipal());
System.out.println("是否有删除权限："+subject.isPermitted("conm:delete"));
System.out.println("是否有添加权限："+subject.isPermitted("conm:add"));
subject.logout();
System.out.println("登出后是否有权限："+subject.isAuthenticated());
}3⃣️和上一个单测一样，第一步都是先初始化SecurityManager，并设置到环境中去，然后利用subject去进行各种操作
3、实际上我们的用户信息是不可能存储在ini文件里面的，通常都是存储在数据库中，下面我们尝试从数据库中获取用户信息
1⃣️.配置shiro项目的数据源(不是SpringBoot项目的数据源，仅仅是Realm的数据源）
2⃣️.在resource根目录中创建一个jdbcrealm.ini文件，用来配置realm的数据源，具体配置大家自己根据自己情况灵活更改
#声明realm，指定realm类型
jdbcRealm=org.apache.shiro.realm.jdbc.JdbcRealm
dataSource=com.alibaba.druid.pool.DruidDataSource
dataSource.driverClassName=com.mysql.jdbc.Driver
dataSource.url=jdbc:mysql://localhost:3306/cq-sys?useUnicode=true&characterEncoding=utf8&useSSL=false
dataSource.username=root
dataSource.password=root
#指定数据源
jdbcRealm.dataSource=$dataSource
jdbcRealm.permissionsLookupEnabled=true
#指定SecurityManager的Realm实现，可以有多个，用逗号隔开
securityManager.realms=$jdbcRealr3⃣️.具体数据库表字段具体可以查看org.apache.shiro.realm.jdbc.JdbcRealm这个类里面的定义
-- jdbcRealm练习
SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for `roles_permissions`
-- ----------------------------
DROP TABLE IF EXISTS `roles_permissions`;
CREATE TABLE `roles_permissions` (
`id` int(11) NOT NULL DEFAULT '0',
`role_name` varchar(20) DEFAULT NULL,
`permission` varchar(20) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of roles_permissions
-- ----------------------------
INSERT INTO `roles_permissions` VALUES ('1', 'root', '*');
INSERT INTO `roles_permissions` VALUES ('2', 'user', 'conm:*');
-- ----------------------------
-- Table structure for `users`
-- ----------------------------
DROP TABLE IF EXISTS `users`;
CREATE TABLE `users` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(20) DEFAULT NULL,
`password` varchar(20) DEFAULT NULL,
`password_salt` int(11) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of users
-- ----------------------------
INSERT INTO `users` VALUES ('1', 'admin', 'admin', null);
INSERT INTO `users` VALUES ('2', 'liming', 'liming', null);
-- ----------------------------
-- Table structure for `user_roles`
-- ----------------------------
DROP TABLE IF EXISTS `user_roles`;
CREATE TABLE `user_roles` (
`id` int(11) NOT NULL DEFAULT '0',
`username` varchar(20) DEFAULT NULL,
`role_name` varchar(20) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of user_roles
-- ----------------------------
INSERT INTO `user_roles` VALUES ('1', 'admin', 'root');
INSERT INTO `user_roles` VALUES ('2', 'liming', 'user');4⃣️.单元测试搞起来，代码是不是和shiro.ini很像，流程都是一样的
/**
* 从ini文件获取jdbcRealm的SecurityManager环境
*/
@Test
public void JdbcRealmRoleAuthTest(){
//工厂模式+shiro.ini方式初始化SecurityManager
IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:jdbcRealm.ini");
SecurityManager manager = factory.getInstance();
SecurityUtils.setSecurityManager(manager);
Subject subject = SecurityUtils.getSubject();
UsernamePasswordToken token = new UsernamePasswordToken("liming","liming");
subject.login(token);
System.out.println("登录结果："+subject.isAuthenticated());
System.out.println("是否管理员："+subject.hasRole("root"));
System.out.println("是否普通用户："+subject.hasRole("user"));
System.out.println("用户名："+subject.getPrincipal());
System.out.println("是否有删除权限："+subject.isPermitted("conm:delete"));
System.out.println("是否有添加权限："+subject.isPermitted("conm:add"));
System.out.println("是否有sm添加权限："+subject.isPermitted("sm:add"));
subject.logout();
System.out.println("登出后是否有权限："+subject.isAuthenticated());
UsernamePasswordToken rootToken = new UsernamePasswordToken("admin","admin");
subject.login(rootToken);
System.out.println("登录结果："+subject.isAuthenticated());
System.out.println("是否管理员："+subject.hasRole("root"));
System.out.println("是否普通用户："+subject.hasRole("user"));
System.out.println("用户名："+subject.getPrincipal());
System.out.println("是否有删除权限："+subject.isPermitted("conm:delete"));
System.out.println("是否有添加权限："+subject.isPermitted("conm:add"));
subject.logout();
System.out.println("登出后是否有权限："+subject.isAuthenticated());
}4、没有ini文件的方式，用纯代码连接数据库，我们来单测一下
/**
* 手动代码方式建立连接池，构建获取SecurityManager环境
*/
@Test
public void jdbdRelmAuthTest(){
//连接池方式初始化SecurityManager
DruidDataSource source = new DruidDataSource();
source.setUrl("jdbc:mysql://localhost:3306/cq-sys?useUnicode=true&characterEncoding=utf8&useSSL=false");
source.setUsername("root");
source.setPassword("root");
JdbcRealm realm = new JdbcRealm();
realm.setDataSource(source);
realm.setPermissionsLookupEnabled(true);
DefaultSecurityManager manager = new DefaultSecurityManager();
manager.setRealm(realm);
SecurityUtils.setSecurityManager(manager);
Subject subject = SecurityUtils.getSubject();
UsernamePasswordToken token = new UsernamePasswordToken("xiaoming","xiaoming");
subject.login(token);
System.out.println("登录结果："+subject.isAuthenticated());
System.out.println("是否管理员："+subject.hasRole("root"));
System.out.println("是否普通用户："+subject.hasRole("user"));
System.out.println("用户名："+subject.getPrincipal());
System.out.println("是否有删除权限："+subject.isPermitted("conm:delete"));
System.out.println("是否有添加权限："+subject.isPermitted("conm:add"));
subject.logout();
System.out.println("登出后是否有权限："+subject.isAuthenticated());
}5、上面几个realm都是有数据库字段限制的，即表结构必须和shiro默认的表结构一致，实际业务中，我们肯定不能使用他的数据库表结构，那么就需要我们以自定义Realm方式的方式去构建SecurityManager。
1⃣️.如果细心一点，你就会发现，上面涉及到的Realm都是继承自AuthorizingRealm，那么我们自定义也需要继承自他
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 org.springframework.beans.factory.annotation.Autowired;
import java.util.HashSet;
import java.util.Set;
//自定义realm，基本逻辑都是根据用户名，自己去查找数据库，查出对应的权限，角色，密码
public class CustomerRealm extends AuthorizingRealm {
/**
* 权限认证
* @param principalCollection
* @return
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
Object username = principalCollection.getPrimaryPrincipal();
//自己查询数据库，查询这个usernam下所有的角色和权限
Set<String> permissions = new HashSet<>();
permissions.add("conm:add");
permissions.add("conm:delete");
Set<String> roles = new HashSet<>();
roles.add("user");
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
info.setStringPermissions(permissions);
info.setRoles(roles);
return info;
}
/**
* 登录认证
* @param authenticationToken
* @return
* @throws AuthenticationException
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
//自己查询数据库，查询这个username的密码
Object username = authenticationToken.getPrincipal();
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(username,"1234",this.getName());
return info;
}
}
2⃣️.AuthorizingRealm 中有两个需要重写的方法，一个是和登录有关，另外一个是和授权有关，即用户是否满足某个角色或具有某个权限，上面的代码，为了简便我们用代码写死了用户的信息，实际上他是用mybatis查出来的用户信息，然后构建各自的info信息。显而易见，两个info所需要的信息分别是权限角色集合与用户名和密码
3⃣️.单元测试看一下效果
/**
* 自定义realm，构建SecurityManager环境
*/
@Test
public void customerRealmAuthTest(){
CustomerRealm realm = new CustomerRealm();
manager.setRealm(realm);
SecurityUtils.setSecurityManager(manager);
Subject subject = SecurityUtils.getSubject();
UsernamePasswordToken token = new UsernamePasswordToken("liming","root");
subject.login(token);
System.out.println("登录结果："+subject.isAuthenticated());
System.out.println("是否管理员："+subject.hasRole("root"));
System.out.println("是否普通用户："+subject.hasRole("user"));
System.out.println("用户名："+subject.getPrincipal());
System.out.println("是否有删除权限："+subject.isPermitted("conm:delete"));
System.out.println("是否有修改权限："+subject.isPermitted("conm:update"));
subject.logout();
System.out.println("登出后是否有权限："+subject.isAuthenticated());
}五、实战演练
1、创建数据库表
#用户表
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(20) DEFAULT NULL,
`password` varchar(20) DEFAULT NULL,
`salt` int(11) DEFAULT NULL,
`create_time` datetime DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
SET FOREIGN_KEY_CHECKS = 1;
INSERT INTO `user`(`id`, `username`, `password`, `salt`, `create_time`) VALUES (0, 'admin', 'admin', NULL, NULL);
INSERT INTO `user`(`id`, `username`, `password`, `salt`, `create_time`) VALUES (1, 'liming', 'liming', NULL, NULL);
INSERT INTO `user`(`id`, `username`, `password`, `salt`, `create_time`) VALUES (2, 'guest', 'guest', NULL, NULL);
#角色表
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for role
-- ----------------------------
DROP TABLE IF EXISTS `role`;
CREATE TABLE `role` (
`id` bigint(20) NOT NULL,
`role_name` varchar(255) COLLATE utf8_bin DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;
SET FOREIGN_KEY_CHECKS = 1;
INSERT INTO `role`(`id`, `role_name`) VALUES (0, 'admin');
INSERT INTO `role`(`id`, `role_name`) VALUES (1, 'root');
INSERT INTO `role`(`id`, `role_name`) VALUES (2, 'guest');
#权限表
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for permission
-- ----------------------------
DROP TABLE IF EXISTS `permission`;
CREATE TABLE `permission` (
`id` int(11) NOT NULL,
`permission_name` varchar(255) COLLATE utf8_bin DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;
SET FOREIGN_KEY_CHECKS = 1;
INSERT INTO `permission`(`id`, `permission_name`) VALUES (0, 'conm:view');
INSERT INTO `permission`(`id`, `permission_name`) VALUES (1, 'conm:modify');
INSERT INTO `permission`(`id`, `permission_name`) VALUES (2, 'conm:del');
INSERT INTO `permission`(`id`, `permission_name`) VALUES (3, 'conm:add');
#用户-角色 中间表
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for user_role
-- ----------------------------
DROP TABLE IF EXISTS `user_role`;
CREATE TABLE `user_role` (
`id` bigint(11) NOT NULL DEFAULT '0',
`user_id` bigint(20) DEFAULT NULL,
`role_id` bigint(20) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
SET FOREIGN_KEY_CHECKS = 1;
INSERT INTO `user_role`(`id`, `user_id`, `role_id`) VALUES (0, 0, 0);
INSERT INTO `user_role`(`id`, `user_id`, `role_id`) VALUES (1, 1, 1);
INSERT INTO `user_role`(`id`, `user_id`, `role_id`) VALUES (2, 2, 2);
#角色-权限中间表
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for role_permission
-- ----------------------------
DROP TABLE IF EXISTS `role_permission`;
CREATE TABLE `role_permission` (
`id` bigint(11) NOT NULL DEFAULT '0',
`role_id` bigint(20) DEFAULT NULL,
`permission_id` bigint(20) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
SET FOREIGN_KEY_CHECKS = 1;
INSERT INTO `role_permission`(`id`, `role_id`, `permission_id`) VALUES (0, 2, 0);
INSERT INTO `role_permission`(`id`, `role_id`, `permission_id`) VALUES (1, 1, 0);
INSERT INTO `role_permission`(`id`, `role_id`, `permission_id`) VALUES (2, 1, 1);
INSERT INTO `role_permission`(`id`, `role_id`, `permission_id`) VALUES (3, 1, 2);
INSERT INTO `role_permission`(`id`, `role_id`, `permission_id`) VALUES (4, 1, 3);
INSERT INTO `role_permission`(`id`, `role_id`, `permission_id`) VALUES (5, 0, 0);
INSERT INTO `role_permission`(`id`, `role_id`, `permission_id`) VALUES (6, 0, 1);
2、配置Springboot 数据源 application.properties
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.url=jdbc:mysql://localhost:3306/cq-sys?useUnicode=true&characterEncoding=utf8&useSSL=false
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=root
spring.thymeleaf.cache=false
spring.thymeleaf.suffix=.html
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
logging.level.com.scmc.conm.mapper=debug
3、mybatis反向映射生成实体类，Mapper, Service ,Controller，生成的实体类需要继承Serializable接口，后面使用redis会用到
package com.scmc.generator;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
public class MyBatisPlusGenerater {
static String packageName = "com.scmc"; // 当前包名
static String author = "liming"; // 作者
static String sqlUrl = "mysql://localhost"; // 数据库类型及地址
static String sqlDb = "cq-sys"; // 数据库名
static String sqlPort = "3306"; // 数据库名
static String sqlUser = "root";
static String sqlPassword = "root";
static String table = "user,role,permission,user_role,role_permission"; // 表，用逗号隔开
public static void main(String[] args) {
// 代码生成器
AutoGenerator mpg = new AutoGenerator();
// 全局配置
GlobalConfig gc = new GlobalConfig();
gc.setOutputDir(System.getProperty("user.dir") + "/src/main/java");
gc.setAuthor(author);
gc.setOpen(false);
gc.setServiceName("%sService");
mpg.setGlobalConfig(gc);
// 数据源配置
DataSourceConfig dsc = new DataSourceConfig();
dsc.setUrl("jdbc:" + sqlUrl + ":" + sqlPort +"/"+sqlDb + "?useUnicode=true&characterEncoding=utf8&useSSL=false");
dsc.setDriverName("com.mysql.jdbc.Driver");
dsc.setUsername(sqlUser);
dsc.setPassword(sqlPassword);
mpg.setDataSource(dsc);
// 包配置
PackageConfig pc = new PackageConfig();
pc.setParent(packageName);
pc.setEntity("entity");
mpg.setPackageInfo(pc);
// 配置模板
TemplateConfig templateConfig = new TemplateConfig();
templateConfig.setXml(null); // 不生成MapperXML
mpg.setTemplate(templateConfig);
// 策略配置
StrategyConfig strategy = new StrategyConfig();
strategy.setNaming(NamingStrategy.underline_to_camel);
strategy.setColumnNaming(NamingStrategy.underline_to_camel);
strategy.setRestControllerStyle(true);
strategy.setEntityTableFieldAnnotationEnable(true);
strategy.setInclude(table.split(","));
strategy.setControllerMappingHyphenStyle(true);
//strategy.setTablePrefix("t_"); // 表前缀，如t_user，没有就注释掉此行
mpg.setStrategy(strategy);
mpg.setTemplateEngine(new FreemarkerTemplateEngine());
mpg.execute();
}
}4、SpringBoot启动类开启mapper扫描
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@MapperScan("com.scmc.mapper")
public class ConmApplication {
public static void main(String[] args) {
SpringApplication.run(ConmApplication.class, args);
}
}5、RoleMapper添加级联查询sql方法，根据用户名查找对应的角色集合
import com.scmc.entity.Role;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Component;
import java.util.Set;
/**
* <p>
* Mapper 接口
* </p>
* @since 2020-09-14
*/
@Component
public interface RoleMapper extends BaseMapper<Role> {
@Select("select r.role_name from user u left join user_role ur on u.id=ur.user_id left join role r on ur.role_id=r.id where u.username=#{username}")
public Set<String> getRolesByUsername(@Param("username")String username);
}6、PermissionMapper添加方法，根据用户名获取权限集合
import com.scmc.entity.Permission;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Component;
import java.util.Set;
/**
* <p>
* Mapper 接口
* </p>
* @since 2020-09-14
*/
@Component
public interface PermissionMapper extends BaseMapper<Permission> {
@Select("select p.permission_name from user u left join user_role r on u.id=r.user_id left join role_permission rp on r.role_id=rp.role_id left join permission p on rp.permission_id = p.id where u.username=#{username}")
public Set<String> getPermissionsByUsername(String username);
}7、根据刚才的mapper,我们来自定义Realm,动态的从数据库查找用户信息
package com.scmc.shiro.config;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.scmc.entity.User;
import com.scmc.mapper.PermissionMapper;
import com.scmc.mapper.RoleMapper;
import com.scmc.mapper.UserMapper;
import org.apache.commons.beanutils.BeanUtils;
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 org.springframework.beans.factory.annotation.Autowired;
import java.util.HashSet;
import java.util.Set;
//自定义realm，基本逻辑都是根据用户名，自己去查找数据库，查出对应的权限，角色，密码
public class CustomRealm extends AuthorizingRealm {
@Autowired
private RoleMapper roleMapper;
@Autowired
private UserMapper userMapper;
@Autowired
private PermissionMapper permissionMapper;
/**
* 权限认证
* @param principalCollection
* @return
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
Object principal = principalCollection.getPrimaryPrincipal();
//自己查询数据库，查询这个usernam下所有的角色和权限
User user = new User();
try {
//springboot热部署原因，上面不能强转成User类型，需要拷贝一下
//两个参数不能写反，如果写反的话就会抛org.crazycake.shiro.exception.PrincipalIdNullException
BeanUtils.copyProperties(user,principal);
} catch (Exception e) {
e.printStackTrace();
}
Set<String> rolesByUsername = roleMapper.getRolesByUsername(user.getUsername());
Set<String> permissions = permissionMapper.getPermissionsByUsername(user.getUsername());
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
info.setStringPermissions(permissions);
info.setRoles(rolesByUsername);
return info;
}
/**
* 登录认证
*
* @param authenticationToken
* @return
* @throws AuthenticationException
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
//自己查询数据库，查询这个username的密码
Object username = authenticationToken.getPrincipal();
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.eq("username",username.toString());
User user = userMapper.selectOne(wrapper);
if (user==null)return null;
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user,user.getPassword(),this.getName());
return info;
}
}
8、自定义SessionManager，因为前后端分离架构下，像小程序，app等都是没有Session,Cookie等概念，需要自己实现sessionid的生成和获取，具体的方法可以参照DefaultWebSessionManager中的方法，我们只需要重写sessionid的获取，前端请求时会从header中携带我们定义的sessionId，即下面的“token”
package com.scmc.shiro.config;
import org.apache.shiro.web.servlet.ShiroHttpServletRequest;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.apache.shiro.web.util.WebUtils;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.Serializable;
/**
* 自定义
*/
public class CustomSessionManager extends DefaultWebSessionManager {
public CustomSessionManager(){
super();
}
/***
* 传统的web应用是在session中获取sessionId的，前后端分离的应用是无状态的，所以需要自定义获取sessionId,在请求头定义token即为sessionId，每次请求都必须携带
* @param request
* @param response
* @return
*/
@Override
protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
String sessionId = WebUtils.toHttp(request).getHeader("token");
System.out.println("sessionid="+sessionId);
//第一次请求没有携带sessionId,那么就分配一个
if (sessionId != null) {
request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE,ShiroHttpServletRequest.COOKIE_SESSION_ID_SOURCE);
request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, sessionId);
request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
return sessionId;
}else{
return super.getSessionId(request,response);
}
}
}
9、自定义权限或角色过滤器，查看DefaultFilter中的权限和角色过滤器的源码，我们就可以知道当配置roles[user,root,admin] 这样的多角色时，shiro会认为只有当前用户同时拥有这三个角色时，才判定权限校验成功，如果我们要想符合其中一个角色就校验成功的话，我们就需要添加自定义过滤器，并覆盖原来的perms过滤器，具体代码如下：
package com.scmc.shiro.filter;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.authz.AuthorizationFilter;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
/**
* 根据源码，自定义过滤器，只需要任意权限即可访问
*/
public class CustomPermissionAuthorizationFilter extends AuthorizationFilter {
@Override
protected boolean isAccessAllowed(ServletRequest servletRequest, ServletResponse servletResponse, Object mappedValue) throws Exception {
Subject subject = this.getSubject(servletRequest, servletResponse);
String[] perms = (String[])((String[])mappedValue);
boolean isPermitted = true;
for (String perm : perms) {
boolean permitted = subject.isPermitted(perm);
if (permitted){
return isPermitted;
}
}
return false;
}
protected Subject getSubject(ServletRequest request, ServletResponse response) {
return SecurityUtils.getSubject();
}
}
10、我们来看一下shiro最重要的一步，配置ShiroFilterFactoryBean。配置类用@SpringBootConfiguration修饰，内容我们分步讲
@Bean
public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
//认证失败的时候会以get方式跳转到这个LoginUrl路径，所以这个路径必须是get方式
shiroFilterFactoryBean.setLoginUrl("/pub/login");
shiroFilterFactoryBean.setSuccessUrl("/authc/success");
shiroFilterFactoryBean.setUnauthorizedUrl("/pub/unAuth");
shiroFilterFactoryBean.setSecurityManager(securityManager);
//自定义权限过滤器
shiroFilterFactoryBean.setFilterChainDefinitionMap(getFilterChainMap());
HashMap<String, Filter> filterMap = new HashMap<>();
filterMap.put("perms",new CustomPermissionAuthorizationFilter());
shiroFilterFactoryBean.setFilters(filterMap);
return shiroFilterFactoryBean;
}1⃣️.loginUrl是用户在登录失败的时候，shiro会自动以get请求访问这个接口
2⃣️.successUrl是用户登录成功的接口，shiro会自动以get请求访问这个接口
3⃣️.unauthorizedUrl是用户鉴权失败的时候访问的接口，shiro会自动以get请求访问这个接口
4⃣️.Filters就是shiro提供用户自定义过滤器的地方，自定义过滤器都继承自AuthorizationFilter类，以map方式设值，所以我们如果要覆盖默认的perms过滤器，map的key就要写成"perms"，其他的过滤器的key参考DefaultFilter中的枚举的写法
5⃣️.还剩一个SecurityManager我们还没讲，从最开始的shiro框架图中，我们可以知道，SecurityManager是整个shiro的核心，其中的属性设置也比较多，下面我们详细讲解
@Bean
public SecurityManager securityManager() {
DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
manager.setRealm(customRealm());
manager.setSessionManager(sessionManager());
manager.setCacheManager(redisCacheManager());
return manager;
}看完了上面代码，让我们回顾思考一下，
1.为什么要设置自定义realm？
答：shiro默认的realm不符合我们的业务，或shiro默认的数据库表字段和我们设计的数据库字段不一致，这时就需要我们自定义实现realm。
2.为什么设置自定义SessionManager?
答：前后端分离架构下，像app,小程序这种无状态的前端架构和浏览器不一样，他们不支持Session和Cookie，所以就需要我们自定义Session的实现，app每次发起请求的时候都需要在请求头header中携带会话sessionid字段，字段名可以随意，一般叫token，有令牌的含义，这样服务器就可以识别不同的会话，方便后续的鉴权和登录等操作
3.为什么使用缓存？
答：用户登录操作一般都不是很频繁，但是用户访问接口却是非常频繁的，我们不能在每次访问接口前都去数据库查一下权限，这样不仅会损耗性能，也很耗时，所以对于权限这块我们可以缓存起来，而且在SessionManager中我们也可以加入缓存，那干嘛要在SessionManager中加入缓存呢？因为我们每次新功能发布都会重启项目，在没有redis的情况下重启应用会导致当前登录用户丢失Session会话，用户正在进行某个操作，突然就要求重新登录，这肯定是不合理的，所以我们需要把Session也缓存起来，重启服务器，用户的会话不会受到影响
4.看一下SecurityManager中的具体配置吧
@Bean
public CustomRealm customRealm() {
CustomRealm realm = new CustomRealm();
realm.setCacheManager(redisCacheManager());
//realm.setCredentialsMatcher(credentialsMatcher());
return realm;
}
@Bean
public CredentialsMatcher credentialsMatcher() {
HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
matcher.setHashAlgorithmName("md5");
//双重md5
matcher.setHashIterations(2);
return matcher;
}
@Bean
public RedisManager redisManager(){
RedisManager redisManager = new RedisManager();
redisManager.setHost("localhost");
redisManager.setPort(6379);
return redisManager;
}
@Bean
public SessionDAO sessionDao(){
RedisSessionDAO sessionDAO = new RedisSessionDAO();
sessionDAO.setRedisManager(redisManager());
return sessionDAO;
}
@Bean
public RedisCacheManager redisCacheManager(){
RedisCacheManager cacheManager = new RedisCacheManager();
cacheManager.setRedisManager(redisManager());
cacheManager.setExpire(30*60*1000);
cacheManager.setPrincipalIdFieldName("id");
return cacheManager;
}
@Bean
public SessionManager sessionManager() {
CustomSessionManager sessionManager = new CustomSessionManager();
sessionManager.setGlobalSessionTimeout(30*60*1000L);
sessionManager.setSessionDAO(sessionDao());
return sessionManager;
}
private Map<String, String> getFilterChainMap() {
Map<String, String> map = new LinkedHashMap<>();
//退出过滤器
map.put("/logout", "logout");
//匿名过滤器,pub下的路径都不用验权
map.put("/pub/**", "anon");
//对应路径需要具体的权限
map.put("/authc/add", "perms[conm:add,conm:view]");
map.put("/authc/view", "perms[conm:view]");
//登录才能访问的过滤器
map.put("/authc/**", "authc");
//具有全部的角色才能访问管，角色之间用逗号隔开
map.put("/admin/**", "roles[admin]");
//具有合同查看权限才能访问
map.put("/authc/view", "perms[view]");;
//通过认证才能访问
map.put("**", "authc");
return map;
}
/**
* Shiro生命周期处理器
* @return
*/
@Bean
public LifecycleBeanPostProcessor lifecycleBeanPostProcessor(){
return new LifecycleBeanPostProcessor();
}
/**
* 开启Shiro的注解(如@RequiresRoles,@RequiresPermissions),需借助SpringAOP扫描使用Shiro注解的类,并在必要时进行安全逻辑验证
* @return
*/
@Bean
@DependsOn({"lifecycleBeanPostProcessor"})
public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator(){
DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
advisorAutoProxyCreator.setProxyTargetClass(true);
return advisorAutoProxyCreator;
}
1⃣️.redisCacheManager setPrincipalIdFieldName("id")方法中必须指定当前subject实体User的数据库主键id,用来后续redis登录或授权缓存的时候用来当作key。
2⃣️.getFilterChainMap中的Map一定要使用有序的LinkedHashMap，这样过滤器才会按顺序过滤，从上而下，当某一请求被上面的过滤器过滤的时候，就不会再去匹配下面的过滤器，所以我们需要定义好过滤顺序，map的key是拦截路径，value就是过滤器的枚举写法，logout:当匹配到该过滤器时，SessionManager会自动清除Session; anon:不需要任何权限即可访问的过滤器 ； perms[权限1，权限2，权限3]：需要相应的权限的过滤器； roles[角色1，角色2，角色3]：需要相应角色的过滤器； authc: 需要登录才能访问的过滤器
11、下面我们写几个Controller来验证一下吧
import com.alibaba.fastjson.JSONObject;
import lombok.Data;
@Data
public class JsonData {
private Boolean success;
private String url;
private String token;
private String msg;
public JsonData(Boolean success,String url,String token,String msg){
this.success=success;
this.url=url;
this.token=token;
this.msg=msg;
}
}package com.scmc.controller;
import com.alibaba.fastjson.JSONObject;
import com.scmc.entity.JsonData;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import redis.clients.jedis.exceptions.JedisConnectionException;
@Controller
@RequestMapping("pub")
public class LoginController {
@PostMapping("toLogin")
@ResponseBody
public String toLogin(@RequestParam("username") String username,@RequestParam("password") String password) {
JsonData jsonData=null;
try{
Subject subject = SecurityUtils.getSubject();
UsernamePasswordToken token = new UsernamePasswordToken(username,password);
subject.login(token);
subject.isAuthenticated();
String id = subject.getSession().getId().toString();
jsonData = new JsonData(true, "/authc/index", id,"登录成功");
return JSONObject.toJSONString(jsonData);
}catch(UnknownAccountException ue){
jsonData = new JsonData(false, "/pub/unauthc",null,"用户不存在，请先注册");
}catch (IncorrectCredentialsException ie){
jsonData = new JsonData(false, "/pub/unauthc",null,"密码错误");
}catch (JedisConnectionException je){
jsonData = new JsonData(true, "/authc/index",null,"redis异常，但登录成功");
}
return JSONObject.toJSONString(jsonData);
}
@GetMapping("login")
@ResponseBody
public String login() {
//告诉前端，认证失败，需要登录
JsonData jsonData = new JsonData(false, "/pub/toLogin",null,"需要登录");
return JSONObject.toJSONString(jsonData);
}
@PostMapping("register")
@ResponseBody
public String register(@RequestParam("username") String username,@RequestParam("password") String password){
return "";
}
@GetMapping("unAuth")
@ResponseBody
public String uploadFile() {
//告诉前端，没有权限
JsonData jsonData = new JsonData(false,null,null,"访问失败，没有权限");
return JSONObject.toJSONString(jsonData);
}
@GetMapping("logout")
@ResponseBody
public String logout(){
Subject subject = SecurityUtils.getSubject();
if (subject.isAuthenticated()) {
subject.logout();
}
JsonData jsonData = new JsonData(true,null,null,"退出登录");
return JSONObject.toJSONString(jsonData);
}
}
package com.scmc.controller;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
@RequestMapping("authc")
public class IndexController {
@PostMapping("success")
@ResponseBody
public String success() {
return "登录成功";
}
@PostMapping("index")
@ResponseBody
public String homepage() {
return "主页";
}
@PostMapping("bgcontrol")
@ResponseBody
public String bgcontrol() {
return "控制台";
}
@PostMapping("view")
@ResponseBody
public String view() {
return "查看权限";
}
@RequiresPermissions("conm:add")
@PostMapping("add")
@ResponseBody
public String add() {
return "添加权限";
}
}
package com.scmc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
@RequestMapping("admin")
public class AdminController {
@PostMapping("mc")
@ResponseBody
public String admin(){
return "您的角色是admin";
}
}
1609
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
