46、shiro认证和权限管理介绍

最新推荐文章于 2022-04-07 17:54:17 发布
最新推荐文章于 2022-04-07 17:54:17 发布
阅读量549 收藏 1
点赞数
分类专栏： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lixiang987654321/article/details/100607018
版权

shiro认证和权限管理介绍

前言

Apache Shiro是一个功能强大、灵活的，开源的安全框架。它可以干净利落地处理身份验证、授权、企业会话管理和加密。Apache Shiro的首要目标是易于使用和理解。安全通常很复杂，甚至让人感到很痛苦，但是Shiro却不是这样子的。一个好的安全框架应该屏蔽复杂性，向外暴露简单、直观的API，来简化开发人员实现应用程序安全所花费的时间和精力。

Shiro能做什么呢？

  • 验证用户身份
  • 用户访问权限控制，比如：1、判断用户是否分配了一定的安全角色。2、判断用户是否被授予完成某个操作的权限
  • 在非 web 或 EJB 容器的环境下可以任意使用Session API
  • 可以响应认证、访问控制，或者 Session 生命周期中发生的事件
  • 可将一个或以上用户安全数据源数据组合成一个复合的用户 “view”(视图)
  • 支持单点登录(SSO)功能
  • 支持提供“Remember Me”服务，获取用户关联信息而无需登录

等等——都集成到一个有凝聚力的易于使用的API。
Shiro 致力在所有应用环境下实现上述功能，小到命令行应用程序，大到企业应用中，而且不需要借助第三方框架、容器、应用服务器等。当然 Shiro 的目的是尽量的融入到这样的应用环境中去，但也可以在它们之外的任何环境下开箱即用。

1、用户名密码身份认证流程

在这里插入图片描述
上边的流程图中需要理解以下关键对象：
Subject：主体
访问系统的用户，主体可以是用户、程序等，进行认证的都称为主体；
Principal：身份信息
是主体（subject）进行身份认证的标识，标识必须具有唯一性，如用户名、手机号、邮箱地址等，一个主体可以有多个身份，但是必须有一个主身份（Primary Principal）。
credential：凭证信息
是只有主体自己知道的安全信息，如密码、证书等。

2、授权

授权，即访问控制，控制谁能访问哪些资源。主体进行身份认证后需要分配权限方可访问系统的资源，对于某些资源没有权限是无法访问的。
在这里插入图片描述
授权可简单理解为who对what(which)进行How操作：
Who，即主体（Subject），主体需要访问系统中的资源。
What，即资源（Resource），如系统菜单、页面、按钮、类方法、系统商品信息等。资源包括资源类型和资源实例，比如商品信息为资源类型，类型为t01的商品为资源实例，编号为001的商品信息也属于资源实例。
How，权限/许可（Permission），规定了主体对资源的操作许可，权限离开资源没有意义，如用户查询权限、用户添加权限、某个类方法的调用权限、编号为001用户的修改权限等，通过权限可知主体对哪些资源都有哪些操作许可。
权限分为粗颗粒和细颗粒，粗颗粒权限是指对资源类型的权限，细颗粒权限是对资源实例的权限。
主体、资源、权限关系如下图：
在这里插入图片描述

3、权限模型

主体、资源、权限通过数据模型表示。
主体（账号、密码）
资源（资源名称、访问地址）
权限（权限名称、资源id）
角色（角色名称）
角色和权限关系（角色id、权限id）
主体和角色关系（主体id、角色id）
关系如下：在这里插入图片描述
实际情况中，通常企业开发中将资源和权限表合并为一张权限表，如下：
资源（资源名称、访问地址）
权限（权限名称、资源id）

合并为：
权限（权限名称、资源名称、资源访问地址）
在这里插入图片描述
上图常被称为权限管理的通用模型，不过企业在开发中根据系统自身的特点还会对上图进行修改，但是用户、角色、权限、用户角色关系、角色权限关系是需要去理解的。

4、权限分配

对主体分配权限，主体只允许在权限范围内对资源进行操作，比如：对u01用户分配商品修改权限，u01用户只能对商品进行修改。权限分配的数据通常需要持久化，根据上边的数据模型创建表并将用户的权限信息存储在数据库中。

5、权限控制

用户拥有了权限即可操作权限范围内的资源，系统不知道主体是否具有访问权限需要对用户的访问进行控制。

基于角色的访问控制
RBAC基于角色的访问控制（Role-Based Access Control）是以角色为中心进行访问控制，比如：主体的角色为总经理可以查询企业运营报表，查询员工工资信息等，访问控制流程如下：在这里插入图片描述
上图中的判断逻辑代码可以理解为：

if(主体.hasRole("总经理角色id")){
查询工资
}

缺点：
以角色进行访问控制粒度较粗，如果上图中查询工资所需要的角色变化为总经理和部门经理，此时就需要修改判断逻辑为“判断主体的角色是否是总经理或部门经理”，系统可扩展性差。修改代码如下：

if(主体.hasRole("总经理角色id") || 主体.hasRole("部门经理角色id")){
查询工资
}

基于资源的访问控制
RBAC基于资源的访问控制（Resource-Based Access Control）是以资源为中心进行访问控制，比如：主体必须具有查询工资权限才可以查询员工工资信息等，访问控制流程如下：

if(主体.hasPermission("查询工资权限标识")){
查询工资
}

优点：

系统设计时定义好查询工资的权限标识，即使查询工资所需要的角色变化为总经理和部门经理也只需要将“查询工资信息权限”添加到“部门经理角色”的权限列表中，判断逻辑不用修改，系统可扩展性强。

6、权限管理解决方案

粗颗粒度和细颗粒度
对资源类型的管理称为粗颗粒度权限管理，即只控制到菜单、按钮、方法。粗粒度的例子比如：用户具有用户管理的权限，具有导出订单明细的权限。
对资源实例的控制称为细颗粒度权限管理，即控制到数据级别的权限，比如：用户只允许修改本部门的员工信息，用户只允许导出自己创建的订单明细。
如何实现粗颗粒度和细颗粒度
对于粗颗粒度的权限管理可以很容易做系统架构级别的功能，即系统功能操作使用统一的粗颗粒度的权限管理。
对于细颗粒度的权限管理不建议做成系统架构级别的功能，因为对数据级别的控制是系统的业务需求，随着业务需求的变更业务功能变化的可能性很大，建议对数据级别的权限控制在业务层个性化开发，比如：用户只允许修改自己创建的商品信息可以在service接口添加校验实现，service接口需要传入当前操作人的标识，与商品信息创建人标识对比，不一致则不允许修改商品信息。

基于url拦截
基于url拦截是企业中常用的权限管理方法，实现思路是：将系统操作的每个url配置在权限表中，将权限对应到角色，将角色分配给用户，用户访问系统功能通过Filter进行过虑，过虑器获取到用户访问的url，只要访问的url是用户分配角色中的url则放行继续访问。
在这里插入图片描述

7、shiro介绍

Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。
既然shiro将安全认证相关的功能抽取出来组成一个框架，使用shiro就可以非常快速的完成认证、授权等功能的开发，降低系统成本。shiro使用广泛，shiro可以运行在web应用，非web应用，集群分布式应用中越来越多的用户开始使用shiro。
java领域中spring security(原名Acegi)也是一个开源的权限管理框架，但是spring security依赖spring运行，而shiro就相对独立，最主要是因为shiro使用简单、灵活，所以现在越来越多的用户选择shiro。

Shiro解决了什么问题？
互联网无非就是一些用户C想要使用一些服务S的资源去完成某件事，S的资源不能说给谁用就给谁用，因此产生了权限的概念，即C必须有权限才能操作S的资源。S如何确定C就是C呢？因此又产生了身份验证的概念。一个Authorization一个Authentication就是Shiro解决的最重要的两个问题，其他的功能都是给Shiro打辅助的，比如Session管理，加密处理，记住我等

Shiro是什么？
把Shiro想象成一家安全公司
公司给服务端提供的服务是：服务端把自己维护的权限啊、用户啊、角色啊什么的信息通过接口提供给Shiro，shiro就可以帮服务端处理用户权限角色等的安全认证和授权等工作
公司给客户提供的服务是：客户可以是任何外来的东西，但是想要访问服务端提供的要求权限验证等资源，就必须先经过shiro这层把关，shiro会对客户进行安全认证和授权等工作。
在这里插入图片描述
Shiro架构
在这里插入图片描述
Subject
Subject即主体，外部应用与subject进行交互，subject记录了当前操作用户，将用户的概念理解为当前操作的主体，可能是一个通过浏览器请求的用户，也可能是一个运行的程序。Subject在shiro中是一个接口，接口中定义了很多认证授相关的方法，外部程序通过subject进行认证授，而subject是通过SecurityManager安全管理器进行认证授权

SecurityManager
SecurityManager即安全管理器，对全部的subject进行安全管理，它是shiro的核心，负责对所有的subject进行安全管理。通过SecurityManager可以完成subject的认证、授权等，实质上SecurityManager是通过Authenticator进行认证，通过Authorizer进行授权，通过SessionManager进行会话管理等。
SecurityManager是一个接口，继承了Authenticator, Authorizer, SessionManager这三个接口。

Authenticator
Authenticator即认证器，对用户身份进行认证，Authenticator是一个接口，shiro提供ModularRealmAuthenticator实现类，通过ModularRealmAuthenticator基本上可以满足大多数需求，也可以自定义认证器。

Authorizer
Authorizer即授权器，用户通过认证器认证通过，在访问功能时需要通过授权器判断用户是否有此功能的操作权限。

realm
Realm即领域，相当于datasource数据源，securityManager进行安全认证需要通过Realm获取用户权限数据，比如：如果用户身份数据在数据库那么realm就需要从数据库获取用户身份信息。
注意：
不要把realm理解成只是从数据源取数据，在realm中还有认证授权校验的相关的代码。

sessionManager
sessionManager即会话管理，shiro框架定义了一套会话管理，它不依赖web容器的session，所以shiro可以使用在非web应用上，也可以将分布式应用的会话集中在一点管理，此特性可使它实现单点登录。

SessionDAO
SessionDAO即会话dao，是对session会话操作的一套接口，比如要将session存储到数据库，可以通过jdbc将会话存储到数据库。

CacheManager
CacheManager即缓存管理，将用户权限数据存储在缓存，这样可以提高性能。

Cryptography
Cryptography即密码管理，shiro提供了一套加密/解密的组件，方便开发。比如提供常用的散列、加/解密等功能。

我们需要操作哪些组件呢？
作为一个成熟的跟Apache混的组件，用起来肯定越简单越符合用户习惯。我们使用的时候只需要把用户、角色、权限信息存储好（一般放到数据库里）并提供接口可以把这些信息注入到Shiro中就可以了。然后再对Shiro进行一些简单的配置即可！

8、shiro使用

（1）创建用户权限等相关表
创建5张表，分别记录用户、角色、权限、用户角色关系、角色权限关系。
建表很随意的，字段随便起名字，哪些字段也很随意，甚至有些表可以不存在的（比如权限表）。比如你可以简单的给user表一个id一个name，给role表一个id一个name。

DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` int(32) NOT NULL,
`name` varchar(60) DEFAULT NULL,
`mob` varchar(60) DEFAULT NULL,
`email` varchar(150) DEFAULT NULL,
`valid` int(2) DEFAULT NULL,
`pticket` varchar(200) DEFAULT NULL,
`role_id` int(32) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

DROP TABLE IF EXISTS `user_role`;
CREATE TABLE `user_role` (
`uid` int(32) NOT NULL,
`role_id` int(32) NOT NULL,
PRIMARY KEY (`uid`,`role_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

DROP TABLE IF EXISTS `role`;
CREATE TABLE `role` (
`id` int(32) NOT NULL,
`description` varchar(255) DEFAULT NULL,
`role` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

DROP TABLE IF EXISTS `role_permission`;
CREATE TABLE `role_permission` (
`permission_id` int(32) NOT NULL,
`role_id` int(32) NOT NULL,
PRIMARY KEY (`permission_id`,`role_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

DROP TABLE IF EXISTS `permission`;
CREATE TABLE `permission` (
`id` int(32) NOT NULL,
`name` varchar(255) DEFAULT NULL,
`description` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

（2）加入jar包

<dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-core</artifactId>
          <version>1.2.3</version>
     </dependency>
     <dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-web</artifactId>
          <version>1.2.3</version>
     </dependency>
     <dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-spring</artifactId>
          <version>1.2.3</version>
     </dependency>
     <dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-ehcache</artifactId>
          <version>1.2.3</version>
     </dependency>
     <dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-quartz</artifactId>
          <version>1.2.3</version>
     </dependency>

将shiro的jar包加入项目就可以使用shiro提供的功能了。shiro-core是核心包必须选用，还提供了与web整合的shiro-web、与spring整合的shiro-spring、与任务调度quartz整合的shiro-quartz等。

也可以通过shiro-all包包含所有组件

<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-all</artifactId>
    <version>1.2.3</version>
</dependency>

（3）创建用户服务接口

@Service
public class UserService {
	@Autowired
	private UserRoleDAO userRoleDAO;
	@Autowired
	private UserDAO userDAO;
	@Autowired
	private RoleDAO roleDAO;
	@Autowired
	private PermissionDAO permissionDAO;
	@Autowired
	private RolePermissionDAO rolePermissionDAO;
//根据用户id查询所有的角色信息
public List<Role> findRoles(Integer id) {
	UserRoleExample example = new UserRoleExample();
	example.createCriteria().andUidEqualTo(id);
	List<UserRoleKey> keyList = userRoleDAO.selectByExample(example);
	List<Integer> roleIdList = new ArrayList<>(keyList.size());
	for (UserRoleKey userRoleKey : keyList) {
		roleIdList.add(userRoleKey.getRoleId());
	}
	RoleExample roleExample = new RoleExample();
	roleExample.createCriteria().andIdIn(roleIdList);
	return roleDAO.selectByExample(roleExample);
}

//根据用户的id查询所有权限信息
public List<Permission> findPermissions(Integer id) {
	List<Role> roles = findRoles(id);
	List<Integer> roleIds = new ArrayList<>(roles.size());
	for (Role role : roles) {
		roleIds.add(role.getId());
	}
	RolePermissionExample example = new RolePermissionExample();
	example.createCriteria().andRoleIdIn(roleIds);
	List<RolePermissionKey> keyList = rolePermissionDAO.selectByExample(example);
	List<Integer> permissionIdList = new ArrayList<>(keyList.size());
	for (RolePermissionKey rolePermissionKey : keyList) {
		permissionIdList.add(rolePermissionKey.getPermissionId());
	}
	PermissionExample permissionExample = new PermissionExample();
	if (permissionIdList.size() != 0) {
		permissionExample.createCriteria().andIdIn(permissionIdList);
		return permissionDAO.selectByExample(permissionExample);
	}
	return new ArrayList<>();
}

public User findUserById(String uId) {
	return userDAO.selectByPrimaryKey(Integer.valueOf(uId));
}

@Transactional
public int assignDefaultUserRolePermission(User user) {
	int success1 = userDAO.insert(user);
	UserRoleKey userRoleKey = new UserRoleKey();
	userRoleKey.setUid(user.getId());
	userRoleKey.setRoleId(2);
	int success2 = userRoleDAO.insert(userRoleKey);
	return success1 + success2;
}

}

（4）把获取角色和权限信息的userService的两个接口提供给Shiro，让Shiro有法可依。

  • 首先，UserRealm这个类继承了AuthorizingRealm，这个类的作用是两处获取信息，一处是Subject即用户传过来的信息；一处是我们提供给shiro的userService接口以获取权限信息和角色信息。拿这两个信息之后AuthorizingRealm会自动进行比较，判断用户名密码，用户权限等等。
  • 然后，拿用户凭证信息的是doGetAuthenticationInfo接口，拿角色权限信息的是doGetAuthorizationInfo接口
  • 然后，两个重要参数，AuthenticationToken是我们可以自己实现的用户凭证/密钥信息，PrincipalCollection是用户凭证信息集合。注意Principals表示凭证（比如用户名、手机号、邮箱等）
  • 最后，配置完成对比的信息之后Subject.login(token)的时候就会调用doGetAuthenticationInfo方法；涉及到Subject.hasRole或者Subject.hasPermission的时候就会调用doGetAuthorizationInfo方法；
public class UserRealm extends AuthorizingRealm {
@Autowired
private UserService userService;

//shiro的权限信息配置
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
String uid = (String) principals.getPrimaryPrincipal();

List<Role> roles = userService.findRoles(Integer.valueOf(uid));
Set<String> roleNames = new HashSet<>(roles.size());
for (Role role : roles) {
roleNames.add(role.getRole());
}
//此处把当前subject对应的所有角色信息交给shiro，调用hasRole的时候就根据这些role信息判断
authorizationInfo.setRoles(roleNames);

List<Permission> permissions = userService.findPermissions(Integer.valueOf(uid));
Set<String> permissionNames = new HashSet<>(permissions.size());
for (Permission permission : permissions) {
permissionNames.add(permission.getName());
}
//此处把当前subject对应的权限信息交给shiro，当调用hasPermission的时候就会根据这些信息判断
authorizationInfo.setStringPermissions(permissionNames);

return authorizationInfo;
}

//根据token获取认证信息authenticationInfo
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
		/**这里为什么是String类型呢？其实要根据Subject.login(token)时候的token来的，你token定义成的pricipal是啥，这里get的时候就是啥。比如我
		Subject subject = SecurityUtils.getSubject();
		UsernamePasswordToken idEmail = new UsernamePasswordToken(String.valueOf(user.getId()), user.getEmail());
		try {
		idEmail.setRememberMe(true);
		subject.login(idEmail);
		}
		**/

		String uId = (String) token.getPrincipal();
		User user = userService.findUserById(uId);
		if (user == null) {
			return null;
		}
		//SimpleAuthenticationInfo还有其他构造方法，比如密码加密算法等，感兴趣可以自己看
		SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
		uId,      //表示凭证，可以随便设，跟token里的一致就行
		user.getEmail(),             //表示密钥如密码，你可以自己随便设，跟token里的一致就行
		getName()
		);

		//authenticationInfo信息交个shiro，调用login的时候会自动比较这里的token和authenticationInfo
		return authenticationInfo;
	}

}

在这个方法中主要是使用类：SimpleAuthorizationInfo进行角色的添加和权限的添加

authorizationInfo.addRole(role.getRole());
authorizationInfo.addStringPermission(p.getPermission());

当然也可以添加集合：

authorizationInfo.setRoles(roles);
authorizationInfo.setStringPermissions(stringPermissions);

（5）配置shiro
对shiro进行一些配置，如登陆路径、权限验证、密码匹配等等.

@Configuration
public class ShiroConfig {
	@Bean
	public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
        //shiroFilterFactoryBean对象
		ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        // 配置shiro安全管理器 SecurityManager
		shiroFilterFactoryBean.setSecurityManager(securityManager);
        // 指定要求登录时的链接
	   	shiroFilterFactoryBean.setLoginUrl("/login");
      	// 登录成功后要跳转的链接
         //shiroFilterFactoryBean.setSuccessUrl("/index");
		// 未授权时跳转的界面;
         //shiroFilterFactoryBean.setUnauthorizedUrl("/403");
		//配置拦截器.
		Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
		//配置退出 过滤器,其中的具体的退出代码Shiro已经替我们实现了
		filterChainDefinitionMap.put("/logout", "anon");
		filterChainDefinitionMap.put("/afterlogout", "anon");
		//<!-- 过滤链定义，从上向下顺序执行，一般将/**放在最为下边 -->:这是一个坑呢，一不小心代码就不好使了;
		//<!-- authc:所有url都必须认证通过才可以访问; anon:所有url都都可以匿名访问-->
		filterChainDefinitionMap.put("/static/**", "anon");
         //filterChainDefinitionMap.put("/templates/**", "anon");
        //filterChainDefinitionMap.put("/html/**","anon");
		filterChainDefinitionMap.put("/afterlogin", "anon");
		//add操作，该用户必须有【addOperation】权限
		//filterChainDefinitionMap.put("/add", "perms[addOperation]");
		filterChainDefinitionMap.put("/**", "authc");

		shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        //logger.debug("Shiro拦截器工厂类注入成功");
		return shiroFilterFactoryBean;
}


@Bean
public Realm myShiroRealm() {
	UserRealm myShiroRealm = new UserRealm();
	return myShiroRealm;
}

    
        /**
    * ehcache缓存管理器；shiro整合ehcache：
    * 通过安全管理器：securityManager
    * @return EhCacheManager
    */
@Bean public EhCacheManager ehCacheManager() {
	logger.debug("=====shiro整合ehcache缓存：ShiroConfiguration.getEhCacheManager()");
	EhCacheManager cacheManager = new EhCacheManager();
	cacheManager.setCacheManagerConfigFile("classpath:config/ehcache.xml");
	return cacheManager;
}


    /**
         * shiro安全管理器设置realm认证
         * @return
        */
@Bean
public SecurityManager securityManager() {
	DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
	// 设置realm.
	securityManager.setRealm(myShiroRealm());
	//注入ehcache缓存管理器;
	//securityManager.setCacheManager(ehCacheManager());
	 //注入Cookie记住我管理器
	//securityManager.setRememberMeManager(rememberMeManager());
	return securityManager;
}

@Bean(name="lifecycleBeanPostProcessor")
	public static LifecycleBeanPostProcessor getLifecycleBeanPostProcessor() {
	return new LifecycleBeanPostProcessor();
}

/**
* 开启Shiro的注解(如@RequiresRoles,@RequiresPermissions),需借助SpringAOP扫描使用Shiro注解的类,并在必要时进行安全逻辑验证
* 配置以下两个bean(DefaultAdvisorAutoProxyCreator(可选)和AuthorizationAttributeSourceAdvisor)即可实现此功能
* @return
*/
@Bean
@DependsOn({"lifecycleBeanPostProcessor"})
public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator() {
	DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
	advisorAutoProxyCreator.setProxyTargetClass(true);
	return advisorAutoProxyCreator;
}

@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor() {
	AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
	authorizationAttributeSourceAdvisor.setSecurityManager(securityManager());
	return authorizationAttributeSourceAdvisor;
}

    /**
    * 如下两个方法设置了记住我cookie过期时间,如果不需要则不需要注入如下2个方法
    **/
@Bean
public SimpleCookie remeberMeCookie(){
	logger.debug("记住我，设置cookie过期时间！");
	//cookie名称;对应前端的checkbox的name = rememberMe
	SimpleCookie scookie=new SimpleCookie("rememberMe");
	//记住我cookie生效时间1小时 ,单位秒 [1小时]
	scookie.setMaxAge(3600);
	return scookie;
}
// 配置cookie记住我管理器
@Bean
public CookieRememberMeManager rememberMeManager(){
	logger.debug("配置cookie记住我管理器！");
	CookieRememberMeManager cookieRememberMeManager=new CookieRememberMeManager();
	cookieRememberMeManager.setCookie(remeberMeCookie());
	return cookieRememberMeManager;
}
    
}

说明：
Filter Chain定义说明：
1、一个URL可以配置多个Filter，使用逗号分隔；
2、当设置多个过滤器时，全部验证通过，才视为通过；
3、部分过滤器可指定参数，如perms，roles
Shiro内置的FilterChain：

anon
org.apache.shiro.web.filter.authc.AnonymousFilter
authc
org.apache.shiro.web.filter.authc.FormAuthenticationFilter
authcBasic
org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter
perms
org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter
port
org.apache.shiro.web.filter.authz.PortFilter
rest
org.apache.shiro.web.filter.authz.HttpMethodPermissionFilter
roles
org.apache.shiro.web.filter.authz.RolesAuthorizationFilter
ssl
org.apache.shiro.web.filter.authz.SslFilter
user
org.apache.shiro.web.filter.authc.UserFilter

anon : 所有url都都可以匿名访问
authc : 需要认证才能进行访问
user : 配置记住我或认证通过可以访问
ShiroFilterFactoryBean处理拦截问题的时候需要注入SecurityManager，否则报错

如果shiro使用ehcache缓存（可以不用），那么则必须引入对应jar包

    <!--shiro添加ehcache缓存 -->
    <dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-ehcache</artifactId>
<version>1.2.6</version>
    </dependency>
    <!--
包含支持UI模版（Velocity，FreeMarker，JasperReports），
邮件服务，
脚本服务(JRuby)，
缓存Cache（EHCache），
任务计划Scheduling（uartz）。
    -->
    <dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
</dependency>

引入ehcache.xml配置文件

<ehcache>
	<diskStore path="java.io.tmpdir"/>
	<defaultCache
		maxElementsInMemory="10000"
		timeToIdleSeconds="120"
		timeToLiveSeconds="120"
		maxElementsOnDisk="10000000"
		diskExpiryThreadIntervalSeconds="120"
		memoryStoreEvictionPolicy="LRU">
	</defaultCache>
	<!-- 设定缓存的默认数据过期策略 -->
	<cache name="shiro"
		maxElementsInMemory="10000"
		timeToIdleSeconds="120"
		timeToLiveSeconds="120"
		maxElementsOnDisk="10000000"
		diskExpiryThreadIntervalSeconds="120"
		memoryStoreEvictionPolicy="LRU">
	</cache>
</ehcache>

如果添加“记住我”功能，那么登录方法更改为

//新增rememberMe参数@RequestParam(value="rememberMe",required = false)boolean rememberMe
... ...
// 1、 封装用户名、密码、是否记住我到token令牌对象 [支持记住我]
AuthenticationToken token = new UsernamePasswordToken(
user.getMobile(), DigestUtils.md5Hex(user.getPassword()),rememberMe);

（6）登录以及权限校验
完成以上配置就可以正常写登录登出接口，以及权限验证接口了。我这里边是利用了类似于openid的统一登录认证接口，然后写了几个登录接口。注意这里的Session，一定要用SecurityUtils.getSubject.getSession，不然会有坑。

  • 对于需要验证权限的接口，比如要求角色直接在接口上加
    @RequiresRoles(“admin”)，@RequiresPermission（“xxx”）就可以了，注解里还有稍微高阶点的用法，自己Ctrl点进去看源码就行。
  • @RequireRoles有个坑，就是shiroFilter里配置的无权跳转路径是不跳转的，因为ajax获取与url直接获取是有区别的，我这边用的ajax获取。所以写一个统一的异常处理接口捕获无权异常就可以了。
@RestControllerpublic class LoginController {
	@Autowired
	private LoginService loginService;

@RequestMapping("/login")
public void login(HttpServletResponse response) {
	response.setStatus(302);
	try {
		response.sendRedirect(OPSConstants.OPS_URL_WITH_RETURN);
	} catch (IOException e) {
	
	}
}

@RequestMapping("/afterlogin")
public void recTicket(String ticket, HttpServletRequest request, HttpServletResponse response) {
	Map<String, String> paramMap = new HashMap<>(1);
	paramMap.put("ticket", ticket);
	
	String result = HttpHandler.getInstance().usingGetMethod(OPSConstants.OPS_URL_WITH_TICKET, paramMap, null);
	User user = JSON.parseObject(result, User.class);
	loginService.registerOrLogin(user);
	
	HttpSession session = request.getSession();
	session.setMaxInactiveInterval(1000 * 60 * 60);
	session.setAttribute(session.getId(), user);
	try {
		response.sendRedirect("/html/index.html");
	} catch (IOException e) {
	
	}
}

@RequestMapping(value = "/logout")
public void logout(HttpServletRequest request, HttpServletResponse response) {
	HttpSession session = request.getSession();
	User user = (User) session.getAttribute(session.getId());
	String pticket = user.getPticket();
	String url = OPSConstants.OPS_URL_LOGOUT + "&pticket=" + pticket;
	response.setStatus(302);
	try {
		response.sendRedirect(url);
	} catch (IOException e) {
	
	}
}

@RequestMapping(value = "/afterlogout")
public void afterLogout(HttpServletResponse response) {
	//这里一定要使用shiro退出方式，否则session失效
	SecurityUtils.getSubject().logout();
	try {
		response.sendRedirect(OPSConstants.OPS_URL_WITH_RETURN);
	} catch (IOException e) {
	
	}
}

}

无权处理：

@ControllerAdvice
public class GlobalExceptionHandler {

@ExceptionHandler(value = UnauthorizedException.class)
@ResponseBody
public ResponseBO jsonExceptionHandler(HttpServletRequest req, Exception e) {
	return new ResponseBO(403, "权限不足！");
}
// @ExceptionHandler(value = UnauthorizedException.class)
	// public ModelAndView businessExceptionHandler(){
	// ModelAndView mav = new ModelAndView();
	// mav.setStatus(HttpStatus.UNAUTHORIZED);
	// mav.addObject("message", e.getMessage());
	// mav.setViewName("403");
	// return mav;
	// }
}

（7）认证流程
在这里插入图片描述
1、 创建token令牌，token中有用户提交的认证信息即账号和密码
2、 执行subject.login(token)，最终由securityManager通过Authenticator进行认证
3、 Authenticator的实现ModularRealmAuthenticator调用realm从ini配置文件取用户真实的账号和密码，这里使用的是IniRealm（shiro自带）
4、 IniRealm先根据token中的账号去ini中找该账号，如果找不到则给ModularRealmAuthenticator返回null，如果找到则匹配密码，匹配密码成功则认证通过。
在这里插入图片描述
（8）常见异常
UnknownAccountException
账号不存在异常如下：
org.apache.shiro.authc.UnknownAccountException: No account found for user。。。。
IncorrectCredentialsException
当输入密码错误会抛此异常，如下：
org.apache.shiro.authc.IncorrectCredentialsException: Submitted credentials for token [org.apache.shiro.authc.UsernamePasswordToken - zhangsan, rememberMe=false] did not match the expected credentials.
更多如下：
DisabledAccountException（帐号被禁用）
LockedAccountException（帐号被锁定）
ExcessiveAttemptsException（登录失败次数过多）
ExpiredCredentialsException（凭证过期）

（4）自定义Realm
Shiro自带的IniRealm从ini配置文件中读取用户的信息，大部分情况下需要从系统的数据库中读取用户信息，所以需要自定义realm。shiro自带的real如下
在这里插入图片描述
最基础的是Realm接口，CachingRealm负责缓存处理，AuthenticationRealm负责认证，AuthorizingRealm负责授权，通常自定义的realm继承AuthorizingRealm。

自定义realm
在这里插入图片描述
在这里插入图片描述

9、 散列算法

散列算法一般用于生成一段文本的摘要信息，散列算法不可逆，将内容可以生成摘要，无法将摘要转成原始内容。散列算法常用于对密码进行散列，常用的散列算法有MD5、SHA。
一般散列算法需要提供一个salt（盐）与原始内容生成摘要信息，这样做的目的是为了安全性，比如：111111的md5值是：96e79218965eb72c92a549dd5a330112，拿着“96e79218965eb72c92a549dd5a330112”去md5破解网站很容易进行破解，如果要是对111111和salt（盐，一个随机数）进行散列，这样虽然密码都是111111加不同的盐会生成不同的散列值。
在这里插入图片描述
在自定义realm中的使用
在这里插入图片描述

10、授权方式

Shiro 支持三种方式的授权：
（1）编程式：通过写if/else 授权代码块完成

Subject subject = SecurityUtils.getSubject();
if(subject.hasRole(“admin”)) {
    //有权限
} else {
    //无权限
}

（2）注解式：通过在执行的Java方法上放置相应的注解完成：

@RequiresRoles("admin")
public void hello() {
    //有权限
}

（3）JSP/GSP 标签：在JSP/GSP 页面通过相应的标签完成：

<shiro:hasRole name="admin">
    <!— 有权限—>
</shiro:hasRole>

11、Shiro总结

核心

ShiroFilterFactory
Shiro过滤器工厂类，具体的实现类：：ShiroFilterFactoryBean，此实现类是依赖于SecurityManager安全管理器。

sercurityManager
shiro的安全管理，主要是身份认证的管理，缓存管理，cookie管理，ShiroFilterFactory主要配置好了Filter就可以了。当然SecurityManager并进行身份认证缓存的实现，我们需要进行对应的编码然后进行注入到安全管理器中。

Realm
用于身份信息权限信息的验证。
其它

如缓存管理，记住登录之类的，这些大部分都是需要自己进行简单的实现，然后注入到SecurityManager让Shiro的安全管理器进行管理就好了。

集成步骤
1.pom.xml需要加依赖
2.注入 shiro Factory 和SecuirtyManager
3.身份认证
4.权限控制

重要说明
身份认证基本完成了可以在homeController哪里加上login/post处理
在这里插入图片描述
更改加密算法和加密层次
在这里插入图片描述
参考文章：

https://blog.csdn.net/qq_39455116/article/details/83654629
https://blog.csdn.net/clj198606061111/article/details/82948757
https://www.cnblogs.com/slivelove/p/9922666.html

快来成为我的朋友或合作伙伴，一起交流，一起进步！：
QQ群：961179337
微信：lixiang6153
邮箱：lixx2048@163.com
公众号：IT技术快餐

贝壳里的沙
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
117.Shiro（二）：SpringBoot整合Shiro（1）：搭建环境环境，并完成认证模块
鹏哥哥Aaa
06-03 148
SpringBoot整合Shiro（1）：搭建环境环境，并完成认证模块
Shiro 身份验证、授权、密码和会话管理
05-07
使用Java安全框架,执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序
Shiro身份认证和权限管理（授权）
nanZhaiXiaoLang的博客
09-27 960
1. Shiro的身份认证流程信息： 后台接受凭证信息（密码）和身份信息（用户名）封装到Subject主体中，调用Subject自己的登陆方法，完成校验。底层校验代码是实现AuthenticatingRealm 类重写doGetAuthentica方法，根据传过来的值来 查询数据库完成用户认证。 2. Shiro的用户授权流程信息： 先认证过以后，根据认证信息查询用户的权限级别，...
Shiro权限框架认证和授权原理介绍
m0_67393827的博客
04-07 922
1、简介 shiro是一个安全框架，是Apache的一个子项目。shiro提供了：认证、授权、加密、会话管理、与web集成、缓存等模块。 1.1、模块介绍 Authentication:用户身份识别，可以认为是登录； Authorization:授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限。 Session Manager：会话管理，即用户登录后就是一次会话，在没有退出之前，它的
Shiro 权限管理入门之认证与授权
萌宅鹿的技术小屋
07-05 590
Shiro权限管理什么是权限管理？什么是身份认证？什么是授权？ShiroShiro 的核心架构3.2 SecurityManager3.3 Authenticator3.4 Authorizer3.5 Realm3.6 SessionManager3.7 SessionDAO3.8 CacheManager3.9 Cryptography 权限管理 什么是权限管理？ 基本上涉及到用户参与的系统都要进行权限管理，权限管理属于系统安全的范畴，权限管理实现 对用户访问系统的控制，按照 安全规则 或者 安全策略 控
springboot与shiro整合—登录认证和权限管理实例项目
04-16
亲测可用的，springboot与shiro整合—登录认证和权限管理实例项目，对于学习理论之后需要实战实现功能的初级程序员很有用！
spring boot+shiro 权限认证管理案例
12-20
spring boot+shiro 权限认证管理案例 shiro搭配缓存处理
Shiro权限管理框架详解
02-24
权限管理包括用户身份认证和授权两部分，简称认证授权。对于需要访问控制的资源用户首先经过身份认证，认证通过后用户具有该资源的访问权限方可访问。1.2.1概念身份认证，就是判断一个用户是否为合法用户的处理过程...
shiro登陆身份认证和权限管理 密码加密
01-23
shiro登陆，shiro登陆身份认证和权限管理 密码加密。自己写的demo。实用。希望大家多多支持。谢谢大家
41、nacos单机以及集群配置
lixiang987654321的专栏
09-07 6828
nacos单机以及集群配置安装准备一、前言二、单机模式（standalone）三、集群搭建（cluster）四、添加配置文件五、添加配置文件 安装准备 1、下载库 从Github 上拉取Nacos Github最新版（地址：https://github.com/alibaba/nacos）。 2、本地解压 tar -zxvf nacos-server-1.1.3.tar.gz 解压后目录说明如下...
17、kafka分区选主机制
lixiang987654321的专栏
08-16 4046
kafka分区选主机制1、大数据常用的选主机制2、常用选主机制的缺点3、kafka分区的选主机制 1、大数据常用的选主机制 leader的选择方法非常多，大数据领域常用的的选举方法有如下集中 （1）Zab（zookeeper使用） a、快速leader选举（leader election） b、发现或者版本建立（epoch establish） c、同步（follower从leader同步数据和状...
44、nacos服务注册以及发现示例
lixiang987654321的专栏
09-07 3607
44、nacos服务注册以及发现示例一、创建服务提供者项目-nacos-producer二、添加服务消费者项目-nacos-consumer 注意，我在测试过程中发现问题 （1）如果使用SpringCloud2.0.4.RELEASE版本无法使用nacos （2）如果使用open-feign的2.1.0版本远程过程调用失败，如果使用2.0.0版本发现可以远程调用，但是nacos注册失效（也就是本...
45、nacos集成openfeign
lixiang987654321的专栏
09-07 3121
nacos集成openfeign一、创建服务提供者项目-nacos-producer二、添加服务消费者项目-nacos-openfeign SpringCloud中使用feign（底层使用Ribbon）实现调用远程方法像调用本地方法一样去使用，如果使用nacos，那么对应就是使用openfeign即可实现。具体实现过程如下，仅供参考！ 一、创建服务提供者项目-nacos-producer 1、修改...
Java在Windows下使用Hbase操作Hadoop示例
lixiang987654321的专栏
06-21 2102
（1）解决jar包依赖问题，可以使用两种方式1、直接创建maven工程，编写pom文件，添加依赖的jar包声明2、直接下载对应的hbase的linux压缩包，解压后拷贝文件夹lib下的所有jar包注意：在运行过程中会报错：java.lang.NoClassDefFoundError: org/hamcrest/SelfDescribing，因为缺少了hadoop的jar包），可以从解压ha...
36、关于资源服务鉴权流程
lixiang987654321的专栏
03-15 1448
使用springcloud框架时，最常用的鉴权流程框架是spring Security和OAuth2，OAuth2是SpringSecurity的扩展版；OAuth2.0有两种方式： 1、授权服务与资源服务属于同一进程（同一服务） 2、资源服务与授权服务分离（不属于同一进程） 对于第一种情况，我们很好区分，访问对应资源和授权数据同一进程，无需在配置文件中进行任何配置，但对于第二...
49、实现shiro无状态访问（自定义token）
lixiang987654321的专栏
09-07 1259
前言 http协议是无状态协议。浏览器访问服务器时，要让服务器知道你是谁，只有两种方式： 方式一：把“你是谁”写入cookie。它会随每次HTTP请求带到服务端； 方式二：在URL、表单数据中带上你的用户信息（也可能在HTTP头部）。这种方式依赖于从特定的网页入口进入，因为只有走特定的入口，才有机会拼装出相应的信息，提交到服务端。 大部分SSO需求都希望不依赖特定的网页入口（集成门户除外），所...
18、kafka的Reactor设计模型
lixiang987654321的专栏
08-16 1059
kafka的Reactor设计模型（2）认识Linux的epoll模型（3）kafka Server Reactor模型 kafka作为一种高性能、高并发的消息中间件，必须要求大量的客户端连接、必须做到高并发，kafka使用了久经检验的Reactor模型。在了解之前，首先了解一下如下几个概念（Reactor模型是基于Java NIO的，是linux的epoll模型的改造）： #（1）认识Java ...
11、HDFS编程案例
lixiang987654321的专栏
12-21 964
一、Windows环境配置 1、准备好hadoop的完全分布式按照，具体按照步骤这里不再赘述 此处我的版本为hadoop2.7.6版本，环境配置为Hadoop的完全分布式按照，各个节点具体安排如下 1）机器地址映射关系 192.168.8.240 hadoop01 192.168.8.241 hadoop02 192.168.8.242 hadoop03 2）机器节点安排 ...
如何shiro框架进行认证和授权
最新发布
07-11
Shiro框架是一个功能强大的Java安全框架，可以用于认证和授权。下面是使用Shiro进行认证和授权的基本步骤： 1. 添加Shiro依赖：在你的项目中添加Shiro的相关依赖，可以通过Maven或者Gradle进行引入。 2. 配置Shiro...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

贝壳里的沙

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值