学习的spring boot 2.0的记录（十一）：SpringBoot关于Shiro的配置（基于mybatis的实战的demo）

客官°小女子只卖身不卖艺 2021-11-13 22:18 138阅读 0赞

前言：

学习的地址：https://www.majiaxueyuan.com/front/showcoulist 、[https://www.bilibili.com/video/av44084437][https_www.bilibili.com_video_av44084437]  
SpringBoot的pom依赖（以2.0版本为例的）  
本集记录的是shiro的权限框架（记录的是一个比较偏向实战的demo）

使用了springboot + freemark + shiro+mybatis 这样的框架

**注意：有些代码是在上一章 **[https://blog.csdn.net/qq\_28198181/article/details/97929008][https_blog.csdn.net_qq_28198181_article_details_97929008] 上的

demo层次：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4MTk4MTgx_size_16_color_FFFFFF_t_70][]

![20190801163327422.png][]

大体流程：

从页面得到登录密码和用户，进入数据库查询，如果有就能进入主页，如果不能，就返回登录页面。登录到主页之后，根据用户的角色显示不同的权限进行不同的操作。

这里面还需要处理realm的授权操作。就是对用户的权限进行判断。

**目录**

1.添加依赖

2.配置application.properties文件

3.创建数据库表和和字段

4.创建实体类和mapper接口

5.修改realm的认证和授权方法

6.修改前端显示方法。

7.测试

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

# 1.添加依赖 #

在上次之前的demo依赖上还需要添加前端支持shiro的依赖和连接数据库的依赖，所有的依赖如下：

<parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.0.0.RELEASE</version>
 </parent>
 
 <dependencies>
 
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter</artifactId>
 </dependency>
 
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-freemarker</artifactId>
 </dependency>
 
 
 <dependency>
 <groupId>org.apache.shiro</groupId>
 <artifactId>shiro-core</artifactId>
 <version>1.3.2</version>
 </dependency>
 <dependency>
 <groupId>org.apache.shiro</groupId>
 <artifactId>shiro-web</artifactId>
 <version>1.3.2</version>
 </dependency>
 <dependency>
 <groupId>org.apache.shiro</groupId>
 <artifactId>shiro-ehcache</artifactId>
 <version>1.3.2</version>
 </dependency>
 <dependency>
 <groupId>org.apache.shiro</groupId>
 <artifactId>shiro-spring</artifactId>
 <version>1.3.2</version>
 </dependency>
 
 <dependency>
 <groupId>org.apache.commons</groupId>
 <artifactId>commons-lang3</artifactId>
 <version>3.4</version>
 </dependency>
 
 
 <dependency>
 <groupId>net.mingsoft</groupId>
 <artifactId>shiro-freemarker-tags</artifactId>
 <version>0.1</version>
 </dependency>
 
 
 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 </dependency>
 
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-jdbc</artifactId>
 </dependency>
 
 <dependency>
 <groupId>org.mybatis.spring.boot</groupId>
 <artifactId>mybatis-spring-boot-starter</artifactId>
 <version>1.1.1</version>
 </dependency>
 
 
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-jta-atomikos</artifactId>
 </dependency>
 
 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <version>1.18.6</version>
 </dependency>
 
 </dependencies>
 
 
 <build>
 <plugins>
 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
 </plugin>
 </plugins>
 </build>

暂时使用到的依赖就这么多。

# 2.配置application.properties文件 #

application.properties在上一次的基础上还需要添加连接数据库的配置

server.port=8080
    server.tomcat.uri-encoding=UTF-8
    spring.freemarker.allow-request-override=false
    spring.freemarker.cache=true
    spring.freemarker.charset=UTF-8
    spring.freemarker.check-template-location=true
    spring.freemarker.content-type=text/html
    spring.freemarker.expose-request-attributes=false
    spring.freemarker.expose-session-attributes=false
    spring.freemarker.expose-spring-macro-helpers=false
    spring.freemarker.suffix=.ftl
    spring.freemarker.template-loader-path=classpath:/templates/
    mysql.datasource.data.borrowConnectionTimeout=30
    mysql.datasource.data.loginTimeout=30
    mysql.datasource.data.maintenanceInterval=60
    mysql.datasource.data.maxIdleTime=60
    mysql.datasource.data.maxLifetime=20000
    mysql.datasource.data.maxPoolSize=25
    mysql.datasource.data.minPoolSize=3
    mysql.datasource.data.password=jy897513;
    mysql.datasource.data.url=jdbc:mysql://localhost:3306/bootdb2?useUnicode=true&characterEncoding=utf-8
    mysql.datasource.data.username=root

自己根据自己数据库去配置连接地址

暂时使用的如上。

# 3.创建数据库表和和字段 #

数据库中涉及到的表如下：

1.用户表user

用户表是记录登录的用户名称和密码，简单点就只是创建了三个字段 uid uname 和 upassword

CREATE TABLE user(
    uid INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
    uname VARCHAR(20) NOT NULL,
    upassword VARCHAR(20) NOT NULL
    );

2.角色表role

角色表是判断用户的在当前系统中是什么角色，是普通user用户还是admin管理用户

也只是设置3个字段 rid rname 和 rdescription

CREATE TABLE role(
    rid INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
    rname VARCHAR(20),
    rdescription VARCHAR(100)
    );

3.权限表permission

权限表只是自己加的，用来判断什么角色拥有什么权限，根据权限来显示可执行的操作

权限也只是写了三个参数 pid pname pdescription

CREATE TABLE permission(
    pid INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
    pname VARCHAR(20),
    pdescription VARCHAR(100)
    );

4.用户表和角色表的关联表

记录用户id和角色id的关联表 可以根据用户id查询到角色

也只是设置了三个字段 urid uid 和rid

CREATE TABLE role_user(
    urid INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
    uid INT NOT NULL,
    rid INT NOT NULL
    );

目的就是为了得到用户后可以去知道他是什么角色 为后面得到权限做准备

5.角色表和权限表的关联表

设置了三个字段 rpid rid 和pid

CREATE TABLE role_permission(
    rpid INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
    rid INT NOT NULL,
    pid INT NOT NULL
    );

这样的所以用到的数据库表就创建好了

# 4.创建实体类和mapper接口 #

实体类创建是为了能从数据库中取得数据组成PO，

具体有三个实体类，分别就是role user 和permission

user:

@Data
    public class User {
    
        private Integer uid;
    
        private String uname;
    
        private String upassword;
    }

role:

@Data
    public class Role {
    
        private Integer rid;
    
        private String rname;
    
        private String rdescription;
    
    }

permission:

@Data
    public class Permission {
    
        private Integer pid;
    
        private String pname;
    
        private String pdescription;
    
    }

实体类创建好后需要配置数据源（我就直接用多数据源配置了）

dbconfig类：

@Data
    @ConfigurationProperties(prefix = "mysql.datasource.data")
    public class DBConfig {
    
        private String url;
        private String username;
        private String password;
        private int minPoolSize;
        private int maxPoolSize;
        private int maxLifetime;
        private int borrowConnectionTimeout;
        private int loginTimeout;
        private int maintenanceInterval;
        private int maxIdleTime;
        private String testQuery;
    }

扫描配置文件前缀为 mysql.datasource.data开头的参数。

mybatisConfigure类

@Configuration
    @MapperScan(basePackages = "com.zqj.mapper",sqlSessionTemplateRef = "primarySqlSessionTemplate")
    public class MyBatisPrimaryConfig {
    
    	@Bean(name = "primaryDataSource")
    	@Primary
    	public DataSource primaryDataSource(DBConfig dbConfig) throws SQLException {
    		//配置数据库参数
    		MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
    		mysqlXaDataSource.setUrl(dbConfig.getUrl());
    		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
    		mysqlXaDataSource.setPassword(dbConfig.getPassword());
    		mysqlXaDataSource.setUser(dbConfig.getUsername());
    		AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
    
    		xaDataSource.setXaDataSource(mysqlXaDataSource);
    		xaDataSource.setUniqueResourceName("primaryDataSource");
    
    		xaDataSource.setMinPoolSize(dbConfig.getMinPoolSize());
    		xaDataSource.setMaxPoolSize(dbConfig.getMaxPoolSize());
    		xaDataSource.setMaxLifetime(dbConfig.getMaxLifetime());
    		xaDataSource.setBorrowConnectionTimeout(dbConfig.getBorrowConnectionTimeout());
    		xaDataSource.setLoginTimeout(dbConfig.getLoginTimeout());
    		xaDataSource.setMaintenanceInterval(dbConfig.getMaintenanceInterval());
    		xaDataSource.setMaxIdleTime(dbConfig.getMaxIdleTime());
    		xaDataSource.setTestQuery(dbConfig.getTestQuery());
    		return xaDataSource;
    	}
    
        @Primary
    	@Bean(name = "pariamrySqlSessionFactory")
    	public SqlSessionFactory testSqlSessionFactory(@Qualifier("primaryDataSource") DataSource dataSource)
    			throws Exception {
    		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
    		bean.setDataSource(dataSource);
    		return bean.getObject();
    	}
    
        @Primary
    	@Bean(name = "primarySqlSessionTemplate")
    	public SqlSessionTemplate testSqlSessionTemplate(
    			@Qualifier("pariamrySqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
    		return new SqlSessionTemplate(sqlSessionFactory);
    	}
    }

配置的datasource扫描的mapper包在com.zqj.mapper

这个时候就是需要去编写mapper接口了

创建mapper包 然后我创建了三个mapper

![20190801112801411.png][]

usermapper 用来查询用户的

@Mapper
    @Repository
    public interface UserMapper {
    
        @Select("SELECT * FROM user WHERE uname LIKE #{username} limit 1;")
        public User getUser(@Param("username") String username);
    
    }

RoleUserMapper

是用来根据用户查询对应绑定的角色

@Mapper
 @Repository
 public interface RoleUserMapper {
 
 @Select("SELECT r.rid, r.rname,r.rdescription FROM user u,role r,role_user ru WHERE u.uname =#{userName} and u.uid = ru.uid and ru.rid = r.rid;")
 List<Role> getRoleList(@Param("userName") String userName);
 
 }

RolePermissionMapper

是根据用户角色来查询绑定的权限的

@Mapper
 @Repository
 public interface RolePermissionMapper {
 
 
 @Select("SELECT p.pid,p.pname FROM permission p , role_permission pr ,role r WHERE r.rname = #{roleName} and r.rid =pr.rid and p.pid=pr.pid;")
 List<Permission> getPermissions(@Param("roleName") String roleName);
 }

mapper写好后，就可以连接数据库了

# 5.修改realm的认证和授权方法 #

mapper 是实体都创建好了，可以去修改realm的认证和授权了。

现将以前写死的认证方法的password改了:

@Autowired
 private UserMapper userMapper;
 
 @Override
 protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
 
 String username = (String) authenticationToken.getPrincipal(); //传递过来的username 就是登陆的用户名称
 
 // String dbpassWord = "123"; //这里模拟的是数据库的用户密码
 User user = userMapper.getUser(username);
 
 System.out.println("进入认证Realm:" + user.toString());
 
 //这里是处理某处登陆后，当前登录失效的方法，就像异地登录那样
 Collection<Session> sessions = sessionDAO.getActiveSessions();
 for (Session session : sessions) {
 String loginedUserName = String.valueOf(session.getAttribute(DefaultSubjectContext.PRINCIPALS_SESSION_KEY));
 if (username.equals(loginedUserName)) {
 //说明已经是登陆成功的了。需要挤掉
 session.setTimeout(0L);
 break;
 }
 }
 
 SimpleAuthenticationInfo simpleAuthorizationInfo = null;
 
 //这里是将username 和 数据库得到的密码放进去 最后一个参数可以写死
 //实战是在数据库查到数据后将这个数据放进去
 //后期还可以加盐
 simpleAuthorizationInfo = new SimpleAuthenticationInfo(username, user.getUpassword(), "realName");
 return simpleAuthorizationInfo;
 }

认证修改后，如果用户正常登录的话，就可以去处理授权的问题了。

处理授权是需要首先在前端获得shiro传递过来的参数：

前台shiro tags和后台的联动：这个是处理shiro的标签

@Component
    public class FreemarkShiroConfig {
    
        @Autowired
        private FreeMarkerConfigurer configurer;
    
        //设置shrio和freemark联动的标签
        @PostConstruct
        public void setShiroTags() {
            configurer.getConfiguration().setSharedVariable("shiro",new ShiroTags());
        }
    }

当前后台联动处理好了后就会根据shiro进入到authorizationInfo的doGetAuthrizationInfo方法

授权主要是在登陆之后进行用户角色判断和权限判断：将得到的用户名查询到对应的角色和权限

@Autowired
 private RolePermissionMapper rolePermissionMapper;
 
 /**
 * 授权
 *
 * @param principalCollection
 * @return
 */
 @Override
 protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
 //得到当前用户名称
 String username = (String) principalCollection.getPrimaryPrincipal();
 
 
 System.out.println("进入到授权Realm:" + username);
 
 //得到从数据库取出的用户的角色对象列表和全县列表
 List<Role> dbRoleList = roleUserMapper.getRoleList(username);
 List<Permission> dbPermissionList = new ArrayList<>();
 
 //要添加的角色列表
 List<String> roleList = new ArrayList<>();
 
 //要添加的权限列表
 List<String> permissionList = new LinkedList<>();
 //得到数据库的角色列表
 
 for (Role role : dbRoleList) {
 //添加角色名称
 roleList.add(role.getRname());
 //权限列表
 //得到角色拥有的权限
 dbPermissionList = rolePermissionMapper.getPermissions(role.getRname());
 for (Permission permission : dbPermissionList) {
 if (permission.getPname().equals("SELECT")) {
 permissionList.add("ADMIN:USER:"+permission.getPname());
 }else{
 permissionList.add(role.getRname()+":"+permission.getPname());
 }
 }
 }
 
 //把角色列表和权限列表发送过来
 SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
 //这里是将得到的角色列表和权限列表放到授权对象中
 simpleAuthorizationInfo.addRoles(roleList);
 simpleAuthorizationInfo.addStringPermissions(permissionList);
 return simpleAuthorizationInfo;
 }

接下来可以去处理前端显示了

# 6.修改前端显示方法 #

将授权写好后，可以将其体现到前端去

index页面是显示得到的角色信息和权限信息

index页面使用shiro标签时会找到联动的@requiresRole 和 @RequiresPermission

<!DOCTYPE html>
 <html xmlns="http://www.w3.org/1999/html">
 <head lang="en">
 <meta charset="UTF-8"/>
 <title></title>
 </head>
 <body>
 你好啊：${name}
 
 
 你当前的角色是：
 <@shiro.hasRole name="ADMIN"> 
 ADMIN角色
 </@shiro.hasRole>
 
 <@shiro.hasRole name="USER">
 USER角色
 </@shiro.hasRole>
 
 <@shiro.hasRole name="MANAGER">
 MANAGER角色
 </@shiro.hasRole>
 
 你当前可以操作的功能有：
 <@shiro.hasPermission name="ADMIN:UPDATE">
 UPDATE功能
 </@shiro.hasPermission>
 
 <@shiro.hasPermission name="ADMIN:DELETE">
 DELETE功能
 </@shiro.hasPermission>
 
 <@shiro.hasPermission name="ADMIN:INSERT">
 INSERT功能
 </@shiro.hasPermission>
 
 <@shiro.hasPermission name="ADMIN:USER:SELECT">
 SELECT功能
 </@shiro.hasPermission>
 
 退出：
 <form action="toLogout" method="get">
 <input type="submit" name="logout" value="退出"/> 
 </form>
 
 </body>
 </html>

上面的@shiro.xxxxx的就是要去userRealm的授权中查找得到的角色数据和权限数据

name后面跟的是 **用户角色:权限**  这样的表达方式

现在数据库中还没有 等下写进去

最后将dbconfig.class进行在程序执行的时候去加载：

@SpringBootApplication
    @EnableConfigurationProperties({DBConfig.class})
    public class ShiroApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(ShiroApplication.class, args);
        }
    
    }

# 7.测试 #

大体流程写完了，现在在数据库中放些数据

用户表：

![20190801114752581.png][]

角色表：

![2019080111490871.png][]  
权限表：

![2019080111500799.png][]

用户角色关联表：

表示的是我姬子阿姐有管理员权限和普通用户权限

神舟平板只有普通用户权限

![20190801115112682.png][]

然后将权限表和角色关联表关联起来：

ADMIN用户拥有增删改查所有功能

USER用户拥有查询功能

![20190801115607831.png][]

后台数据库也模拟好了，

http://localhost:8080/index/getIndex

这个时候可以操作一波试试了

访问indexContrller

访问index界面

![20190801145447490.png][]

会跳转回到login界面 ，因为没有认证通过的

接着

我们来输入用户密码 随便输一个，会报错输入错误

![20190801145551324.png][]

现在我们输入一个正确的数据来尝试一下

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4MTk4MTgx_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4MTk4MTgx_size_16_color_FFFFFF_t_70 2][]

以上。

没有很严谨的去写。可能有些规范不好。请指正

[https_www.bilibili.com_video_av44084437]: https://www.bilibili.com/video/av44084437
[https_blog.csdn.net_qq_28198181_article_details_97929008]: https://blog.csdn.net/qq_28198181/article/details/97929008
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4MTk4MTgx_size_16_color_FFFFFF_t_70]: /images/20211113/46a989bcc3e84aa7950569aa06a333af.png
[20190801163327422.png]: /images/20211113/5c49854119554adb85722329084d7420.png
[20190801112801411.png]: /images/20211113/4b36c6b419b74d55a24eabd491447d85.png
[20190801114752581.png]: /images/20211113/909dd0eb0de14d1bbee8bc1511761a86.png
[2019080111490871.png]: /images/20211113/32382ba0daec428593fccb60b5c556eb.png
[2019080111500799.png]: /images/20211113/e26d533eabb545a8b451e5c23172f86e.png
[20190801115112682.png]: /images/20211113/b2201fcf872e43f9bed900adb272672f.png
[20190801115607831.png]: /images/20211113/6cac2607ad0e404a9b42454aace68487.png
[20190801145447490.png]: /images/20211113/fb25635f90044f9e8531237749df3732.png
[20190801145551324.png]: /images/20211113/2917aaab3b1347a5a60c134f9f2fd7d7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4MTk4MTgx_size_16_color_FFFFFF_t_70 1]: /images/20211113/f2a6f562d076426abbc3bb3bbb5a67d5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4MTk4MTgx_size_16_color_FFFFFF_t_70 2]: /images/20211113/5d3b97a733424cffa5a623fdf4c36ab5.png