Spring实现Shiro简单实例

Spring实现Shiro简单实例

简介

Apache Shiro是Java的一个安全框架，旨在简化身份验证和授权。Shiro在JavaSE和JavaEE项目中都可以使用。它主要用来处理身份认证，授权，企业会话管理和加密等。Shiro的具体功能点如下：

（1）身份认证/登录，验证用户是不是拥有相应的身份；
（2）授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限；
（3）会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通JavaSE环境的，也可以是如Web环境的；
（4）加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；
（5）Web支持，可以非常容易的集成到Web环境；
Caching：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可以提高效率；
（6）shiro支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能把权限自动传播过去；
（7）提供测试支持；
（8）允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；
（9）记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了。

功能

image

Authentication：身份认证 / 登录，验证用户是不是拥有相应的身份；

Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限；

Session Management：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通 JavaSE 环境的，也可以是如 Web 环境的；

Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；

Web Support：Web 支持，可以非常容易的集成到 Web 环境；

Caching：缓存，比如用户登录后，其用户信息、拥有的角色 / 权限不必每次去查，这样可以提高效率；

Concurrency：shiro 支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能把权限自动传播过去；

Testing：提供测试支持；

Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；

Remember Me：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了。

核心组件

image

Subject：主体，代表了当前 “用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是 Subject，如网络爬虫，机器人等；即一个抽象概念；所有 Subject 都绑定到 SecurityManager，与 Subject 的所有交互都会委托给 SecurityManager；可以把 Subject 认为是一个门面；SecurityManager 才是实际的执行者；

SecurityManager：安全管理器；即所有与安全有关的操作都会与 SecurityManager 交互；且它管理着所有 Subject；可以看出它是 Shiro 的核心，它负责与后边介绍的其他组件进行交互，如果学习过 SpringMVC，你可以把它看成 DispatcherServlet 前端控制器；

Realm：域，Shiro 从从 Realm 获取安全数据（如用户、角色、权限），就是说 SecurityManager 要验证用户身份，那么它需要从 Realm 获取相应的用户进行比较以确定用户身份是否合法；也需要从 Realm 得到用户相应的角色 / 权限进行验证用户是否能进行操作；可以把 Realm 看成 DataSource，即安全数据源。

引入依赖

1
2
3
4
5
6
7
8
9
10
11
// https://mvnrepository.com/artifact/org.apache.shiro/shiro-core
implementation group: 'org.apache.shiro', name: 'shiro-core', version: '1.7.1'

// https://mvnrepository.com/artifact/org.apache.shiro/shiro-web
implementation group: 'org.apache.shiro', name: 'shiro-web', version: '1.7.1'

// https://mvnrepository.com/artifact/org.apache.shiro/shiro-ehcache
implementation group: 'org.apache.shiro', name: 'shiro-ehcache', version: '1.7.1'

// https://mvnrepository.com/artifact/org.apache.shiro/shiro-spring
implementation group: 'org.apache.shiro', name: 'shiro-spring', version: '1.7.1'

ShiroConfig

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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
package com.demo;

import org.apache.shiro.codec.Base64;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.session.mgt.SessionManager;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.CookieRememberMeManager;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.servlet.SimpleCookie;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;

import javax.servlet.Filter;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * Shiro配置类
 */
@Configuration
public class ShiroConfig {

    /**
     * 配置Shiro拦截器
     *
     * @param securityManager
     * @return
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {

        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();

        // 设置SecurityManager，必须
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        // 设置登录url
        shiroFilterFactoryBean.setLoginUrl("/login");
        // 未授权界面
        shiroFilterFactoryBean.setUnauthorizedUrl("/403");
        // 自定义拦截器
        Map<String, Filter> filters = new LinkedHashMap<String, Filter>();
        // 限制同一帐号同时在线的个数
        // filtersMap.put("kickOut", kickOutSessionControlFilter());
        shiroFilterFactoryBean.setFilters(filters);

        // 权限控制map
        Map<String, String> filterMap = new LinkedHashMap<>();
        filterMap.put("/login", "anon");
        // filterMap.put("/role", "authc");
        filterMap.put("/role", "anon");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterMap);

        return shiroFilterFactoryBean;
    }

    /**
     * 配置Session管理
     *
     * @return
     */
    @Bean
    public SessionManager sessionManager() {

        DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();

        sessionManager.setSessionValidationSchedulerEnabled(true);
        sessionManager.setSessionIdCookieEnabled(false);
        sessionManager.setGlobalSessionTimeout(2 * 3600000);

        return sessionManager;
    }

    /**
     * 配置Security管理
     *
     * @param sessionManager
     * @return
     */
    @Bean
    public SecurityManager securityManager(SessionManager sessionManager) {

        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();

        securityManager.setRealm(myShiroRealm());
        securityManager.setSessionManager(sessionManager);

        return securityManager;
    }

    /**
     * 开启shiro aop注解支持.否则@RequiresRoles等注解无法生效
     * 使用代理方式;
     *
     * @param securityManager
     * @return
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {

        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);

        return authorizationAttributeSourceAdvisor;
    }

    /**
     * Shiro生命周期处理器
     *
     * @return
     */
    @Bean
    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {

        return new LifecycleBeanPostProcessor();
    }

    /**
     * 自动创建代理
     *
     * @return
     */
    @Bean
    @DependsOn({"lifecycleBeanPostProcessor"})
    public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator() {

        DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        advisorAutoProxyCreator.setProxyTargetClass(true);

        return advisorAutoProxyCreator;
    }

    /**
     * 实例化ShiroRealm
     *
     * @return
     */
    @Bean
    public MyShiroRealm myShiroRealm() {

        return new MyShiroRealm();
    }

    /**
     * cookie对象
     *
     * @return
     */
    public SimpleCookie rememberMeCookie() {

        // 这个参数是cookie的名称，对应前端的checkbox的name = rememberMe
        SimpleCookie simpleCookie = new SimpleCookie("rememberMe");
        // 记住我的cookie生效时间30天，单位秒
        simpleCookie.setMaxAge(2592000);

        return simpleCookie;
    }

    /**
     * cookie管理对象;记住我功能
     *
     * @return
     */
    public CookieRememberMeManager rememberMeManager() {

        CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();

        cookieRememberMeManager.setCookie(rememberMeCookie());
        // rememberMe cookie加密的密钥 建议每个项目都不一样 默认AES算法 密钥长度(128 256 512位)
        cookieRememberMeManager.setCipherKey(Base64.decode("3AvVhmFLUs0KTA3Kprsdag=="));

        return cookieRememberMeManager;
    }
}

MyShiroRealm

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
101
102
103
104
105
package com.demo;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.HashSet;
import java.util.Set;

/**
 * 自定义realm
 */
public class MyShiroRealm extends AuthorizingRealm {

    @Autowired
    private UserService userService;

    /**
     * 验证用户身份
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authorToken) throws AuthenticationException {

        // 解析token令牌到用户名密码
        // 调用服务层方法查询此用户
        UsernamePasswordToken token = (UsernamePasswordToken) authorToken;
        String username = token.getUsername();
        String password = String.valueOf(token.getPassword());
        User user = userService.findByAccount(username);

        // 非法用户抛出异常
        // 抛出异常，在登陆处LoginController处理(subject.login()接收异常)
        if (user.getDelFlag() == 1) {
            throw new UnknownAccountException("验证未通过,用户无效！");
        }
        if (user == null || !user.getPassword().equals(password)) {
            throw new UnknownAccountException("验证未通过,用户名密码错误！");
        }

        // 设置Session
        // 将用户存放到session中
        User userInfo = new User();
        userInfo.setAccount(user.getAccount());
        userInfo.setPassword(user.getPassword());
        user.setDelFlag(user.getDelFlag());
        setSession("user", userInfo);

        return new SimpleAuthenticationInfo(user, password, getName());
    }

    /**
     * 授权用户权限
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

        // 获取当前用户信息并打印
        User user = (User) SecurityUtils.getSubject().getPrincipal();
        System.out.println(user.getAccount());

        /**
         * 编写用户角色与权限的判断逻辑
         * 不同类型用户执行不同的角色和权限操作
         */

        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();

        // 添加用户角色
        Set<String> roleSet = new HashSet<>();
        roleSet.add("admin");
        info.setRoles(roleSet);

        // 添加用户权限
        Set<String> permissionSet = new HashSet<>();
        permissionSet.add("999");
        info.setStringPermissions(permissionSet);

        return info;
    }

    /**
     * 数据放到ShiroSession中,以便其它地方使用
     *
     * @see // 比如Controller,使用时直接用HttpSession.getAttribute(key)就可以取到当前用户
     */
    private void setSession(Object key, Object value) {

        Subject currentUser = SecurityUtils.getSubject();
        if (currentUser != null) {
            Session session = currentUser.getSession();
            System.out.println(session.getId());
            if (null != session) {
                // 2小时
                session.setTimeout(7200000);
                session.setAttribute(key, value);
            }
        }
    }
}

LoginController

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
package com.demo;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authz.annotation.Logical;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.apache.shiro.subject.Subject;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpSession;

/**
 * 登录控制层
 */
@RestController
public class LoginController {

    /**
     * 登录测试
     *
     * @param account
     * @param password
     */
    @RequestMapping(value = "/login", method = {RequestMethod.POST, RequestMethod.GET})
    public void userLogin(@RequestParam("account") String account, @RequestParam("password") String password) {

        // 生成用户名密码令牌
        UsernamePasswordToken token = new UsernamePasswordToken(account, password);
        // 设置记住我
        token.setRememberMe(true);

        // 传递token到ShiroRealm
        // 捕获异常，账户错误
        Subject subject = SecurityUtils.getSubject();
        try {
            subject.login(token);
        } catch (UnknownAccountException e) {
            System.out.println("账户错误! ");
        }
    }

    /**
     * 权限测试
     */
    @RequestMapping(value = "/role")
    @RequiresRoles(value={"admin"})
    public void role() {

//        // 编程式：通过写if/else授权代码块完成
//        Subject subject = SecurityUtils.getSubject();
//        if (subject.hasRole("admin")) {
//            //有权限
//            System.out.println("I have this role! ");
//        } else {
//            //无权限
//            System.out.println("I haven't this role! ");
//        }

        System.out.println("I have this role! ");
    }
}

UserService

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.demo;

import org.springframework.stereotype.Service;

/**
 * 服务层
 */
@Service
public class UserService {

    public User findByAccount(String account) {

        /**
         * 实际场景中
         * 调用Mapper层的查询MySQL方法，验证用户身份
         */
        User user = new User();
        user.setAccount(account);
        user.setDelFlag(0);

        return user;
    }
}

User

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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
package com.demo;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/**
 * 系统用户实体类
 * 实现序列化Serializable，否则rememberMe设置中会序列化失败
 */
@Data
public class User implements Serializable {

    /**
     * 用户ID
     */
    private Long userId;

    /**
     * 用户账号名
     */
    private String account;

    /**
     * 密码默认值为123456
     */
    private String password = "123456";

    /**
     * 用户名
     */
    private String name;

    /**
     * 用户性别
     */
    private String gender;

    /**
     * 用户电子邮件
     */
    private String email;

    /**
     * 用户电话号码
     */
    private String telephone;

    /**
     * @是否是内部用户 0是 1否
     */
    private Integer isInner = 0;

    /**
     * 创建时间
     */
    private Date creatTime;

    /**
     * 登录时间
     */
    private Date loginTime;

    /**
     * 上次登录时间
     */
    private Date lastLoginTime;

    /**
     * 最后登录失败时间
     */
    private Date lastLoginErrorTime;

    /**
     * 登录错误次数
     */
    private Integer loginErrorCount = 0;

    /**
     * 是否锁定（0:未锁定，1:锁定）
     */
    private Integer isLocked = 0;

    /**
     * 管理员是否更改过密码（0:未更改，1:更改）
     */
    private Integer isUpdatePassword;

    /**
     * 删除标志
     */
    private Integer delFlag = 1;

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userid) {
        this.userId = userid;
    }

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getTelephone() {
        return telephone;
    }

    public void setTelephone(String telephone) {
        this.telephone = telephone;
    }

    public Integer getIsInner() {
        return isInner;
    }

    public void setIsInner(Integer isInner) {
        this.isInner = isInner;
    }

    public Date getCreatTime() {
        return creatTime;
    }

    public void setCreatTime(Date creatTime) {
        this.creatTime = creatTime;
    }

    public Date getLoginTime() {
        return loginTime;
    }

    public void setLoginTime(Date loginTime) {
        this.loginTime = loginTime;
    }

    public Date getLastLoginTime() {
        return lastLoginTime;
    }

    public void setLastLoginTime(Date lastLoginTime) {
        this.lastLoginTime = lastLoginTime;
    }

    public Date getLastLoginErrorTime() {
        return lastLoginErrorTime;
    }

    public void setLastLoginErrorTime(Date lastLoginErrorTime) {
        this.lastLoginErrorTime = lastLoginErrorTime;
    }

    public Integer getLoginErrorCount() {
        return loginErrorCount;
    }

    public void setLoginErrorCount(Integer loginErrorCount) {
        this.loginErrorCount = loginErrorCount;
    }

    public Integer getIsLocked() {
        return isLocked;
    }

    public void setIsLocked(Integer isLocked) {
        this.isLocked = isLocked;
    }

    public Integer getIsUpdatePassword() {
        return isUpdatePassword;
    }

    public void setIsUpdatePassword(Integer isUpdatePassword) {
        this.isUpdatePassword = isUpdatePassword;
    }

    public Integer getDelFlag() {
        return delFlag;
    }

    public void setDelFlag(Integer delFlag) {
        this.delFlag = delFlag;
    }
}

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

徘徊在原子与字节的边缘<br><br>将更好的自己呈现给世界<br><br><br><br>修心至要，事上磨练<br><br>一蓑衣，一壶酒，一曲长歌，一剑天涯<br><br>见自己，见天地，见众生<br><br>