Spring Boot 集成Shiro的多realm配置过程

我在做毕设的时候采用shiro进行登录认证和权限管理的实现。其中需求涉及使用三个角色分别是:学生、教师、管理员。现在要三者实现分开登录。即需要三个Realm——StudentRealm和TeacherRealm、AdminRealm,分别处理学生、教师和管理员的验证功能。

但是正常情况下,当定义了多个Realm,无论是学生登录,教师登录,还是管理员登录,都会由这三个Realm共同处理。这是因为,当配置了多个Realm时,我们通常使用的认证器是shiro自带的org.apache.shiro.authc.pam.ModularRealmAuthenticator,其中决定使用的Realm的是doAuthenticate()方法,源代码如下:

protected AuthenticationInfo doAuthenticate(AuthenticationToken authenticationToken) throws AuthenticationException {
  assertRealmsConfigured();
  Collection<Realm> realms = getRealms();
  if (realms.size() == 1) {
   return doSingleRealmAuthentication(realms.iterator().next(), authenticationToken);
  } else {
   return doMultiRealmAuthentication(realms, authenticationToken);
  }
 }

上述代码的意思就是如果有多个Realm就会使用所有配置的Realm。 只有一个的时候,就直接使用当前的Realm。

为了实现需求,我会创建一个org.apache.shiro.authc.pam.ModularRealmAuthenticator的子类,并重写doAuthenticate()方法,让特定的Realm完成特定的功能。如何区分呢?我会同时创建一个org.apache.shiro.authc.UsernamePasswordToken的子类,在其中添加一个字段loginType,用来标识登录的类型,即是学生登录、教师登录,还是管理员登录。具体步骤如下(我的代码使用的是Groovy):

enum LoginType {
 STUDENT("Student"), ADMIN("Admin"), TEACHER("Teacher")

 private String type

 private LoginType(String type) {
  this.type = type
 }

 @Override
 public String toString() {
  return this.type.toString()
 }
}

接下来新建org.apache.shiro.authc.UsernamePasswordToken的子类UserToken

import org.apache.shiro.authc.UsernamePasswordToken

class UserToken extends UsernamePasswordToken {

 //登录类型,判断是学生登录,教师登录还是管理员登录
 private String loginType

 public UserToken(final String username, final String password,String loginType) {
  super(username,password)
  this.loginType = loginType
 }

 public String getLoginType() {
  return loginType
 }
 public void setLoginType(String loginType) {
  this.loginType = loginType
 }
}

第三步:新建org.apache.shiro.authc.pam.ModularRealmAuthenticator的子类UserModularRealmAuthenticator:

import org.apache.shiro.authc.AuthenticationException
import org.apache.shiro.authc.AuthenticationInfo
import org.apache.shiro.authc.AuthenticationToken
import org.apache.shiro.authc.pam.ModularRealmAuthenticator
import org.apache.shiro.realm.Realm
import org.slf4j.Logger
import org.slf4j.LoggerFactory

/**
 * 当配置了多个Realm时,我们通常使用的认证器是shiro自带的org.apache.shiro.authc.pam.ModularRealmAuthenticator,其中决定使用的Realm的是doAuthenticate()方法
 *
 * 自定义Authenticator
 * 注意,当需要分别定义处理学生和教师和管理员验证的Realm时,对应Realm的全类名应该包含字符串“Student”“Teacher”,或者“Admin”。
 * 并且,他们不能相互包含,例如,处理学生验证的Realm的全类名中不应该包含字符串"Admin"。
 */
class UserModularRealmAuthenticator extends ModularRealmAuthenticator {

 private static final Logger logger = LoggerFactory.getLogger(UserModularRealmAuthenticator.class)

 @Override
 protected AuthenticationInfo doAuthenticate(AuthenticationToken authenticationToken)
   throws AuthenticationException {
  logger.info("UserModularRealmAuthenticator:method doAuthenticate() execute ")
  // 判断getRealms()是否返回为空
  assertRealmsConfigured()
  // 强制转换回自定义的CustomizedToken
  UserToken userToken = (UserToken) authenticationToken
  // 登录类型
  String loginType = userToken?.getLoginType()
  // 所有Realm
  Collection<Realm> realms = getRealms()
  // 登录类型对应的所有Realm
  Collection<Realm> typeRealms = new ArrayList<>()
  for (Realm realm : realms) {
   if (realm?.getName()?.contains(loginType))
    typeRealms?.add(realm)
  }

  // 判断是单Realm还是多Realm
  if (typeRealms?.size() == 1){
   logger.info("doSingleRealmAuthentication() execute ")
   return doSingleRealmAuthentication(typeRealms?.get(0), userToken)
  }
  else{
   logger.info("doMultiRealmAuthentication() execute ")
   return doMultiRealmAuthentication(typeRealms, userToken)
  }
 }
}

第四步:创建分别处理学生登录和教师登录、管理员登录的Realm:
我这里直接贴出了我项目中的代码,你们可以根据具体的需求进行操作。
AdminShiroRealm :

package com.ciyou.edu.config.shiro.admin
import com.ciyou.edu.config.shiro.common.UserToken
import com.ciyou.edu.entity.Admin
import com.ciyou.edu.service.AdminService
import com.ciyou.edu.service.PermissionService
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.authc.UnknownAccountException
import org.apache.shiro.authz.AuthorizationException
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.util.ByteSource
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.annotation.Lazy

class AdminShiroRealm extends AuthorizingRealm {

  private static final Logger logger = LoggerFactory.getLogger(AdminShiroRealm.class)
  @Autowired
  @Lazy
  private AdminService adminService

 @Autowired
 @Lazy
 private PermissionService permissionService

 @Override
 protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

  logger.info("开始Admin身份认证...")
  UserToken userToken = (UserToken)token
  String adminName = userToken?.getUsername() //获取用户名,默认和login.html中的adminName对应。
  Admin admin = adminService?.findByAdminName(adminName)

  if (admin == null) {
   //没有返回登录用户名对应的SimpleAuthenticationInfo对象时,就会在LoginController中抛出UnknownAccountException异常
   throw new UnknownAccountException("用户不存在!")
  }

  //验证通过返回一个封装了用户信息的AuthenticationInfo实例即可。
  SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
    admin, //用户信息
    admin?.getPassword(), //密码
    getName() //realm name
  )
  authenticationInfo.setCredentialsSalt(ByteSource.Util.bytes(admin?.getAdminName())) //设置盐
  logger.info("返回Admin认证信息:" + authenticationInfo)
  return authenticationInfo
 }

//当访问到页面的时候,链接配置了相应的权限或者shiro标签才会执行此方法否则不会执行
 @Override
 protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

  logger.info("开始Admin权限授权(进行权限验证!!)")
  if (principals == null) {
   throw new AuthorizationException("PrincipalCollection method argument cannot be null.")
  }
  SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo()
  if(principals?.getPrimaryPrincipal() instanceof Admin){
   Admin admin = (Admin) principals?.getPrimaryPrincipal()
   logger.info("当前Admin :" + admin )
   authorizationInfo?.addRole("Admin")
   //每次都从数据库重新查找,确保能及时更新权限
   admin?.setPermissionList(permissionService?.findPermissionByAdmin(admin?.getAdminId()))
   admin?.getPermissionList()?.each {current_Permission ->
    authorizationInfo?.addStringPermission(current_Permission?.getPermission())
   }
   logger.info("当前Admin授权角色:" +authorizationInfo?.getRoles() + ",权限:" + authorizationInfo?.getStringPermissions())
   return authorizationInfo
  }
 }
}

TeacherShiroRealm :

package com.ciyou.edu.config.shiro.teacher

import com.ciyou.edu.config.shiro.common.UserToken
import com.ciyou.edu.entity.Teacher
import com.ciyou.edu.service.TeacherService
import org.apache.shiro.authc.*
import org.apache.shiro.authz.AuthorizationException
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.util.ByteSource
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.annotation.Lazy

class TeacherShiroRealm extends AuthorizingRealm {
 private static final Logger logger = LoggerFactory.getLogger(TeacherShiroRealm.class)

 //在自定义Realm中注入的Service声明中加入@Lazy注解即可解决@cacheble注解无效问题
 //解决同时使用Redis缓存数据和缓存shiro时,@cacheble无效的问题
  @Autowired
  @Lazy
  private TeacherService teacherService

 @Override
 protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

  logger.info("开始Teacher身份认证..")
  UserToken userToken = (UserToken)token
  String teacherId = userToken?.getUsername()
  Teacher teacher = teacherService?.findByTeacherId(teacherId)

  if (teacher == null) {
   //没有返回登录用户名对应的SimpleAuthenticationInfo对象时,就会在LoginController中抛出UnknownAccountException异常
   throw new UnknownAccountException("用户不存在!")
  }

  //验证通过返回一个封装了用户信息的AuthenticationInfo实例即可。
  SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
    teacher, //用户信息
    teacher?.getPassword(), //密码
    getName() //realm name
  )
  authenticationInfo.setCredentialsSalt(ByteSource.Util.bytes(teacher?.getTeacherId())) //设置盐

  return authenticationInfo
 }

//当访问到页面的时候,链接配置了相应的权限或者shiro标签才会执行此方法否则不会执行
 @Override
 protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
  logger.info("开始Teacher权限授权")
  if (principals == null) {
   throw new AuthorizationException("PrincipalCollection method argument cannot be null.")
  }
  SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo()
  if(principals?.getPrimaryPrincipal() instanceof Teacher){
   authorizationInfo?.addRole("Teacher")
   return authorizationInfo
  }
 }
}

StudentShiroRealm :

package com.ciyou.edu.config.shiro.student

import com.ciyou.edu.config.shiro.common.UserToken
import com.ciyou.edu.entity.Student
import com.ciyou.edu.service.StudentService
import org.apache.shiro.authc.*
import org.apache.shiro.authz.AuthorizationException
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.util.ByteSource
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.annotation.Lazy

class StudentShiroRealm extends AuthorizingRealm {
 private static final Logger logger = LoggerFactory.getLogger(StudentShiroRealm.class)

 //在自定义Realm中注入的Service声明中加入@Lazy注解即可解决@cacheble注解无效问题
 //解决同时使用Redis缓存数据和缓存shiro时,@cacheble无效的问题
  @Autowired
  @Lazy
  private StudentService studentService

 @Override
 protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

  logger.info("开始Student身份认证..")
  UserToken userToken = (UserToken)token
  String studentId = userToken?.getUsername()
  Student student = studentService?.findByStudentId(studentId)

  if (student == null) {
   //没有返回登录用户名对应的SimpleAuthenticationInfo对象时,就会在LoginController中抛出UnknownAccountException异常
   throw new UnknownAccountException("用户不存在!")
  }

  //验证通过返回一个封装了用户信息的AuthenticationInfo实例即可。
  SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
    student, //用户信息
    student?.getPassword(), //密码
    getName() //realm name
  )
  authenticationInfo.setCredentialsSalt(ByteSource.Util.bytes(student?.getStudentId())) //设置盐

  return authenticationInfo
 }

//当访问到页面的时候,链接配置了相应的权限或者shiro标签才会执行此方法否则不会执行
 @Override
 protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
  logger.info("开始Student权限授权")
  if (principals == null) {
   throw new AuthorizationException("PrincipalCollection method argument cannot be null.")
  }
  SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo()
  if(principals?.getPrimaryPrincipal() instanceof Student){
   authorizationInfo?.addRole("Student")
   return authorizationInfo
  }
 }
}

接下来是对Shiro进行多realm的注解配置。
这里直接贴出我项目中的代码。

上面是我进行shiro进行配置的类,下面是主要的一些代码:

//SecurityManager 是 Shiro 架构的核心,通过它来链接Realm和用户(文档中称之为Subject.)
 @Bean
 public SecurityManager securityManager() {
  DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager()
  //设置realm.
  securityManager.setAuthenticator(modularRealmAuthenticator())
  List<Realm> realms = new ArrayList<>()
  //添加多个Realm
  realms.add(adminShiroRealm())
  realms.add(teacherShiroRealm())
  realms.add(studentShiroRealm())
  securityManager.setRealms(realms)
  // 自定义缓存实现 使用redis
  securityManager.setCacheManager(cacheManager())
  // 自定义session管理 使用redis
  securityManager.setSessionManager(sessionManager())
  //注入记住我管理器;
  securityManager.setRememberMeManager(rememberMeManager())
  return securityManager
 }

 /**
  * 系统自带的Realm管理,主要针对多realm
  * */
 @Bean
 public ModularRealmAuthenticator modularRealmAuthenticator(){
  //自己重写的ModularRealmAuthenticator
  UserModularRealmAuthenticator modularRealmAuthenticator = new UserModularRealmAuthenticator()
  modularRealmAuthenticator.setAuthenticationStrategy(new AtLeastOneSuccessfulStrategy())
  return modularRealmAuthenticator
 }

 @Bean
 public AdminShiroRealm adminShiroRealm() {
  AdminShiroRealm adminShiroRealm = new AdminShiroRealm()
  adminShiroRealm.setCredentialsMatcher(hashedCredentialsMatcher())//设置解密规则
  return adminShiroRealm
 }

 @Bean
 public StudentShiroRealm studentShiroRealm() {
  StudentShiroRealm studentShiroRealm = new StudentShiroRealm()
  studentShiroRealm.setCredentialsMatcher(hashedCredentialsMatcher())//设置解密规则
  return studentShiroRealm
 }

 @Bean
 public TeacherShiroRealm teacherShiroRealm() {
  TeacherShiroRealm teacherShiroRealm = new TeacherShiroRealm()
  teacherShiroRealm.setCredentialsMatcher(hashedCredentialsMatcher())//设置解密规则
  return teacherShiroRealm
 }

 //因为我们的密码是加过密的,所以,如果要Shiro验证用户身份的话,需要告诉它我们用的是md5加密的,并且是加密了两次。同时我们在自己的Realm中也通过SimpleAuthenticationInfo返回了加密时使用的盐。这样Shiro就能顺利的解密密码并验证用户名和密码是否正确了。
 @Bean
 public HashedCredentialsMatcher hashedCredentialsMatcher() {
  HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher()
  hashedCredentialsMatcher.setHashAlgorithmName("md5")//散列算法:这里使用MD5算法;
  hashedCredentialsMatcher.setHashIterations(2)//散列的次数,比如散列两次,相当于 md5(md5(""));
  return hashedCredentialsMatcher;
 }

接下来就是Controller中实现登录的功能了,这里我只贴出我项目中Admin登录的代码:

package com.ciyou.edu.controller.admin

import com.ciyou.edu.config.shiro.common.LoginType
import com.ciyou.edu.config.shiro.common.UserToken
import com.ciyou.edu.entity.Admin
import com.ciyou.edu.utils.JSONUtil
import org.apache.shiro.SecurityUtils
import org.apache.shiro.authc.AuthenticationException
import org.apache.shiro.subject.Subject
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import org.springframework.stereotype.Controller
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RequestMethod
import org.springframework.web.bind.annotation.ResponseBody

/**
 * @Author C.
 * @Date 2018-02-02 20:46
 * admin登录Controller
 */
@Controller
class AdminLoginController {

 private static final Logger logger = LoggerFactory.getLogger(AdminLoginController.class)
 private static final String ADMIN_LOGIN_TYPE = LoginType.ADMIN.toString()

 /**
  * admin登录
  * @param admin
  * @return 登录结果
  */
 @RequestMapping(value="/adminLogin",method=RequestMethod.POST, produces="application/json;charset=UTF-8")
 @ResponseBody
 public String loginAdmin(Admin admin){
  logger.info("登录Admin: " + admin)
  //后台校验提交的用户名和密码
  if(!admin?.getAdminName() || admin?.adminName?.trim() == ""){
   return JSONUtil.returnFailReuslt("账号不能为空")
  }else if(!admin?.getPassword() || admin?.getPassword()?.trim() == ""){
   return JSONUtil.returnFailReuslt("密码不能为空")
  }else if(admin?.getAdminName()?.length() < 3 || admin?.getAdminName()?.length() >15){
   return JSONUtil.returnFailReuslt("账号长度必须在3~15之间")
  }else if(admin?.getPassword()?.length() < 3 || admin?.getPassword()?.length() >15){
   return JSONUtil.returnFailReuslt("密码长度必须在3~15之间")
  }

  //获取Subject实例对象
  //在shiro里面所有的用户的会话信息都会由Shiro来进行控制,那么也就是说只要是与用户有关的一切的处理信息操作都可以通过Shiro取得,
  // 实际上可以取得的信息可以有用户名、主机名称等等,这所有的信息都可以通过Subject接口取得
  Subject subject = SecurityUtils.getSubject()

  //将用户名和密码封装到继承了UsernamePasswordToken的userToken
  UserToken userToken = new UserToken(admin?.getAdminName(), admin?.getPassword(), ADMIN_LOGIN_TYPE)
  userToken.setRememberMe(false)
  try {
   //认证
   // 传到ModularRealmAuthenticator类中,然后根据ADMIN_LOGIN_TYPE传到AdminShiroRealm的方法进行认证
   subject?.login(userToken)
   //Admin存入session
   SecurityUtils.getSubject()?.getSession()?.setAttribute("admin",(Admin)subject?.getPrincipal())
   return JSONUtil.returnSuccessResult("登录成功")
  } catch (AuthenticationException e) {
   //认证失败就会抛出AuthenticationException这个异常,就对异常进行相应的操作,这里的处理是抛出一个自定义异常ResultException
   //到时候我们抛出自定义异常ResultException,用户名或者密码错误
   logger.info("认证错误:" + e.getMessage())
   return JSONUtil.returnFailReuslt("账号或者密码错误")
  }
 }

 @RequestMapping(value="/admin/adminLogout")
 public String logoutAdmin(){
  SecurityUtils.getSubject()?.logout()
  return "redirect:/adminLogin"
 }
}

现在Spring Boot中集成Shiro实现多realm配置就完成了。

感谢以下博文,在我学习的过程中给了我很多帮助,我的博文也有一些内容参考他们的,还不够清楚的读者可以参考:
shiro实现不同身份使用不同Realm进行验证
SpringBoot+Shiro学习之数据库动态权限管理和Redis缓存
Springboot多realm集成,无ini文件,无xml配置

想看项目具体源码,或者对我项目感兴趣的可以查看:CIYOU

到此这篇关于Spring Boot 集成Shiro的多realm配置过程的文章就介绍到这了,更多相关Spring Boot多realm配置内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Springboot+Shiro记录用户登录信息并获取当前登录用户信息的实现代码

    由于最近做项目需要,在用户登陆后有一个功能是需要用户的信息,进行写入数据库的操作.但是目前还用不到Shiro的高级权限,只为了简单获取用户信息,自己整合了一个只记录用户,获取用户信息的功能. 导入Shiro依赖 <!-- Shiro --> <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId> <version

  • Spring boot整合shiro+jwt实现前后端分离

    本文实例为大家分享了Spring boot整合shiro+jwt实现前后端分离的具体代码,供大家参考,具体内容如下 这里内容很少很多都为贴的代码,具体内容我经过了看源码和帖子加了注释.帖子就没用太多的内容 先下载shiro和jwt的jar包 <!-- shiro包 --> <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId

  • spring boot整合Shiro实现单点登录的示例代码

    Shiro是什么 Shiro是一个Java平台的开源权限框架,用于认证和访问授权.具体来说,满足对如下元素的支持: 用户,角色,权限(仅仅是操作权限,数据权限必须与业务需求紧密结合),资源(url). 用户分配角色,角色定义权限. 访问授权时支持角色或者权限,并且支持多级的权限定义. Q:对组的支持? A:shiro默认不支持对组设置权限. Q:是否可以满足对组进行角色分配的需求? A:扩展Realm,可以支持对组进行分配角色,其实就是给该组下的所有用户分配权限. Q:对数据权限的支持? 在业务

  • SpringBoot + Shiro前后端分离权限

    shiro 验证通过后的信息保存在session 中,而ajax 每次传的都是不同的sessionid ,所以主要的区别就是需要修改shiro获取sessionid的方式.这里使用的是登录后将后台的sessionid 传到前端然后存放到 cookie(这个存放的地方视情况而定),然后每次请求后端时在Header中携带此信息,这里起名为Authorization shiro 中 默认获取Sessionid的类是 DefaultWebSessionManager 所以需要重写此类 import or

  • SpringBoot集成shiro,MyRealm中无法@Autowired注入Service的问题

    网上说了很多诸如是Spring加载顺序,shiroFilter在Spring自动装配bean之前的问题,其实也有可能忽略如下低级错误. 在ShiroConfiguration中要使用@Bean在ApplicationContext注入MyRealm,不能直接new对象. 道理和Controller中调用Service一样,都要是SpringBean,不能自己new. 错误方式: @Bean(name = "securityManager") public SecurityManager

  • Spring Boot 集成Shiro的多realm实现以及shiro基本入门教程

    情景 我的项目中有六个用户角色(学校管理员,学生等),需要进行分别登陆.如果在一个realm中,对controller封装好的Token进行Service验证,需要在此realm中注入六个数据库操作对象,然后写一堆if语句来判断应该使用那个Service服务,然后再在验证方法(doGetAuthorizationInfo)中写一堆if来进行分别授权,这样写不仅会让代码可读性会非常低而且很难后期维护修改(刚写完的时候只有上帝和你能看懂你写的是什么,一个月之后你写的是什么就只有上帝能看懂了). 所以

  • Spring Boot 集成Shiro的多realm配置过程

    我在做毕设的时候采用shiro进行登录认证和权限管理的实现.其中需求涉及使用三个角色分别是:学生.教师.管理员.现在要三者实现分开登录.即需要三个Realm--StudentRealm和TeacherRealm.AdminRealm,分别处理学生.教师和管理员的验证功能. 但是正常情况下,当定义了多个Realm,无论是学生登录,教师登录,还是管理员登录,都会由这三个Realm共同处理.这是因为,当配置了多个Realm时,我们通常使用的认证器是shiro自带的org.apache.shiro.au

  • spring boot 集成shiro的配置方法

    spring boot提供了一个自带的认证框架,同时也提供自定义的javaconfig配置扩展,spring-sercurity同样也是优秀的框架,但是习惯了用apache shiro框架,而且原项目就是集成的shiro框架,到网上找了一下配置方式,没找到完全配置的方法,因此决定自己动手,丰衣足食! 要在spring boot上集成其他框架,首先要会spring javaconfig方法,利用此方法同样可以配置其他模块,废话少说,开始... 开始前需要导入maven依赖(shiro-web可选)

  • spring boot集成shiro详细教程(小结)

    我们开发时候有时候要把传统spring shiro转成spring boot项目,或者直接集成,name我们要搞清楚一个知识,就是 xml配置和spring bean代码配置的关系,这一点很重要,因为spring boot是没有xml配置文件的(也不绝对,spring boot也是可以引用xml配置的) 引入依赖: <dependency> <artifactId>ehcache-core</artifactId> <groupId>net.sf.ehcac

  • 详解Spring Boot 集成Shiro和CAS

    请大家在看本文之前,先了解如下知识点: 1.Shiro 是什么?怎么用? 2.Cas 是什么?怎么用? 3.最好有spring基础 首先看一下下面这张图: 第一个流程是单纯使用Shiro的流程. 第二个流程是单纯使用Cas的流程. 第三个图是Shiro集成Cas后的流程. PS:流程图急急忙忙画的,整体上应该没有什么问题,具体细节问题还请大家留言指正. 如果你只是打算用到你的Spring Boot项目中,那么看着如下配置完成便可. 如果你想进一步了解其中的细节,还是建议大家单独配置Shiro.单

  • Spring Boot集成Shiro实现动态加载权限的完整步骤

    一.前言 本文小编将基于 SpringBoot 集成 Shiro 实现动态uri权限,由前端vue在页面配置uri,Java后端动态刷新权限,不用重启项目,以及在页面分配给用户 角色 . 按钮 .uri 权限后,后端动态分配权限,用户无需在页面重新登录才能获取最新权限,一切权限动态加载,灵活配置 基本环境 spring-boot 2.1.7 mybatis-plus 2.1.0 mysql 5.7.24 redis 5.0.5 温馨小提示:案例demo源码附文章末尾,有需要的小伙伴们可参考哦 ~

  • Spring Boot集成Shiro并利用MongoDB做Session存储的方法详解

    前言 shiro是一个权限框架,具体的使用可以查看其官网 http://shiro.apache.org/ 它提供了很方便的权限认证和登录的功能. 而springboot作为一个开源框架,必然提供了和shiro整合的功能! 之前项目鉴权一直使用的Shiro,那是在Spring MVC里面使用的比较多,而且都是用XML来配置,用Shiro来做权限控制相对比较简单而且成熟,而且我一直都把Shiro的session放在mongodb中,这个比较符合mongodb的设计初衷,而且在分布式项目中mongo

  • spring boot 集成 shiro 自定义密码验证 自定义freemarker标签根据权限渲染不同页面(推荐

    项目里一直用的是 spring-security ,不得不说,spring-security 真是东西太多了,学习难度太大(可能我比较菜),这篇博客来总结一下折腾shiro的成果,分享给大家,强烈推荐shiro,真心简单 : ) 引入依赖 <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId> <version>1.4

  • Spring Boot自定义Starter组件开发实现配置过程

    目录 自定义starter 为什么要自定义starter 自定义starter的命名规则 实现方法 引入依赖 编写测试类 创建配置类 创建spring.factories文件 乱码问题 解决方案: 1. 使用yml配置文件进行配置. 2. 使用自定义配置文件如: 3. 把中文换成对应的ASCII码. 自定义starter SpringBoot中的starter是一种非常重要的机制,能够抛弃以前繁杂的配置,将其统一集成进 starter,应用者只需要在maven中引入starter依赖,Sprin

  • 详解Spring Boot集成MyBatis(注解方式)

    MyBatis是支持定制化SQL.存储过程以及高级映射的优秀的持久层框架,避免了几乎所有的JDBC代码和手动设置参数以及获取结果集.spring Boot是能支持快速创建Spring应用的Java框架.本文通过一个例子来学习Spring Boot如何集成MyBatis,而且过程中不需要XML配置. 创建数据库 本文的例子使用MySQL数据库,首先创建一个用户表,执行sql语句如下: CREATE TABLE IF NOT EXISTS user ( `id` INT(10) NOT NULL A

随机推荐