springmvc+shiro+maven 实现登录与权限授权_springmvc 鉴权

作者：小蓝xlanll | 2024-03-02 20:47:09

踩

springmvc 鉴权

Shiro 是Shiro 是一个 Apache 下的一开源项目项目，旨在简化身份验证和授权。

1：shiro的配置，通过maven加入shiro相关jar包

<!-- shiro -->  
    <dependency>  
        <groupId>org.apache.shiro</groupId>  
        <artifactId>shiro-core</artifactId>  
        <version>1.2.1</version>  
    </dependency>  
    <dependency>  
        <groupId>org.apache.shiro</groupId>  
        <artifactId>shiro-web</artifactId>  
        <version>1.2.1</version>  
    </dependency>  
    <dependency>  
        <groupId>org.apache.shiro</groupId>  
        <artifactId>shiro-ehcache</artifactId>  
        <version>1.2.1</version>  
    </dependency>  
    <dependency>  
        <groupId>org.apache.shiro</groupId>  
        <artifactId>shiro-spring</artifactId>  
        <version>1.2.1</version>  
    </dependency>  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2 ：在web.xml中添加shiro过滤器

<!-- 配置shiro的核心拦截器 -->  
   <filter>  
        <filter-name>shiroFilter</filter-name>  
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>  
    </filter>  
    <filter-mapping>  
        <filter-name>shiroFilter</filter-name>  
        <url-pattern>/admin/*</url-pattern>  
    </filter-mapping>  1
2
3
4
5
6
7
8

3： springmvc中对shiro配置

<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"  
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans   
        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd   
        http://www.springframework.org/schema/mvc   
        http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd   
        http://www.springframework.org/schema/context   
        http://www.springframework.org/schema/context/spring-context-3.2.xsd   
        http://www.springframework.org/schema/aop   
        http://www.springframework.org/schema/aop/spring-aop-3.2.xsd   
        http://www.springframework.org/schema/tx   
        http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">  
&lt;!-- web.xml中shiro的filter对应的bean --&gt;  
&lt;bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean"&gt;  
    &lt;!-- 管理器，必须设置 --&gt;  
    &lt;property name="securityManager" ref="securityManager" /&gt;  
    &lt;!-- 拦截到，跳转到的地址,通过此地址去认证 --&gt;  
    &lt;property name="loginUrl" value="/admin/login.do" /&gt;  
    &lt;!-- 认证成功统一跳转到/admin/index.do，建议不配置，shiro认证成功自动到上一个请求路径 --&gt;  
    &lt;property name="successUrl" value="/admin/index.do" /&gt;  
    &lt;!-- 通过unauthorizedUrl指定没有权限操作时跳转页面 --&gt;  
    &lt;property name="unauthorizedUrl" value="/refuse.jsp" /&gt;  
    &lt;!-- 自定义filter，可用来更改默认的表单名称配置 --&gt;  
    &lt;property name="filters"&gt;  
        &lt;map&gt;  
            &lt;!-- 将自定义 的FormAuthenticationFilter注入shiroFilter中 --&gt;  
            &lt;entry key="authc" value-ref="formAuthenticationFilter" /&gt;  
        &lt;/map&gt;  
    &lt;/property&gt;  
    &lt;property name="filterChainDefinitions"&gt;  
        &lt;value&gt;  
            &lt;!-- 对静态资源设置匿名访问 --&gt;  
            /images/** = anon  
            /js/** = anon  
            /styles/** = anon  
            &lt;!-- 验证码，可匿名访问 --&gt;  
            /validatecode.jsp = anon  
            &lt;!-- 请求 logout.do地址，shiro去清除session --&gt;  
            /admin/logout.do = logout  
            &lt;!--商品查询需要商品查询权限 ，取消url拦截配置，使用注解授权方式 --&gt;  
            &lt;!-- /items/queryItems.action = perms[item:query] /items/editItems.action   
                = perms[item:edit] --&gt;  
            &lt;!-- 配置记住我或认证通过可以访问的地址 --&gt;  
            /welcome.jsp = user  
            /admin/index.do = user  
            &lt;!-- /** = authc 所有url都必须认证通过才可以访问 --&gt;  
            /** = authc  
        &lt;/value&gt;  
    &lt;/property&gt;  
&lt;/bean&gt;  

&lt;!-- securityManager安全管理器 --&gt;  
&lt;bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager"&gt;  
    &lt;property name="realm" ref="customRealm" /&gt;  
    &lt;!-- 注入缓存管理器 --&gt;  
    &lt;property name="cacheManager" ref="cacheManager" /&gt;  
    &lt;!-- 注入session管理器 --&gt;  
    &lt;!-- &lt;property name="sessionManager" ref="sessionManager" /&gt; --&gt;  
    &lt;!-- 记住我 --&gt;  
    &lt;property name="rememberMeManager" ref="rememberMeManager" /&gt;  
&lt;/bean&gt;  

&lt;!-- 自定义realm --&gt;  
&lt;bean id="customRealm" class="com.zhijianj.stucheck.shiro.CustomRealm"&gt;  
    &lt;!-- 将凭证匹配器设置到realm中，realm按照凭证匹配器的要求进行散列 --&gt;  
    &lt;!-- &lt;property name="credentialsMatcher" ref="credentialsMatcher" /&gt; --&gt;  
&lt;/bean&gt;  

&lt;!-- 凭证匹配器 --&gt;  
&lt;bean id="credentialsMatcher"  
    class="org.apache.shiro.authc.credential.HashedCredentialsMatcher"&gt;  
    &lt;!-- 选用MD5散列算法 --&gt;  
    &lt;property name="hashAlgorithmName" value="md5" /&gt;  
    &lt;!-- 进行一次加密 --&gt;  
    &lt;property name="hashIterations" value="1" /&gt;  
&lt;/bean&gt;  

&lt;!-- 自定义form认证过虑器 --&gt;  
&lt;!-- 基于Form表单的身份验证过滤器，不配置将也会注册此过虑器，表单中的用户账号、密码及loginurl将采用默认值，建议配置 --&gt;  
&lt;!-- 可通过此配置，判断验证码 --&gt;  
&lt;bean id="formAuthenticationFilter"  
    class="com.zhijianj.stucheck.shiro.CustomFormAuthenticationFilter "&gt;  
    &lt;!-- 表单中账号的input名称,默认为username --&gt;  
    &lt;property name="usernameParam" value="username" /&gt;  
    &lt;!-- 表单中密码的input名称,默认为password --&gt;  
    &lt;property name="passwordParam" value="password" /&gt;  
    &lt;!-- 记住我input的名称,默认为rememberMe --&gt;  
    &lt;property name="rememberMeParam" value="rememberMe" /&gt;  
&lt;/bean&gt;  
&lt;!-- 会话管理器 --&gt;  
&lt;bean id="sessionManager"  
    class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager"&gt;  
    &lt;!-- session的失效时长，单位毫秒 --&gt;  
    &lt;property name="globalSessionTimeout" value="600000" /&gt;  
    &lt;!-- 删除失效的session --&gt;  
    &lt;property name="deleteInvalidSessions" value="true" /&gt;  
&lt;/bean&gt;  
&lt;!-- 缓存管理器 --&gt;  
&lt;bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager"&gt;  
    &lt;property name="cacheManagerConfigFile" value="classpath:shiro-ehcache.xml" /&gt;  
&lt;/bean&gt;  
&lt;!-- rememberMeManager管理器，写cookie，取出cookie生成用户信息 --&gt;  
&lt;bean id="rememberMeManager" class="org.apache.shiro.web.mgt.CookieRememberMeManager"&gt;  
    &lt;property name="cookie" ref="rememberMeCookie" /&gt;  
&lt;/bean&gt;  
&lt;!-- 记住我cookie --&gt;  
&lt;bean id="rememberMeCookie" class="org.apache.shiro.web.servlet.SimpleCookie"&gt;  
    &lt;!-- rememberMe是cookie的名字 --&gt;  
    &lt;constructor-arg value="rememberMe" ;  
    &lt;!-- 记住我cookie生效时间30天 --&gt;  
    &lt;property name="maxAge" value="2592000";  
&lt;/bean&gt;  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4 ：自定义Realm编码

  public class CustomRealm extends AuthorizingRealm {  
    // 设置realm的名称  
    @Override  
    public void setName(String name) {  
        super.setName("customRealm");  
    }  
    @Autowired  
    private AdminUserService adminUserService;  
/** 
 * 认证 
 */  
@Override  
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  

    // token中包含用户输入的用户名和密码  
    // 第一步从token中取出用户名  
    String userName = (String) token.getPrincipal();  
    // 第二步：根据用户输入的userCode从数据库查询  
    TAdminUser adminUser = adminUserService.getAdminUserByUserName(userName);  
    // 如果查询不到返回null  
    if (adminUser == null) {//  
        return null;  
    }  
    // 获取数据库中的密码  
    String password = adminUser.getPassword();  
    /** 
     * 认证的用户,正确的密码 
     */  
    AuthenticationInfo authcInfo = new SimpleAuthenticationInfo(adminUser, password, this.getName());  
           //MD5 加密+加盐+多次加密  

    return authcInfo;  
}  

/** 
 * 授权,只有成功通过doGetAuthenticationInfo方法的认证后才会执行。
 */  
@Override  
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
    // 从 principals获取主身份信息  
    // 将getPrimaryPrincipal方法返回值转为真实身份类型（在上边的doGetAuthenticationInfo认证通过填充到SimpleAuthenticationInfo中身份类型），  
    TAdminUser activeUser = (TAdminUser) principals.getPrimaryPrincipal();  
    // 根据身份信息获取权限信息  
    // 从数据库获取到权限数据  
    TAdminRole adminRoles = adminUserService.getAdminRoles(activeUser);  
    // 单独定一个集合对象  
    List&lt;String&gt; permissions = new ArrayList&lt;String&gt;();  
    if (adminRoles != null) {  
        permissions.add(adminRoles.getRoleKey());  
    }  
    // 查到权限数据，返回授权信息(要包括 上边的permissions)  
    SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();  
    // 将上边查询到授权信息填充到simpleAuthorizationInfo对象中  
    simpleAuthorizationInfo.addStringPermissions(permissions);  
    return simpleAuthorizationInfo;  
}  

// 清除缓存  
public void clearCached() {  
    PrincipalCollection principals = SecurityUtils.getSubject().getPrincipals();  
    super.clearCache(principals);  
}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
1
2
3
4
5
6
7
8

}

5 缓存配置

ehcache.xml代码如下：

<ehcache updateCheck="false" name="shiroCache">  
    <defaultCache  
            maxElementsInMemory="10000"  
            eternal="false"  
            timeToIdleSeconds="120"  
            timeToLiveSeconds="120"  
            overflowToDisk="false"  
            diskPersistent="false"  
            diskExpiryThreadIntervalSeconds="120"  
            />  
</ehcache> 1
2
3
4
5
6
7
8
9
10

通过使用ehache中就避免第次都向服务器发送权限授权( doGetAuthorizationInfo )的请求。

6.自定义表单编码过滤器

CustomFormAuthenticationFilter代码，认证之前调用，可用于验证码校验

public class CustomFormAuthenticationFilter extends FormAuthenticationFilter {  
    // 原FormAuthenticationFilter的认证方法  
    @Override  
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {  
        // 在这里进行验证码的校验  
    // 从session获取正确验证码  
    HttpServletRequest httpServletRequest = (HttpServletRequest) request;  
    HttpSession session = httpServletRequest.getSession();  
    // 取出session的验证码（正确的验证码）  
    String validateCode = (String) session.getAttribute("validateCode");  

    // 取出页面的验证码  
    // 输入的验证和session中的验证进行对比  
    String randomcode = httpServletRequest.getParameter("randomcode");  
    if (randomcode != null &amp;&amp; validateCode != null &amp;&amp; !randomcode.equals(validateCode)) {  
        // 如果校验失败，将验证码错误失败信息，通过shiroLoginFailure设置到request中  
        httpServletRequest.setAttribute("shiroLoginFailure", "randomCodeError");  
        // 拒绝访问，不再校验账号和密码  
        return true;  
    }  
    return super.onAccessDenied(request, response);  
}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4
5

}

在此符上验证码jsp界面的代码 validatecode.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"  
    pageEncoding="UTF-8"%>  
<%@ page import="java.util.Random"%>  
<%@ page import="java.io.OutputStream"%>  
<%@ page import="java.awt.Color"%>  
<%@ page import="java.awt.Font"%>  
<%@ page import="java.awt.Graphics"%>  
<%@ page import="java.awt.image.BufferedImage"%>  
<%@ page import="javax.imageio.ImageIO"%>  
<%  
    int width = 60;  
    int height = 32;  
    //create the image  
    BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);  
    Graphics g = image.getGraphics();  
    // set the background color  
    g.setColor(new Color(0xDCDCDC));  
    g.fillRect(0, 0, width, height);  
    // draw the border  
    g.setColor(Color.black);  
    g.drawRect(0, 0, width - 1, height - 1);  
    // create a random instance to generate the codes  
    Random rdm = new Random();  
    String hash1 = Integer.toHexString(rdm.nextInt());  
    // make some confusion  
    for (int i = 0; i < 50; i++) {  
        int x = rdm.nextInt(width);  
        int y = rdm.nextInt(height);  
        g.drawOval(x, y, 0, 0);  
    }  
    // generate a random code  
    String capstr = hash1.substring(0, 4);  
    //将生成的验证码存入session  
    session.setAttribute("validateCode", capstr);  
    g.setColor(new Color(0, 100, 0));  
    g.setFont(new Font("Candara", Font.BOLD, 24));  
    g.drawString(capstr, 8, 24);  
    g.dispose();  
    //输出图片  
    response.setContentType("image/jpeg");  
    out.clear();  
    out = pageContext.pushBody();  
    OutputStream strm = response.getOutputStream();  
    ImageIO.write(image, "jpeg", strm);  
    strm.close();  
%>  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

7.登录控制器方法

/** 
 * 到登录界面 
 *  
 * @return 
 * @throws Exception 
 */  
@RequestMapping("login.do")  
public String adminPage(HttpServletRequest request) throws Exception {  
    // 如果登陆失败从request中获取认证异常信息，shiroLoginFailure就是shiro异常类的全限定名  
    String exceptionClassName = (String) request.getAttribute("shiroLoginFailure");  
    // 根据shiro返回的异常类路径判断，抛出指定异常信息  
    if (exceptionClassName != null) {  
        if (UnknownAccountException.class.getName().equals(exceptionClassName)) {  
            // 最终会抛给异常处理器  
            throw new CustomJsonException("账号不存在");  
        } else if (IncorrectCredentialsException.class.getName().equals(exceptionClassName)) {  
            throw new CustomJsonException("用户名/密码错误");  
        } else if ("randomCodeError".equals(exceptionClassName)) {  
            throw new CustomJsonException("验证码错误 ");  
        } else {  
            throw new Exception();// 最终在异常处理器生成未知错误  
        }  
    }  
    // 此方法不处理登陆成功（认证成功），shiro认证成功会自动跳转到上一个请求路径  
    // 登陆失败还到login页面  
    return "admin/login";  
}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

8.用户回显Controller

当用户登录认证成功后，CustomRealm在调用完doGetAuthenticationInfo时，通过

AuthenticationInfo authcInfo = new SimpleAuthenticationInfo(adminUser, password, this.getName());  
    return authcInfo; 1

SimpleAuthenticationInfo构造参数的第一个参数传入一个用户的对象，之后，可通过Subject subject = SecurityUtils.getSubject();中的subject.getPrincipal()获取到此对象。所以需要回显用户信息时，我这样调用的

@RequestMapping("index.do")  
public String index(Model model) {  
    //从shiro的session中取activeUser  
    Subject subject = SecurityUtils.getSubject();  
    //取身份信息  
    TAdminUser adminUser =  (TAdminUser) subject.getPrincipal();  
    //通过model传到页面  
    model.addAttribute("adminUser", adminUser);  
    return "admin/index";  
}  1
2
3
4
5
6
7
8
9

9.在jsp页面中控制权限

先引入shiro的头文件

<%@ taglib uri="http://shiro.apache.org/tags" prefix="shiro"%>

<!-- shiro头引入 -->  
<%@ taglib uri="http://shiro.apache.org/tags" prefix="shiro"%>  1

采用shiro标签对权限进行处理

<!-- 有curd权限才显示修改链接，没有该 权限不显示，相当 于if(hasPermission(curd)) -->  
                <shiro:hasPermission name="curd">  
                    <BR />  
                    我拥有超级的增删改查权限额  
                </shiro:hasPermission>  1
2
3
4

10.在Controller控制权限

通过@RequiresPermissions注解，指定执行此controller中某个请求方法需要的权限

@RequestMapping("/queryInfo.do")  
    @RequiresPermissions("q")//执行需要"q"权限  
    public ModelAndView queryItems(HttpServletRequest request) throws Exception { }1
2

11.MD5加密加盐处理

这里以修改密码为例,通过获取新的密码(明文)后通过MD5加密+加盐+3次加密为例

@RequestMapping("updatePassword.do")  
    @ResponseBody  
    public String updateAdminUserPassword(String newPassword) {  
        // 从shiro的session中取activeUser  
        Subject subject = SecurityUtils.getSubject();  
        // 取身份信息  
        TAdminUser adminUser = (TAdminUser) subject.getPrincipal();  
        // 生成salt,随机生成  
        SecureRandomNumberGenerator secureRandomNumberGenerator = new SecureRandomNumberGenerator();  
        String salt = secureRandomNumberGenerator.nextBytes().toHex();  
        Md5Hash md5 = new Md5Hash(newPassword, salt, 3);  
        String newMd5Password = md5.toHex();  
        // 设置新密码  
        adminUser.setPassword(newMd5Password);  
        // 设置盐  
        adminUser.setSalt(salt);  
        adminUserService.updateAdminUserPassword(adminUser);  
        return newPassword;  
    }  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/182366?site