基于SpringBoot打造在线教育系统（3）-- 登录与授权管

作者: 剽悍一小兔 | 来源:发表于2021-01-05 23:45 被阅读0次

更正

首先抱歉了各位，上一讲有一个错误，我已经在视频里面指出。
视频地址：https://www.bilibili.com/video/BV1CA411W7QV/ ，
就是junit测试那一块，如果自己写sql，事物是不能加在测试方法上的，还是需要写一个Service，不能偷懒。下次写文，我会更加谨慎，确保不再出现类似的疏漏。

1. 登录的准备

jpa搞定了，终于要开始做登录了。登录了以后，考虑到用户是有一个身份的，比如管理员，普通用户，vip用户等。

有些功能，比如新增教程，是只有管理员角色才能做的事情，所以，就得弄一套权限管理。

说到权限管理，现在最流行的就是shiro了，据说是spring官方推荐使用的。

那么，还等什么呢，用呗。

这不，兔哥给我推荐了一些资料，我看完后差不多就可以依葫芦画瓢开始了。

2. 建三张表

用户可以拥有多个角色，每一个角色拥有多个权限。

我们要做的是一个复杂的，可以商用的在线教育平台，所以不能做的太简单。那么，第一步，权限管理是不能少了。

要做权限管理，我们还缺少3张表，即角色表和权限表，还有一张角色权限关系表。

因为我们使用的是JPA，所以，直接创建class即可。

角色表

package com.edu.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Role {

    @Id
    @GeneratedValue
    private Integer id;
    
    @Column(length = 20)
    private String name;
    
    @Column(length = 20)
    private String description;
    
    
    public Role(){}

}

权限表

package com.edu.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Permission {

    @Id
    @GeneratedValue
    private Integer id;
    
    @Column(length = 20)
    private String url;
    
    @Column(length = 20)
    private String description;
    
    
    public Permission(){}

角色权限关系表

package com.edu.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class RolePermission {

    @Id
    @GeneratedValue
    private Integer id;
    
    @Column
    private Integer roleId;
    
    @Column
    private Integer permissionId;
    
    
    public RolePermission(){}


}

运行主程序，可以看到表已经建好了。

为了节省时间，我们直接用insert语句添加初始化数据：

INSERT INTO `edu`.`role` (`id`, `description`, `name`) VALUES ('1', NULL, '管理员');
INSERT INTO `edu`.`role` (`id`, `description`, `name`) VALUES ('2', NULL, '普通会员');
INSERT INTO `edu`.`role` (`id`, `description`, `name`) VALUES ('3', NULL, 'VIP会员');

INSERT INTO `edu`.`permission` (`id`, `description`, `url`) VALUES ('1', '增加分类', 'type:add');
INSERT INTO `edu`.`permission` (`id`, `description`, `url`) VALUES ('2', '修改分类', 'type:edit');
INSERT INTO `edu`.`permission` (`id`, `description`, `url`) VALUES ('3', '删除分类', 'type:delete');

INSERT INTO `edu`.`role_permission` (`id`, `permission_id`, `role_id`) VALUES ('1', '1', '1');
INSERT INTO `edu`.`role_permission` (`id`, `permission_id`, `role_id`) VALUES ('2', '2', '1');
INSERT INTO `edu`.`role_permission` (`id`, `permission_id`, `role_id`) VALUES ('3', '3', '1');

我们做3个测试权限，管理员角色默认拥有所有的权限。

3. 创建三个Dao

和三个实体类对应，我们需要建立三个dao文件。

代码如下：

public interface RoleDao  extends JpaRepository<Permission, Integer>{

}


public interface PermissionDao  extends JpaRepository<Permission, Integer>{

}


public interface RolePermissionDao  extends JpaRepository<RolePermission, Integer>{

}

老规矩，继承JpaRepository就行了。

4. 引入Shiro的依赖

用maven引入Shiro的包，在pom.xml中加上：

<!-- shiro -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.3.2</version>
        </dependency>
                 
        <!-- shiro-web -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-web</artifactId>
            <version>1.3.2</version>
        </dependency>

其实我们主要使用的是第一个，第二个后面也许会用到，先加上吧。

5. 配置Shiro到SpringBoot

因为我们搭建的项目是基于SpringBoot的，所以需要通过配置类的方式，把Bean加入到Spring的Bean工厂。

方法就是，我们自己写一个类，把Shiro需要用到的Bean声明一下。

创建一个ShiroConfig：

给这个类加上@Configuration注解，表示它是一个配置类。啥意思呢，我们在不用SpringBoot之前，不是会有一个applicationContext.xml的配置文件吗，在这个文件里面，我们可以写好多Bean的注册。那么被@Configuration注解的类，就是一样的作用。

具体的做法是，我们在ShiroConfig里面添加若干个方法，方法上打一个@Bean注解，意思就和在applicationContext.xml里面配置<bean></bean>是一样一样的，被@Bean注解的方法，会返回一个对象，返回的对象会交给Spring来管理，你在别的地方就可以直接使用它了。

Shiro我们只需要学会三个核心组件就可以了。

6. 自定义realm

比如我叶小凡来登录了，登录的时候，是不是要验证用户名和密码，这个验证的过程，就需要我们自己来设计。

6.1 认证

比如我们可以这样设计，先判断用户名是否存在，存在的话怎么样，不存在怎么样？这个就叫做认证，shiro要我们提供一个Realm，把如何认证的代码写了。

6.2 授权

还有一点，我登录了以后，到底能做哪些事情，我们刚才不是有一个权限表嘛？

我们配置了三个权限，如果登录成功了，就会进入授权的过程，就是我们需要写一个方法，去数据库里面把这个用户所拥有的权限取出来，然后添加到 授权信息 里面。

这个Realm就是做这两件事情的。

我们创建一个UserRealm，把这两件事情都做了。因为我们使用了Shiro框架，那么就得按照规矩办事，需要去继承一个AuthorizingRealm。

public abstract class AuthorizingRealm extends AuthenticatingRealm
        implements Authorizer, Initializable, PermissionResolverAware, RolePermissionResolverAware {

}

看源码，得知这是一个抽象类，继承了它就必须重写它所有的抽象方法。

我们先注入三个Dao

    @Autowired
    UserDao userDao;
    
    @Autowired
    PermissionDao permissionDao;
    
    @Autowired
    RolePermissionDao rolePermissionDao;

6.3 认证方法

然后，重写认证方法（注意，默认重写两个方法，名字是一样的，下面的那个是认证方法！）：

//认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        System.out.println("执行了认证");
        
        //用户名和密码
        UsernamePasswordToken userToken = (UsernamePasswordToken) token;
        
        //根据用户名去查找这个用户，现在不校验密码
        User user = userDao.findOne(userToken.getUsername());
        
        if(user == null){
            return null; // 会被认为是用户名不存在
        }
        
        
        //Shiro会自动帮我们去做密码的校验，不用你操心
        return new SimpleAuthenticationInfo(user.getUsername(),userToken.getPassword(),getName());
    }

这个方法啥时候被调用呢，调用的时机就是你在其他地方调用 subject.login(token) 的时候。

这也是shiro最让人头疼的地方，就是你自己写了很多代码，却不知道啥时候会调用，挺绕的。

看最后一句：

return new SimpleAuthenticationInfo(userToken.getUsername(),user.getPassword(),getName());

返回了一个SimpleAuthenticationInfo，这是一个简单的认证信息，构造函数里面第一个参数是认证对象，你可以传一个Object，比如放一个User对象进去，也可以跟我一样，简单一些，放userName进去，这个东西待会会用到。

第二个参数是密码，我们这边就不加密了，到时候shiro会自己帮你去校验密码是否正确的。注意，这个密码是你从数据库里面查出来的，正确的密码，不是你传进来的密码！！

你可能很奇怪，啥时候校验密码呢？

呵呵，要不怎么用框架呢，shiro连这个校验密码的工作都帮你做了。而且，shiro还可以帮你做很多加密的工作，现在我们就不整那么复杂了，就用明文密码吧。

6.4 授权方法

重写授权方法（注意，默认重写两个方法，名字是一样的，上面那个是授权方法！）：

    //授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("执行了授权");
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        
        //获取当前用户
        String userName = principalCollection.getPrimaryPrincipal().toString();
        
        //根据用户名获取角色
        User userInDB = userDao.findOne(userName);
        String roleId = userInDB.getRoleId();
        
        //根据角色查询所有的权限
        List<RolePermission> listRolePermission = rolePermissionDao.getByRoleId(Integer.parseInt(roleId));
        
        Set<String> result = new HashSet<>();
        
        //遍历所有的权限ID，去获取权限url
        for(RolePermission rolePermission : listRolePermission){
            Integer permissionId = rolePermission.getPermissionId();
            Permission permission = permissionDao.findOne(permissionId);
            result.add(permission.getUrl());
        }
        
        System.out.println(userName+"的权限包含--" + result);
        
        info.setStringPermissions(result);
        
        return info;
    }

思路就是拿到当前登录的数据，得到用户名，注意，那个userName，我们是通过下面的代码拿到的。

String userName = principalCollection.getPrimaryPrincipal().toString();

principalCollection是这个授权方法的参数，我们必须得先在认证方法里面，给SimpleAuthenticationInfo的第一个构造参数赋值，这里才会有。

有没有感受到用框架的魅力呢，所谓框架就是，它把设计写好了，按照作者的思维，先给你把流程跑通，然后在某些需要嵌入具体业务逻辑的地方，做成接口或者抽象方法，给你去完成。

比如这个AuthorizingRealm类，他要求你必须要去继承，然后重写认证和授权方法。我们可以想象，在某个地方，他先调用了认证方法，然后不是得到一个SimpleAuthenticationInfo对象嘛。接着，他又在某个地方调用了授权方法，并且把SimpleAuthenticationInfo对象的principal传进去。

这就是框架的普遍设计思路。

如果你也能理解这些，你也可以去做一些架构的工作了，或者成为全球最大的同性交友网站 —— github的一员。

6.5 简单挖掘一下源码（如不感兴趣可以直接条过本小节）

既然说到了这里，不挖一下源码是不行了。ok，让我们一起来走一遍。

就稍微读一下认证方法吧，最后返回了这个：

//Shiro会自动帮我们去做密码的校验，不用你操心
return new SimpleAuthenticationInfo(userToken.getUsername(),user.getPassword(),getName());

点进去看：

    /**
     * Constructor that takes in a single 'primary' principal of the account and its corresponding credentials,
     * associated with the specified realm.
     * <p/>
     * This is a convenience constructor and will construct a {@link PrincipalCollection PrincipalCollection} based
     * on the {@code principal} and {@code realmName} argument.
     *
     * @param principal   the 'primary' principal associated with the specified realm.
     * @param credentials the credentials that verify the given principal.
     * @param realmName   the realm from where the principal and credentials were acquired.
     */
    public SimpleAuthenticationInfo(Object principal, Object credentials, String realmName) {
        this.principals = new SimplePrincipalCollection(principal, realmName);
        this.credentials = credentials;
    }

看这个：

this.principals = new SimplePrincipalCollection(principal, realmName);

这说明这个类有一个属性principals，它的值是SimplePrincipalCollection，两个构造参数，分别是principal（我们这次传递的是String，假如说是“admin”）。进入SimplePrincipalCollection：

    public SimplePrincipalCollection(Object principal, String realmName) {
        if (principal instanceof Collection) {
            addAll((Collection) principal, realmName);
        } else {
            add(principal, realmName);
        }
    }

因为我们传的不是集合，而是String，所以走到else

    public void add(Object principal, String realmName) {
        if (realmName == null) {
            throw new IllegalArgumentException("realmName argument cannot be null.");
        }
        if (principal == null) {
            throw new IllegalArgumentException("principal argument cannot be null.");
        }
        this.cachedToString = null;
        getPrincipalsLazy(realmName).add(principal);
    }

两个值都不是null,走到

getPrincipalsLazy(realmName).add(principal);

继续挖：

    protected Collection getPrincipalsLazy(String realmName) {
        if (realmPrincipals == null) {
            realmPrincipals = new LinkedHashMap<String, Set>();
        }
        Set principals = realmPrincipals.get(realmName);
        if (principals == null) {
            principals = new LinkedHashSet();
            realmPrincipals.put(realmName, principals);
        }
        return principals;
    }

意思就是先设置了一下Realm，然后返回principals，principals是一个Set集合。然后再去add，把我们本次添加的principal，也就是“admin”字符串加进去。

又因为这一句：

 realmPrincipals.put(realmName, principals);

所以，最终principals会多一个principal = “admin”。

7. ShiroConfig实现

分三步，分别是

1.创建realm对象，连接数据库，做认证和授权

2.将自定义realm交给SecurityManager管理所有用户

3.创建Shiro工厂，设置需要过滤的对象

直接贴代码：

package com.edu.config;

import java.util.LinkedHashMap;
import java.util.Map;

import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ShiroConfig {
    
    
    //1.创建realm对象，连接数据库，做认证和授权
    @Bean
    public UserRealm userRealm(){
        return new UserRealm();
    }
    
    
    //2.将自定义realm交给SecurityManager管理所有用户
    @Bean(name="securityManager")
    public DefaultWebSecurityManager getDefaultWebSecurityManager(@Qualifier("userRealm") UserRealm userRealm){
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        
        //关联Userrealm
        defaultWebSecurityManager.setRealm(userRealm);
        
        return defaultWebSecurityManager;
        
    }
    
    //3.ShiroFilterFactoryBean  创建Shiro工厂，设置需要过滤的对象
    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("securityManager")DefaultWebSecurityManager defaultWebSecurityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        //设置案权管理器
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        
        //添加过滤器
        /**
         * anon:无需认证
         * authc：必须认证
         * role:拥有某个角色权限才能访问
         * perms:拥有某个资源权限才能访问
         * user:必须拥有记住我功能才能用
         */
        Map<String,String> filterChainDefinitionMap = new LinkedHashMap<>();
        filterChainDefinitionMap.put("/admin/*", "authc");  //所有带admin的请求都要验证登录

        
        //关于分类的权限操作
        filterChainDefinitionMap.put("/type/add", "perms[type:add]");  
        filterChainDefinitionMap.put("/type/edit", "perms[type:edit]");  
        filterChainDefinitionMap.put("/type/delete", "perms[type:delete]");  
        
        
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        
        //设置登录的请求 -- 跳转到登录页面
        shiroFilterFactoryBean.setLoginUrl("/view/login");
        
        //设置未授权页面 -- 就会默认跳转到未授权页面
        //shiroFilterFactoryBean.setUnauthorizedUrl("/view/noauth");
        
        return shiroFilterFactoryBean;
    }
    
}

8.UserController

终于创建用户控制器了，里面就有一个登录的方法：

package com.edu.controller;

import java.util.HashMap;
import java.util.Map;

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.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class UserController {

    @RequestMapping("/user/login")
    @ResponseBody
    public Map<String,Object> login(String userName,String password,Model m){
        
        Map<String,Object> result = new HashMap<>();
        result.put("code",0);
        
        //获取当前用户
        Subject subject = SecurityUtils.getSubject();
        //得到登录的数据
        UsernamePasswordToken token = new UsernamePasswordToken(userName, password);
        
        try{
            subject.login(token); //就是执行登录的方法，如果没有异常，就是登录成功！
            //能走到这就说明登录成功了
            return result;
            
        }catch(UnknownAccountException e){
            result.put("code",-1);
            result.put("msg", "用户名不存在！");
            return result;
        }catch(IncorrectCredentialsException e){
            result.put("code",-1);
            result.put("msg", "密码错误！");
            return result;
        }
        
        
    }
}

这个控制器需要配合login.jsp来完成一个完整的登录功能。

登录的jsp页面我做了一些调整，使得可以正确和这个项目对接，代码太多我就不贴了，有需要的去群文件自取。

9. 一些页面

主要是后台管理系统的主页面，还有一个未授权页面。

10. 类别控制器

@Controller
@RequestMapping("/type")
public class TypeController {

    @RequestMapping("/add")
    @ResponseBody
    public Map<String,Object> add(){
        
        System.out.println("分类新增");
        
        return null;
    }
}

就简单的测试一下。

11. 测试啦

启动项目，我们不登陆，直接访问：http://localhost:8080/edu/admin/index
因为我们在Shiro的过滤器工厂Bean里面以及配置了：

        /**
         * anon:无需认证
         * authc：必须认证
         * role:拥有某个角色权限才能访问
         * perms:拥有某个资源权限才能访问
         * user:必须拥有记住我功能才能用
         */
        Map<String,String> filterChainDefinitionMap = new LinkedHashMap<>();
        filterChainDefinitionMap.put("/admin/*", "authc");  //所有带admin的请求都要验证登录

所以会直接返回登录页面。

果然吧，接下来，我们用管理员账号去登录：

成功了，来到了后台管理页面。接下来，我们访问http://localhost:8080/edu/type/add

结果后台打印了：

因为我们有type:add的权限，所以也成功了！

关闭浏览器，重新登录，这次我们用一个没有权限的用户：

root1的roleId是2，没有权限的。

可以进后台管理页面

接下来访问http://localhost:8080/edu/type/add

如果你把这一句放开，就会跳转到未授权页面：

shiroFilterFactoryBean.setUnauthorizedUrl("/view/noauth");

基于SpringBoot打造在线教育系统（3）-- 登录与授权管

更正

1. 登录的准备

2. 建三张表

3. 创建三个Dao

4. 引入Shiro的依赖

5. 配置Shiro到SpringBoot

6. 自定义realm

6.1 认证

6.2 授权

6.3 认证方法

6.4 授权方法

6.5 简单挖掘一下源码（如不感兴趣可以直接条过本小节）

7. ShiroConfig实现

1.创建realm对象，连接数据库，做认证和授权

2.将自定义realm交给SecurityManager管理所有用户

3.创建Shiro工厂，设置需要过滤的对象

8.UserController

9. 一些页面

10. 类别控制器

11. 测试啦

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

SpringBoot极简教程 · Spring Boot

MyBatis+SpringMVC+SpringBoot

SpringBoot精选

SpringCloud