shiro身份认证及加密（SSM）

最新推荐文章于 2022-08-26 13:07:32 发布
最新推荐文章于 2022-08-26 13:07:32 发布
阅读量244 收藏
点赞数
分类专栏： shiro 文章标签： shiro身份认证及加密（SSM）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zhangrunhong/article/details/102551641
版权

文章目录

1、shiro盐加密、与spring整合

首先导入pom依赖

<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-spring</artifactId>
    <version>1.3.2</version>
</dependency>

web.xml配置

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
<display-name>Archetype Created Web Application</display-name>

  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  <!-- 读取Spring上下文的监听器 -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!-- Spring和web项目集成end -->

  <!-- 防止Spring内存溢出监听器 -->
  <listener>
    <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
  </listener>

  <!-- shiro过滤器定义 -->
  <filter>
    <filter-name>shiroFilter</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    <init-param>
      <!-- 该值缺省为false,表示生命周期由SpringApplicationContext管理,设置为true则表示由ServletContainer管理 -->
      <param-name>targetFilterLifecycle</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>shiroFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>


  <!-- 中文乱码处理 -->
  <filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <!--web.xml 3.0的新特性，是否支持异步-->
    <async-supported>true</async-supported>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!-- Spring MVC servlet -->
  <servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--此参数可以不配置，默认值为：/WEB-INF/springmvc-servlet.xml-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/springmvc-servlet.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
    <!--web.xml 3.0的新特性，是否支持异步-->
    <async-supported>true</async-supported>
  </servlet>
  <servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

</web-app>

通过逆向工程将五张表生成对应的model、mapper

<table schema="" tableName="t_shiro_permission" domainObjectName="ShiroPermission"
               enableCountByExample="false" enableDeleteByExample="false"
               enableSelectByExample="false" enableUpdateByExample="false">
        </table>
        <table schema="" tableName="t_shiro_role" domainObjectName="ShiroRole"
               enableCountByExample="false" enableDeleteByExample="false"
               enableSelectByExample="false" enableUpdateByExample="false">
        </table>
        <table schema="" tableName="t_shiro_role_permission" domainObjectName="ShiroRolePermission"
               enableCountByExample="false" enableDeleteByExample="false"
               enableSelectByExample="false" enableUpdateByExample="false">
        </table>
        <table schema="" tableName="t_shiro_user" domainObjectName="ShiroUser"
               enableCountByExample="false" enableDeleteByExample="false"
               enableSelectByExample="false" enableUpdateByExample="false">
        </table>
        <table schema="" tableName="t_shiro_user_role" domainObjectName="ShiroUserRole"
               enableCountByExample="false" enableDeleteByExample="false"
               enableSelectByExample="false" enableUpdateByExample="false">
        </table>

接下来怎么把数据读取到Shiro里面去呢？
现在我们要自定义Realm（MyRealm）
MyRealm.java

package com.zlk.shiro;


import com.zlk.model.ShiroUser;
import com.zlk.sevice.ShiroUserService;
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.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;

/**
 * @author zrh
 * @site IDEA项目
 * @company
 * @create 2019-10-1317:00
 *
 * 认证的过程
 * 1、数据库（ini-》数据库）
 * 2、doGetAuthorizationInfo将数据库的用户信息给subject主体做shiro认证的
 *      2.1、需要在当前的realm中调用service来验证，当前用户是否在数据库中存在
 *      2.2、盐加密
 *
 */
public class MyRealm extends AuthorizingRealm {
    private ShiroUserService shiroUserService;

    public ShiroUserService getShiroUserService() {
        return shiroUserService;
    }

    public void setShiroUserService(ShiroUserService shiroUserService) {
        this.shiroUserService = shiroUserService;
    }

    /**
     * 授权
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    /**
     * 认证
     * @param token  从jsp传递过来的用户名密码组成的一个token对象
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        String userName = token.getPrincipal().toString();
        String pwd = token.getCredentials().toString();
        ShiroUser shiroUser = this.shiroUserService.queryByName(userName);
        AuthenticationInfo info = new SimpleAuthenticationInfo(
                shiroUser.getUsername(),
                shiroUser.getPassword(),
                ByteSource.Util.bytes(shiroUser.getSalt()),
                this.getName()

        );
        return info;
    }
}

需要在当前的realm中调用service来验证，当前用户是否在数据库中存在
ShiroUserService.java

@Service
public interface ShiroUserService {

    /**
     * 用于shiro认证
     * @param uname
     * @return
     */
    public ShiroUser queryByName(String uname);
}

写一个他的实现类
ShiroUserServiceImpl .java

@Service("shiroUserService")
public class ShiroUserServiceImpl implements ShiroUserService {
    @Autowired
    private ShiroUserMapper shiroUserMapper;
    @Override
    public ShiroUser queryByName(String uname) {
        return shiroUserMapper.queryByName(uname);
    }
}

**ShiroUserMappy.xml **

<select id="queryByName" resultType="com.zlk.model.ShiroUser" parameterType="java.lang.String">
    select
    <include refid="Base_Column_List" />
    from t_shiro_user
    where username = #{uname}
  </select>

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.zlk.shiro.MyRealm">
        <property name="shiroUserService" ref="shiroUserService" />
        <!--注意：重要的事情说三次~~~~~~此处加密方式要与用户注册时的算法一致 -->
        <!--注意：重要的事情说三次~~~~~~此处加密方式要与用户注册时的算法一致 -->
        <!--注意：重要的事情说三次~~~~~~此处加密方式要与用户注册时的算法一致 -->
        <!--以下三个配置告诉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[admin]
                /user/teacher.jsp=perms["user:update"]
               <!-- /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>


Shiro整合固定配置
**applicationContext.xml**

```cpp
<!-- 整合shiro -->
    <import resource="applicationContext-shiro.xml"></import>
盐加密

PasswordHelper .java

package com.zlk.util;

import org.apache.shiro.crypto.RandomNumberGenerator;
import org.apache.shiro.crypto.SecureRandomNumberGenerator;
import org.apache.shiro.crypto.hash.SimpleHash;

public class PasswordHelper {

    /**
     * 随机数生成器
     */
    private static RandomNumberGenerator randomNumberGenerator = new SecureRandomNumberGenerator();

    /**
     * 指定hash算法为MD5
     */
    private static final String hashAlgorithmName = "md5";

    /**
     * 指定散列次数为1024次，即加密1024次
     */
    private static final int hashIterations = 1024;

    /**
     * true指定Hash散列值使用Hex加密存. false表明hash散列值用用Base64-encoded存储
     */
    private static final boolean storedCredentialsHexEncoded = true;

    /**
     * 获得加密用的盐
     *
     * @return
     */
    public static String createSalt() {
        return randomNumberGenerator.nextBytes().toHex();
    }

    /**
     * 获得加密后的凭证
     *
     * @param credentials 凭证(即密码)
     * @param salt        盐
     * @return
     */
    public static String createCredentials(String credentials, String salt) {
        SimpleHash simpleHash = new SimpleHash(hashAlgorithmName, credentials,
                salt, hashIterations);
        return storedCredentialsHexEncoded ? simpleHash.toHex() : simpleHash.toBase64();
    }


    /**
     * 进行密码验证
     *
     * @param credentials        未加密的密码
     * @param salt               盐
     * @param encryptCredentials 加密后的密码
     * @return
     */
    public static boolean checkCredentials(String credentials, String salt, String encryptCredentials) {
        return encryptCredentials.equals(createCredentials(credentials, salt));
    }

    public static void main(String[] args) {
        //盐
        String salt = createSalt();
        System.out.println(salt);
        System.out.println(salt.length());
        //凭证+盐加密后得到的密码
        String credentials = createCredentials("123", salt);
        System.out.println(credentials);
        System.out.println(credentials.length());
        boolean b = checkCredentials("123", salt, credentials);
        System.out.println(b);
    }
}

测试

ShiroUserController.java

package com.zlk.controller;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @author zrh
 * @site IDEA项目
 * @company
 * @create 2019-10-1319:52
 */
@Controller
public class ShiroUserController {
    @RequestMapping("/login")
    public  String login(HttpServletRequest req, HttpServletResponse resp){
        Subject subject = SecurityUtils.getSubject();
        String uname = req.getParameter("username");
        String pwd = req.getParameter("password");
        UsernamePasswordToken token = new UsernamePasswordToken(uname,pwd);
        try{
            subject.login(token);
            return "main";
        }catch (Exception e){
            req.setAttribute("message","用户名或密码错误");
            return "login";

        }

    }
    @RequestMapping("/logout")
    public  String logout(HttpServletRequest req, HttpServletResponse resp){
        Subject subject = SecurityUtils.getSubject();
        subject.logout();
        return "login";
    }
}

界面：
在这里插入图片描述

在这里插入图片描述
最后说说我踩过的坑
Idea的maven项目在bulid是报错

Error:Cannot build artifact 'ssm:war exploded' because it is included into a circular dependency (artifact 'ssm:war exploded', artifact 'apinb-master:war exploded')

解决方案：
打开 File->Project Structure –> Artifacts(ctrl+alt+shift+s) ,这里会有4个，我已经删除了，把 ssm:war 和 ssm:war exploded 移除。然后重新启动就可以运行了

张润红
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java基于ssm框架的shiro整合，带有md5加密
01-06
使用：1，更改数据库配置文件2，创建test表（User的数据结构）。。。工具：Java7+eclipse+maven。 基于ssm框架的shiro整合，带有md5加密，注释只针对于shiro，其中有搭建过程中参考的博客地址，如有不懂的请参考注释中给的地址
Shiro身份认证加密
weixin_45346741的博客
12-01 109
Shiro身份认证加密导入pom.xml导入web.xml配置通过逆向工程将五张表生成对应的model、mappermd5加盐加密 导入pom.xml <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-core</artifactId&g...
shiro身份认证加密
qq_44493832的博客
10-14 281
文章目录Shiro认证 Shiro认证 Pom依赖 web.xml配置 <!-- shiro过滤器定义 --> <filter> <filter-name>shiroFilter</filter-name> <filter-class>org.springframework.web.filter.DelegatingFilter...
Shiro加密认证
敲得码黛
07-20 481
使用Shiro完成用户认证 环境：MyEclipse2017、JDK1.7、Spring4.1 步骤： 创建WEB项目添加Spring4.1支持并配置SpringMVC 引入Shiro相关jar包 编写Realm 配置Shiro前端过滤器 配置安全管理器及Shiro过滤器 编写Controller进行测试 步骤一：创建WEB项目添加Spring4.1支持并配置SpringMVC 此处...
shiro认证 、盐加密
钰团的博客
10-13 179
shiro认证-SSMshiro认证 、盐加密 shiro认证 、盐加密 加入pom依赖 <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-core</artifactId> <version>1.3.2</ver...
SSM+Maven+Shiro
05-24
最后，Shiro作为安全层，处理用户的身份验证和授权，确保只有经过认证和授权的用户才能访问特定资源。 具体实现时，通常会在Spring配置文件中定义Shiro的安全拦截器，比如使用`FormAuthenticationFilter`进行表单...
shiro整合ssm的全部jar包
01-27
然后是`shiro-core-1`，这是Shiro的核心库，包含了基本的身份验证、授权、会话管理及加密功能。在整合SSM时，你需要将Shiro的jar包引入到项目中，并创建Shiro的配置文件，例如`shiro.ini`或`shiro.xml`，在这里定义...
Shiro与SSM整合（内含详细文档介绍）
11-06
Apache Shiro 和 Spring Security (SSM) 是两个广泛使用的Java安全框架，它们分别提供认证、授权、会话管理和加密等功能，以确保Web应用程序的安全性。本资料包将深入讲解如何将Shiro与SSM整合，以实现更高效、灵活...
ssm+maven+shiro
03-29
Apache Shiro是一个强大的安全框架，主要用于身份验证（Authentication）、授权（Authorization）、会话管理和加密（Cryptography）。在这个项目中，Shiro被用来实现用户登录验证、角色和权限的控制，以及安全的会话...
SSM+shiro+redis
04-13
Shiro是Apache组织的一个开源项目，它提供了身份验证、授权、会话管理和密码加密等功能，可以轻松实现用户的登录、权限控制以及会话管理。Shiro与SSM集成，可以为基于Spring的Web应用提供一套完整的安全解决方案，...
shiro认证加密（二）
what_where的博客
10-13 151
文章目录1、shiro认证2、盐加密 1、shiro认证 Shiro认证 Pom依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ...
Shiro学习笔记——认证与加密
shen的博客
09-12 218
流程 获取当前的 Subject， 调用 SecurityUtils.getSubject(); 测试当前的用户是否已经被认证，即是否已经登录。调用 Subject .isAuthenticated() 若没有被认证，则把用户名和密码封装为UsernamePasswordToken 对象。 1）创建一个表单 2）把请求提交到SpringMVC的Handler 3）获取用户名和密码 执行登...
SSM项目整合Shiro进行身份验证
huangjhai的博客
02-25 454
简介 身份验证指的是系统一般需要提供一些标识信息来表明登录者的身份，如提供用户名和密码，或手机号和验证码来证明。在 Shiro 中，用户需要提供principals（身份）和 credentials（证明）给 Shiro来验证用户身份。 principals：身份即为主体的标识属性，它可以是任何属性，如用户名、 邮箱，手机号等，必须保证唯一。一个主体可以有多个principals，但只有一个 P...
Shiro认证-身份认证加密
最新发布
oyang的博客
08-26 861
在面对这个网络世界的时候，密码安全总是各个公司和用户都非常关心的一个内容，毕竟现在大家不管是休闲娱乐还是学习购物都是通过网上的帐号来进行消费的，所以我们通常会给用户的密码进行加密。在加密的时候，经常会听到“加盐”这个词，这是什么意思呢？加盐加密是一种对系统登录口令的加密方式，它实现的方式是将每一个口令同一个叫做”盐“（salt）的n位随机数相关联。无论何时只要口令改变，随机数就改变。随机数以未加密的方式存放在口令文件中，这样每个人都可以读。...
Shiro认证及加盐加密
m0_67477525的博客
08-25 1071
*** @company xxx公司*/}}@Override}@OverrideSystem.out.println("身份认证...");// 拿到数据库中的用户信息，放入token凭证中，用于controler进行对比);}}
springboot+shiro实现登陆过滤、权限认证、shiro密码加密、ehcache缓存（附demo项目）
热门推荐
AmbroseLe
09-12 2万+
首先说一下shiro能干什么 Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码学和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。（百度百科） 主要功能 三个核心组件：Subject, SecurityManager 和 Realms. Subjec...
Shiro学习笔记（五）——shiro实现加密及加密认证
驼君的小小博客园
02-07 557
散列算法概述 散列算法一般用于生成数据的摘要信息，是一种不可逆的算法，一般适合存储密码之类的数据，常见的散列算法如MD5、SHA等。一般进行散列时最好提供一个salt（盐） 比如 加密密码“admin”，产生的散列值是“21232f297a57a5a743894a0e4a801fc3”，可以到一 些md5 解密网站很容易的通过散列值得到密码“admin”，即如果直接对密码进行散列相对来说破解更容易...
PasswordHelper 对user对象的password进行加密重设
baicu7502的博客
04-05 360
public class PasswordHelper { private RandomNumberGenerator randomNumberGenerator = new SecureRandomNumberGenerator(); private String algorithmName = "md5"; private final i...
Shiro -认证凭据(密码)加密的那些事
小小默：进无止境
10-31 2930
一般来说，实际项目中隐私数据没有在网络上明文跑路，都会采用不同的加密算法。Shiro中的认证凭据通常也会采用算法进行加密。 【1】CredentialsMatcher接口 该接口只有一个方法，doCredentialsMatch，就是用来进行密码比较的！ 源码如下： public interface CredentialsMatcher { /** * Returns {@co...
Apache Shiro：简单安全框架在SSM与SpringBoot中的应用
相比于 Spring Security，Shiro 的功能可能稍显不足，但它专注于提供基本的认证（Authentication）、授权（Authorization）、会话管理（Session Management）、加密（Cryptography）、Web 集成、缓存（Caching）以及...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值