<dependencies>

    <dependency>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-thymeleaf</artifactId>

    </dependency>

    <dependency>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-web</artifactId>

    </dependency>

    <dependency>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-test</artifactId>

    </dependency>

    <dependency>

        <groupId>org.apache.shiro</groupId>

        <artifactId>shiro-spring</artifactId>

        <version>1.5.3</version>

    </dependency>

</dependencies>

package com.it.fuxinyu.shiro;

?

import org.apache.shiro.authc.credential.CredentialsMatcher;

import org.apache.shiro.authc.credential.HashedCredentialsMatcher;

import org.apache.shiro.spring.web.ShiroFilterFactoryBean;

import org.apache.shiro.web.mgt.DefaultWebSecurityManager;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

?

import java.util.LinkedHashMap;

import java.util.Map;

?

import static com.it.fuxinyu.config.EncryptionMethodAttributes.ENCRYPTION_TIMES;

import static com.it.fuxinyu.config.EncryptionMethodAttributes.MD5;

import static com.it.fuxinyu.config.ShiroPermissionAttributes.*;

?

@Configuration

public class ShiroConfig {

?

    /**

     * 创建ShiroFilterFactoryBean

     *

     * @return

     */

    @Bean

    public ShiroFilterFactoryBean getShiroFilterFactoryBean() {

        /*

           创建ShiroFilterFactoryBean对 Shiro的过滤器

         */

        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();

        shiroFilterFactoryBean.setSecurityManager(getDefaultWebSecurityManager());

?

        //配置Shiro的过滤器

        Map<String, String> filterMap = new LinkedHashMap<>();

        filterMap.put("/login/login", ANON);

        filterMap.put("/image/**", ANON);

        filterMap.put("/user/toList", PERMS + "[user:list]");

        filterMap.put("/auth/logout", LOGOUt);

        filterMap.put("/**", AUTHC);

?

?

        /**

         * 弄登录页

         */

        shiroFilterFactoryBean.setLoginUrl("/login/toLogin");

        /**

         * 未授权页面

         */

        shiroFilterFactoryBean.setUnauthorizedUrl("/user/unauthorized");

?

        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterMap);

?

        return shiroFilterFactoryBean;

    }

?

    /**

     * 创建DefaultWebSecurityManager 用来管理用户主体的Subject

     *

     * @return

     */

    @Bean

    public DefaultWebSecurityManager getDefaultWebSecurityManager() {

        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();

        defaultWebSecurityManager.setRealm(getUserRealm());

        return defaultWebSecurityManager;

    }

?

    //shiro的加密使用的是哈希算法+盐加密 我们只需要给他盐和加盐的次数设定加密方式即可

?

    /**

     * 实例化自定义的Realm对象

     *

     * @return

     */

    @Bean

    public UserRealm getUserRealm() {

        UserRealm userRealm = new UserRealm();

        userRealm.setCredentialsMatcher(getCredentialsMatcher());

        return userRealm;

    }

?

    /**

     * 加密方法

     *

     * @return

     */

    @Bean

    public CredentialsMatcher getCredentialsMatcher() {

        //创建HashedCredentialsMatcher对象

        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();

        //指定加密方式,可以自定义哈希算法

        hashedCredentialsMatcher.setHashAlgorithmName(MD5);

        //设置加密次数

        hashedCredentialsMatcher.setHashIterations(ENCRYPTION_TIMES);

        //设置加密编码：true表示加密使用的是HEX编码 false表示使用的是Base64编码

        hashedCredentialsMatcher.setStoredCredentialsHexEncoded(true);

        return hashedCredentialsMatcher;

    }

?

}

?

package com.it.fuxinyu.shiro;

?

import org.apache.shiro.crypto.SecureRandomNumberGenerator;

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

?

public class ShiroUtils {

    /**

     * 随机生成 salt 需要指定 它的字符串的长度

     *

     * @param len 字符串的长度

     * @return salt

     */

    public static String generateSalt(int len) {

        //一个Byte占两个字节

        int byteLen = len >> 1;

        SecureRandomNumberGenerator secureRandom = new SecureRandomNumberGenerator();

        return secureRandom.nextBytes(byteLen).toHex();

    }

?

    /**

     * 获取加密后的密码，使用默认hash迭代的次数 1 次

     *

     * @param hashAlgorithm hash算法名称 MD2、MD5、SHA-1、SHA-256、SHA-384、SHA-512、etc。

     * @param password      需要加密的密码

     * @param salt          盐

     * @return 加密后的密码

     */

    public static String encryptPassword(String hashAlgorithm, String password, String salt) {

        return encryptPassword(hashAlgorithm, password, salt, 1);

    }

?

    /**

     * 获取加密后的密码，需要指定 hash迭代的次数

     *

     * @param hashAlgorithm  hash算法名称 MD2、MD5、SHA-1、SHA-256、SHA-384、SHA-512、etc。

     * @param password       需要加密的密码

     * @param salt           盐

     * @param hashIterations hash迭代的次数

     * @return 加密后的密码

     */

    public static String encryptPassword(String hashAlgorithm, String password, String salt, int hashIterations) {

        SimpleHash hash = new SimpleHash(hashAlgorithm, password, salt, hashIterations);

        return hash.toString();

    }

}

package com.it.fuxinyu.shiro;

?

import com.it.fuxinyu.pojo.User;

import com.it.fuxinyu.service.UserService;

import org.apache.commons.lang3.ObjectUtils;

import org.apache.commons.lang3.RandomStringUtils;

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.subject.PrincipalCollection;

import org.apache.shiro.util.ByteSource;

import org.springframework.beans.factory.annotation.Autowired;

?

public class UserRealm extends AuthorizingRealm {

?

?

    @Autowired

    private UserService userService;

?

    /**

     * 授权

     * <p>

     * 校验访问路径

     *

     * @param principals

     * @return

     */

    @Override

    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

?

        System.out.println("-------授权----------");

?

        //编写授权逻辑

        //从数据库查询出当前用户所拥有的权限字符串进行授权

        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();

?

        //添加权限字符串

        authorizationInfo.addStringPermission("user:list");

?

        return authorizationInfo;

?

    }

?

?

    /**

     * 认证

     * <p>

     * 进行登录验证

     *

     * @param token

     * @return

     * @throws AuthenticationException

     */

    @Override

    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

        System.out.println("----------认证----------");

        UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) token;

        //调用数据库根据用户名查询出用户

        User user = userService.findByName(usernamePasswordToken.getUsername());

?

        if (ObjectUtils.isEmpty(user) || !usernamePasswordToken.getUsername().equals(user.getUserName())) {

            return null;

        }

?

        /**

         * 第一个参数为,假如密码正确就是说登录成功后用户对象,相当于我们以前登陆成功后用户放入session的意思

         * 第二个参数,数据库查询出来的密码,shiro会自动帮我们校验密码是否正确

         * 第三个参数,假如密码正确也就是说登录成功后用户名

         * shiro的加密方式通过盐加次数进行hash加密

         * 比如说1234明文,把1234和某一个字符串(盐)一起加密

         */

?

        //判断密码

        return new SimpleAuthenticationInfo(user, user.getPassword(), ByteSource.Util.bytes(user.getSalt()), user.getUserName());

    }

?

}

package com.it.fuxinyu.config;

?

/**

 * 加密方式属性接口

 */

public interface EncryptionMethodAttributes {

    /**

     * 加密方式MD5

     */

    String MD5 = "MD5";

    /**

     * 加密方式MD4

     */

    String MD4 = "MD4";

    /**

     * 加密方式SHA_1

     */

    String SHA_1 = "SHA-1";

    /**

     * 加密方式SHA_2

     */

    String SHA_2 = "SHA-2";

    /**

     * 加密方式SHA_256

     */

    String SHA_256 = "SHA-256";

    /**

     * 加密方式SHA_512

     */

    String SHA_512 = "SHA-512";

    /**

     * 加密方式SHA_384

     */

    String SHA_384 = "SHA-384";

    /**

     * 加密次数

     */

    Integer ENCRYPTION_TIMES = 1;

}

package com.it.fuxinyu.config;

?

/**

 * shiro权限参数

 */

public interface ShiroPermissionAttributes {

?

    /**

     * 不需要登录就能访问的路径

     */

    String ANON = "anon";

    /**

     * 需要登录才能访问

     */

    String AUTHC = "authc";

    /**

     * 该资源必须得到资源权限才可以访问

     */

    String PERMS = "perms";

    /**

     * Basic HTTP身份验证拦截器

     */

    String AUTHC_BASIC = "authcBasic";

    /**

     * 退出拦截器。退出成功后会 redirect到设置的/URI

     */

    String LOGOUt = "logout";

    /**

     * 不创建会话连接器

     */

    String NO_SESSION_CREATION = "noSessionCreation";

    /**

     * 端口拦截器

     */

    String PORT = "port";

    /**

     * rest风格拦截器

     */

    String REST = "rest";

    /**

     * 角色拦截器

     */

    String ROLES = "roles";

    /**

     * ssl拦截器。通过https协议才能通过

     */

    String SSL = "ssl";

    /**

     * 用户拦截器 登录后（authc），第二次没登陆但是有记住我(rememberMe)都可以访问

     */

    String USER = "user";

?

}

@RequestMapping("/login")

public String login(User user, Model model) {

?

    //使用shiro编写登录逻辑

    //1.获取subject

    Subject subject = SecurityUtils.getSubject();

    //2.将参数封装成Token对象

    UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(user.getUserName(), user.getPassword());

    //3.执行登录方法

    try {

        subject.login(usernamePasswordToken);

        return "redirect:/index/toIndex";

    } catch (IncorrectCredentialsException e) {//这个异常一抛出代表密码错误

        model.addAttribute("message", "密码错误");

        return "/login";

    } catch (AuthenticationException e) {  //如果用户不存在,抛出账户位置异常

        model.addAttribute("message", "账号不存在");

        return "/login";

    }

?

}

@RequestMapping("/toAdd")

public String toAdd() {

    Object principal = SecurityUtils.getSubject().getPrincipal();

    User user = null;

    if (principal instanceof User) {

        user = (User) principal;

    }

    System.out.println(user);

    return "add";

}