shiro授权SSM

于 2022-08-26 20:48:26 发布
阅读量54 收藏
点赞数
文章标签： java spring 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63544775/article/details/126549985
版权

目录

一、shiro授权角色、权限

UserMapper.java

UserMapper.xml

userbiz 

applicationContext-shiro.xml

二、Shiro的注解式开发

springmvc-servlet.xml

 ShiroController

 

一、shiro授权角色、权限

 

1、UserMapper.java

package com.zlp.ssm.mapper;

import com.zlp.ssm.model.User;
import org.springframework.stereotype.Repository;

import java.util.Set;

@Repository
public interface UserMapper {
    int deleteByPrimaryKey(Integer userid);

    int insert(User record);

    int insertSelective(User record);

    User selectByPrimaryKey(Integer userid);

    User queryByName(String userName);

    int updateByPrimaryKeySelective(User record);

    int updateByPrimaryKey(User record);

    Set<String> getRolesByUserId(String userName);

    Set<String> getPersByUserId(String userName);
}

2、UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.zlp.ssm.mapper.UserMapper" >
  <resultMap id="BaseResultMap" type="com.zlp.ssm.model.User" >
    <constructor >
      <idArg column="userid" jdbcType="INTEGER" javaType="java.lang.Integer" />
      <arg column="username" jdbcType="VARCHAR" javaType="java.lang.String" />
      <arg column="password" jdbcType="VARCHAR" javaType="java.lang.String" />
      <arg column="salt" jdbcType="VARCHAR" javaType="java.lang.String" />
      <arg column="createdate" jdbcType="TIMESTAMP" javaType="java.util.Date" />
    </constructor>
  </resultMap>
  <sql id="Base_Column_List" >
    userid, username, password, salt, createdate
  </sql>
  <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Integer" >
    select 
    <include refid="Base_Column_List" />
    from t_shiro_user
    where userid = #{userid,jdbcType=INTEGER}
  </select>
  <select id="queryByName" resultType="com.zlp.ssm.model.User" parameterType="java.lang.String">
    select
    <include refid="Base_Column_List" />
    from t_shiro_user
    where userName = #{userName}
  </select>

  <select id="getRolesByUserId" resultType="java.lang.String" parameterType="java.lang.String">
  select ur.roleid from t_shiro_user u,t_shiro_user_role ur,t_shiro_role r
    where u.userid = ur.userid and ur.roleid = r.roleid
    and u.username = #{username}
  </select>
  <select id="getPersByUserId" resultType="java.lang.String" parameterType="java.lang.String">
  select rp.perid from t_shiro_user u,t_shiro_user_role ur,t_shiro_role_permission rp,t_shiro_permission p
  where u.userid = ur.userid and ur.roleid = rp.roleid and rp.perid = p.perid
  and u.username = #{username}
  </select>


  <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer" >
    delete from t_shiro_user
    where userid = #{userid,jdbcType=INTEGER}
  </delete>
  <insert id="insert" parameterType="com.zlp.ssm.model.User" >
    insert into t_shiro_user (userid, username, password, 
      salt, createdate)
    values (#{userid,jdbcType=INTEGER}, #{username,jdbcType=VARCHAR}, #{password,jdbcType=VARCHAR}, 
      #{salt,jdbcType=VARCHAR}, #{createdate,jdbcType=TIMESTAMP})
  </insert>
  <insert id="insertSelective" parameterType="com.zlp.ssm.model.User" >
    insert into t_shiro_user
    <trim prefix="(" suffix=")" suffixOverrides="," >
      <if test="userid != null" >
        userid,
      </if>
      <if test="username != null" >
        username,
      </if>
      <if test="password != null" >
        password,
      </if>
      <if test="salt != null" >
        salt,
      </if>
      <if test="createdate != null" >
        createdate,
      </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides="," >
      <if test="userid != null" >
        #{userid,jdbcType=INTEGER},
      </if>
      <if test="username != null" >
        #{username,jdbcType=VARCHAR},
      </if>
      <if test="password != null" >
        #{password,jdbcType=VARCHAR},
      </if>
      <if test="salt != null" >
        #{salt,jdbcType=VARCHAR},
      </if>
      <if test="createdate != null" >
        #{createdate,jdbcType=TIMESTAMP},
      </if>
    </trim>
  </insert>
  <update id="updateByPrimaryKeySelective" parameterType="com.zlp.ssm.model.User" >
    update t_shiro_user
    <set >
      <if test="username != null" >
        username = #{username,jdbcType=VARCHAR},
      </if>
      <if test="password != null" >
        password = #{password,jdbcType=VARCHAR},
      </if>
      <if test="salt != null" >
        salt = #{salt,jdbcType=VARCHAR},
      </if>
      <if test="createdate != null" >
        createdate = #{createdate,jdbcType=TIMESTAMP},
      </if>
    </set>
    where userid = #{userid,jdbcType=INTEGER}
  </update>
  <update id="updateByPrimaryKey" parameterType="com.zlp.ssm.model.User" >
    update t_shiro_user
    set username = #{username,jdbcType=VARCHAR},
      password = #{password,jdbcType=VARCHAR},
      salt = #{salt,jdbcType=VARCHAR},
      createdate = #{createdate,jdbcType=TIMESTAMP}
    where userid = #{userid,jdbcType=INTEGER}
  </update>
</mapper>

userbiz 

package com.zlp.ssm.biz;

import com.zlp.ssm.model.User;

import java.util.Set;


public interface UserBiz {
    int deleteByPrimaryKey(Integer userid);

    int insert(User record);

    int insertSelective(User record);

    User selectByPrimaryKey(Integer userid);

    User queryByName(String userName);

    int updateByPrimaryKeySelective(User record);

    int updateByPrimaryKey(User record);

    Set<String> getRolesByUserId(String userName);

    Set<String> getPersByUserId(String userName);

}

UserBizImpl  

package com.zlp.ssm.biz.impl;

import com.zlp.ssm.biz.UserBiz;
import com.zlp.ssm.mapper.UserMapper;
import com.zlp.ssm.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Set;

/**
 * @author zlp
 * @create 2022-08-25 19:10
 */
@Service("UserService")
public class UserBizImpl implements UserBiz {
    @Autowired
    private UserMapper userMapper;

    @Override
    public int deleteByPrimaryKey(Integer userid) {
        return userMapper.deleteByPrimaryKey(userid);
    }

    @Override
    public int insert(User record) {
        return userMapper.insert(record);
    }

    @Override
    public int insertSelective(User record) {
        return userMapper.insertSelective(record);
    }

    @Override
    public User selectByPrimaryKey(Integer userid) {
        return userMapper.selectByPrimaryKey(userid);
    }

    @Override
    public User queryByName(String userName) {
        return userMapper.queryByName(userName);
    }

    @Override
    public int updateByPrimaryKeySelective(User record) {
        return userMapper.updateByPrimaryKeySelective(record);
    }

    @Override
    public int updateByPrimaryKey(User record) {
        return userMapper.updateByPrimaryKey(record);
    }

    @Override
    public Set<String> getRolesByUserId(String userName) {
        return userMapper.getRolesByUserId(userName);
    }

    @Override
    public Set<String> getPersByUserId(String userName) {
        return userMapper.getPersByUserId(userName);
    }
}

5、applicationContext-shiro.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--配置自定义的Realm-->
    <bean id="shiroRealm" class="com.zlp.ssm.shiro.Myrealm">
        <property name="userBiz" ref="UserService" />
        <!--注意：重要的事情说三次~~~~~~此处加密方式要与用户注册时的算法一致 -->
        <!--注意：重要的事情说三次~~~~~~此处加密方式要与用户注册时的算法一致 -->
        <!--注意：重要的事情说三次~~~~~~此处加密方式要与用户注册时的算法一致 -->
        <!--以下三个配置告诉shiro将如何对用户传来的明文密码进行加密-->
        <property name="credentialsMatcher">
            <bean id="credentialsMatcher" class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
                <!--指定hash算法为MD5-->
                <property name="hashAlgorithmName" value="md5"/>
                <!--指定散列次数为1024次-->
                <property name="hashIterations" value="1024"/>
                <!--true指定Hash散列值使用Hex加密存. false表明hash散列值用用Base64-encoded存储-->
                <property name="storedCredentialsHexEncoded" value="true"/>
            </bean>
        </property>
    </bean>

    <!--注册安全管理器-->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="realm" ref="shiroRealm" />
    </bean>

    <!--Shiro核心过滤器-->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <!-- Shiro的核心安全接口,这个属性是必须的 -->
        <property name="securityManager" ref="securityManager" />
        <!-- 身份验证失败，跳转到登录页面 -->
        <property name="loginUrl" value="/login"/>
        <!-- 身份验证成功，跳转到指定页面 -->
        <!--<property name="successUrl" value="/index.jsp"/>-->
        <!-- 权限验证失败，跳转到指定页面 -->
        <property name="unauthorizedUrl" value="/unauthorized.jsp"/>
        <!-- Shiro连接约束配置,即过滤链的定义 -->
        <property name="filterChainDefinitions">
            <value>
                <!--
                注：anon，authcBasic，auchc，user是认证过滤器
                    perms，roles，ssl，rest，port是授权过滤器
                -->
                <!--anon 表示匿名访问，不需要认证以及授权-->
                <!--authc表示需要认证 没有进行身份认证是不能进行访问的-->
                <!--roles[admin]表示角色认证，必须是拥有admin角色的用户才行-->
                /user/login=anon
                /user/updatePwd.jsp=authc
                /admin/*.jsp=roles[4]
                /user/teacher.jsp=perms[2]
                <!-- /css/**               = anon
                 /images/**            = anon
                 /js/**                = anon
                 /                     = anon
                 /user/logout          = logout
                 /user/**              = anon
                 /userInfo/**          = authc
                 /dict/**              = authc
                 /console/**           = roles[admin]
                 /**                   = anon-->
            </value>
        </property>
    </bean>

    <!-- Shiro生命周期，保证实现了Shiro内部lifecycle函数的bean执行 -->
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>
</beans>



package com.zlp.ssm.shiro;

import com.zlp.ssm.biz.UserBiz;
import com.zlp.ssm.model.User;
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.apache.shiro.util.ByteSource;

import java.util.Set;

/**
 * @author zlp
 * @create 2022-08-25 19:24
 */
public class Myrealm extends AuthorizingRealm {
    private UserBiz userBiz;

    public UserBiz getUserBiz() {
        return userBiz;
    }

    public void setUserBiz(UserBiz userBiz) {
        this.userBiz = userBiz;
    }

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        System.out.println("用户授权...");
        String username = principals.getPrimaryPrincipal().toString();
        User user = userBiz.queryByName(username);
        Set<String> roles = userBiz.getRolesByUserId(user.getUsername());
        Set<String> pers = userBiz.getPersByUserId(user.getUsername());
        SimpleAuthorizationInfo info=new SimpleAuthorizationInfo();
        info.setRoles(roles);
        info.setStringPermissions(pers);
        return info;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        System.out.println("身份验证...");
        String username = token.getPrincipal().toString();
        String password = token.getCredentials().toString();
        User user = userBiz.queryByName(username);
        AuthenticationInfo info=new SimpleAuthenticationInfo(
                user.getUsername(),
                user.getPassword(),
                ByteSource.Util.bytes(user.getSalt()),
                this.getName()
        );
        return info;
    }
}

运行结果 

 

二、Shiro的注解式开发

1、springmvc-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 通过context:component-scan元素扫描指定包下的控制器-->
    <!--1) 扫描com.javaxl.zf及子子孙孙包下的控制器(扫描范围过大，耗时)-->
    <aop:aspectj-autoproxy/>
    <context:component-scan base-package="com.zlp.ssm"/>

    <!--2) 此标签默认注册DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter -->
    <!--两个bean，这两个bean是spring MVC为@Controllers分发请求所必须的。并提供了数据绑定支持，-->
    <!--@NumberFormatannotation支持，@DateTimeFormat支持，@Valid支持，读写XML的支持（JAXB），读写JSON的支持（Jackson）-->
    <mvc:annotation-driven></mvc:annotation-driven>

    <!--3) ViewResolver -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- viewClass需要在pom中引入两个包：standard.jar and jstl.jar -->
        <property name="viewClass"
                  value="org.springframework.web.servlet.view.JstlView"></property>
        <property name="prefix" value="/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--4) 单独处理图片、样式、js等资源 -->
    <!--<mvc:resources location="/css/" mapping="/css/**"/>-->
    <!--<mvc:resources location="/images/" mapping="/images/**"/>-->
    <!--<mvc:resources location="/js/" mapping="/js/**"/>-->
    <mvc:resources location="/static/" mapping="/js/**"/>

    <!--文件上传：多功能解析器-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 必须和用户JSP 的pageEncoding属性一致，以便正确解析表单的内容 -->
        <property name="defaultEncoding" value="UTF-8"></property>
        <!-- 文件最大大小(字节) 1024*1024*50=50M-->
        <property name="maxUploadSize" value="52428800"></property>
        <!--resolveLazily属性启用是为了推迟文件解析，以便捕获文件大小异常-->
        <property name="resolveLazily" value="true"/>
    </bean>

    <!--配置拦截器-->
    <!--<mvc:interceptors>
        &lt;!&ndash;针对于所有的请求进行拦截&ndash;&gt;
        <bean class="com.zlp.ssm.intercept.OneHandlerInterceptor"></bean>
    </mvc:interceptors>-->
    <!--配置拦截器链-->
   <!-- <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.zlp.ssm.intercept.OneHandlerInterceptor"></bean>
        </mvc:interceptor>
        <mvc:interceptor>
            <mvc:mapping path="/clz/**"/>
            <bean class="com.zlp.ssm.intercept.TwoHandlerInterceptor"></bean>
        </mvc:interceptor>
    </mvc:interceptors>-->

    <!--支持json数据返回的适配器-->
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="messageConverters">
            <list>
                <ref bean="mappingJackson2HttpMessageConverter"/>
            </list>
        </property>
    </bean>
    <bean id="mappingJackson2HttpMessageConverter"
          class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
       <!-- 处理中文乱码以及避免IE执行AJAX时，返回JSON出现下载文件-->
        <property name="supportedMediaTypes">
            <list>
                <value>text/html;charset=UTF-8</value>
                <value>text/json;charset=UTF-8</value>
                <value>application/json;charset=UTF-8</value>
            </list>
        </property>
    </bean>

    <!--统一异常处理-->
    <!-- springmvc提供的简单异常处理器 -->
    <!--<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        &lt;!&ndash; 定义默认的异常处理页面 &ndash;&gt;
        <property name="defaultErrorView" value="error"/>
        &lt;!&ndash; 定义异常处理页面用来获取异常信息的变量名，也可不定义，默认名为exception &ndash;&gt;
        <property name="exceptionAttribute" value="ex"/>
        &lt;!&ndash; 定义需要特殊处理的异常，这是重要点 &ndash;&gt;
        <property name="exceptionMappings">
            <props>
                <prop key="java.lang.RuntimeException">error</prop>
            </props>
            &lt;!&ndash; 还可以定义其他的自定义异常 &ndash;&gt;
        </property>
    </bean>-->

    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
          depends-on="lifecycleBeanPostProcessor">
        <property name="proxyTargetClass" value="true"></property>
    </bean>
    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
        <property name="securityManager" ref="securityManager"/>
    </bean>

    <bean id="exceptionResolver" class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        <property name="exceptionMappings">
            <props>
                <prop key="org.apache.shiro.authz.UnauthorizedException">
                    unauthorized
                </prop>
            </props>
        </property>
        <property name="defaultErrorView" value="unauthorized"/>
    </bean>


</beans>

 ShiroController

package com.zlp.ssm.web;

import org.apache.shiro.authz.annotation.Logical;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.apache.shiro.authz.annotation.RequiresUser;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;

/**
 * @author zlp
 * @create 2022-08-26 19:33
 */
@RequestMapping("/shiro")
@Controller
public class ShiroController {

    @RequiresUser
    @RequestMapping("/passUser")
    public String passUser(HttpServletRequest request){
        System.out.println("身份认证通过..");
        return "admin/addUser";
    }

    @RequiresRoles(value = {"1","4"},logical = Logical.AND)
    @RequestMapping("/passRole")
    public String passRole(HttpServletRequest request){
        System.out.println("角色认证通过..");
        return "admin/addUser";
    }

    @RequiresPermissions(value = {"2"},logical = Logical.AND)
    @RequestMapping("/passPermission")
    public String permission(HttpServletRequest request){
        System.out.println("权限认证通过..");
        return "admin/addUser";
    }
}

 

 没有登录时：

 

普利斯坑坑密
关注
Shiro 安全框架入门
热心网友
08-21 260
简介 Apache Shiro 是 Java 的一个安全框架。目前，使用 Apache Shiro 的人越来越多，因为它相当简单，对比 Spring Security，可能没有 Spring Security 做的功能强大，但是在实际工作时可能并不需要那么复杂的东西，所以使用小而简单的 Shiro 就足够了。对于它俩到底哪个好，这个不必纠结，能更简单的解决项目问题就好了。 Shiro 可以非常...
Shiro授权
weixin_67677668的博客
08-26 261
Shiro授权
Shiro学习笔记（3）——授权（Authorization）
君君的专栏
05-28 1万+
什么是授权 授权三要素 Shiro的三种授权方式 1 编码方式授权 2 基于注解的授权 3 JSP标签授权1.什么是授权授权，就是访问控制，控制某个用户在应用程序中是否有权限做某件事2.授权三要素 权限 请看Shiro学习笔记（1）——shiro入门中权限部分内容角色 通常代表一组行为或职责.这些行为演化为你在一个软件应用中能或者不能做的事情。角色通常是分配给用户帐户的，因此，通过分配，用户
shiro进行权限控制的四种方式
热门推荐
力挽狂澜的POWER
08-19 4万+
我们使用shiro进行权限控制 有以下几种方式 1.  URL拦截权限控制：基于filter过滤器实现 我们在spring配置文件中配置shiroFilter时配置 &lt;!--指定URL级别拦截策略  --&gt; &lt;property name="filterChainDefinitions"&gt;  &lt;value&gt; /css/ = anon /js/ = anon /im...
shiro框架 4种授权方式 说明
weixin_33923762的博客
06-29 276
1. shiro的配置文件(applicationContext-shiro.xml)中使用filterChain过滤url的方式 详细配置看注释 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi...
shiro整合ssm的全部jar包
01-27
Apache Shiro是一个强大的Java安全框架，它为应用程序提供了身份验证、授权、会话管理和加密等功能。在Java开发中，Shiro常与Spring（SSM：Spring、SpringMVC、MyBatis）框架进行整合，以实现更高效的安全管理。本文...
Shiro与SSM整合（内含详细文档介绍）
11-06
Apache Shiro 和 Spring Security (SSM) 是两个广泛使用的Java安全框架，它们分别提供认证、授权、会话管理和加密等功能，以确保Web应用程序的安全性。本资料包将深入讲解如何将Shiro与SSM整合，以实现更高效、灵活...
SSM-Shiro.zip_shiro ssm 整合_ssm web shiro%2_ssm+shiro_ssm590.com_
09-23
7. **应用场景**：SSM-Shiro项目适用于需要权限控制的Web应用，例如企业级管理系统、电商平台、社区论坛等，确保只有授权用户才能访问特定资源。 8. **项目结构**：项目通常包含以下模块：配置文件（如Spring的...
shiro与ssm
08-16
**标题：“Shiro与SSM”** 在Java Web开发领域，Spring、Struts和MyBatis（简称SSM）是一个常见的企业级应用框架组合，而Apache Shiro则是一个强大且易用的安全管理框架。本教程将详细介绍如何在基于Maven的SSM项目...
shiro整合ssm框架
10-17
SSM（Spring、SpringMVC、MyBatis）框架是Java开发中常用的一种组合，而Apache Shiro则是一个强大且易用的Java安全框架，负责处理认证、授权、会话管理和加密等安全相关任务。本项目"shiro整合ssm框架"旨在将Shiro与...
Shiro 教程基于SSM（SpringMVC + Spring + Mybatis）EHCache版本
sojson.com站长的专栏
01-04 610
一、Shiro简介 Apache Shiro 是 Java  的一个安全框架。我们经常看到它被拿来和 Spring  的 Security  来对比。大部分人认为 Shiro  比 Security  要简单。我的观点赞成一半一半吧。 首先 Shiro  确实和 Security  是同类型的框架，主要用来做安全，也就是我们俗称的权限校验（控制）。居多人对 Shrio  的定义为好...
shiro授权管理方式详解
wonabi的博客
11-24 1035
一.概述  1.授权，又称作为访问控制，是对资源的访问管理的过程。换句话说，控制谁有权限在应用程序中做什么， 通过使用shiro的授权功能，能够完成细粒度的权限控制。 2.授权的三要素   授权有着三个核心元素：权限、角色和用户 。   我们需要在应用程序中对用户和权限建立关联，通常的做法就是将权限分配给某个角色，然后将这个角色关联一个或多个用户。 二.s
shiro登录认证和盐加密
what_to的博客
10-14 428
shiro登录认证和盐加密1、shiro认证2、盐加密 shiro登录认证和盐加密) 1、shiro认证 首先如果需要验证我们先来导入***pop.xml*** <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-core</artifactId&...
Shiro认证-SSM
web18334137065的博客
08-24 162
Shiro从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；最基础的是Realm接口，CachingRealm负责缓存处理，AuthenticationRealm负责认证，AuthorizingRealm负责授权。盐加密工具类，在做新增用户的时候使用，将加密后的密码、及加密时候的盐放入数据库；1、导入pom相关依赖。
Shiro --- shiro认证-SSM
ty0714的博客
04-18 363
重要： 在 shiro 中，用户需要提供principals （身份）和credentials（凭证）给shiro，从而应用能验证用户身份-------------------------即 帐号 / 密码 1.导入基于Shiro的数据库脚本 t_sys_user：用户信息表，例如：zs/ls/ww t_sys_role：用户角色表，例如：管理员/普通员工/部门经理/技术总监/CEO t_sys_permission：权限信...
SSM框架整合Shiro
weixin_44541136的博客
06-20 661
环境配置 1.在web.xml中配置Shiro的过滤器 与Spring集成： <filter> <filter-name>shiroFilter</filter-name> <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class> <async-supported>true</async-sup...
shiro权限
天地无名
09-30 732
一、权限框架介绍 1.什么说权限框架? 权限说简单点就是我们字面理解的意思，项目中，例如普通用户和超级管理园 权限管理包括用户身份认证和授权两部分，简称认证授权。对于需要访问控制的资源用户首先经过身份认证，认证通过后用户具有该资源的访问权限方可访问。 1.1 用户身份认证 身份认证，就是判断一个用户是否为合法用户的处理过程。最常用的简单身份认证方式是系统通过核对用户输入的用户名和口令，看其是否与系统中存储的该用户的用户名和口令一致，来判断用户身份是否正确。对于采用指纹等系统，则出示指纹；对于硬件K
Apache Shiro(二)shiro+ssm项目整合
weixin_46122805的博客
04-08 287
Shiro+SSM一、导入相关依赖 前提：创建一个mavenWeb项目，导入相关依赖 一、导入相关依赖
SSM 整合 Shiro 安全框架
m0_52462015的博客
05-24 281
SSM 整合 Shiro 安全框架 1、介绍 （1）Shiro 是什么？ Shiro 是一个功能强大和易于使用的 Java安全框架。 Shiro 为开发人员提供一个直观而全面的解决方案：认证、授权、加密、会话管理、Web集成、缓存等。 Apache Shiro 和 Spring Security 是同类型的框架，主要用来做安全方面，也就是我们俗称的权限校验（控制），Shiro 扩展更简单和灵活。 （2）Shiro 四个主要的功能 Authentication：身份认证/登录，验证用户是不是拥有相应
Spring整合Shiro（SSM）实战教程
"本文将介绍如何将Apache Shiro框架整合到Spring MVC（SSM）环境中，以实现网站的安全管理和权限控制。Shiro是一个轻量级的安全认证框架，它能处理从登录过滤到细粒度的权限控制等各种任务。下面将详细阐述整合过程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值