Shiro 实战教程(2020版本)

1.权限的管理

• 什么是权限管理
  • 基本上涉及到用户参与的系统都要进行权限管理，权限管理属于系统安全的范畴，权限管理实现对用户访问系统的控制，按照安全规则或者安全策略控制用户可以访问而且只能访问自己被授权的资源。
  • 权限管理包括用户身份认证和授权两部分，简称认证授权。对于需要访问控制的资源用户首先经过身份认证，认证通过后用户具有该资源的访问权限方可访问。
• 什么是身份认证
  • 身份认证，就是判断一个用户是否为合法用户的处理过程。最常用的简单身份认证方式是系统通过核对用户输入的用户名和口令，看其是否与系统中存储的该用户的用户名和口令一致，来判断用户身份是否正确。对于采用指纹等系统，则出示指纹；对于硬件Key等刷卡系统，则需要刷卡。
• 什么是授权
  • 授权，即访问控制，控制谁能访问哪些资源。主体进行身份认证后需要分配权限方可访问系统的资源，对于某些资源没有权限是无法访问的

2.什么是shiro

Apache Shiro? is a powerful and easy-to-use Java security framework that performs authentication, authorization, cryptography, and session management. With Shiro’s easy-to-understand API, you can quickly and easily secure any application – from the smallest mobile applications to the largest web and enterprise applications.
Shiro 是一个功能强大且易于使用的Java安全框架，它执行身份验证、授权、加密和会话管理。使用Shiro易于理解的API，您可以快速轻松地保护任何应用程序—从最小的移动应用程序到最大的web和企业应用程序。

Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。

3.shiro的核心架构

• Subject
  • Subject即主体，外部应用与subject进行交互，subject记录了当前操作用户，将用户的概念理解为当前操作的主体，可能是一个通过浏览器请求的用户，也可能是一个运行的程序。 Subject在shiro中是一个接口，接口中定义了很多认证授相关的方法，外部程序通过subject进行认证授，而subject是通过SecurityManager安全管理器进行认证授权
• SecurityManager
  • SecurityManager即安全管理器，对全部的subject进行安全管理，它是shiro的核心，负责对所有的subject进行安全管理。通过SecurityManager可以完成subject的认证、授权等，实质上SecurityManager是通过Authenticator进行认证，通过Authorizer进行授权，通过SessionManager进行会话管理等。
  • SecurityManager是一个接口，继承了Authenticator, Authorizer, SessionManager这三个接口。
• Authenticator
  • Authenticator即认证器，对用户身份进行认证，Authenticator是一个接口，shiro提供ModularRealmAuthenticator实现类，通过ModularRealmAuthenticator基本上可以满足大多数需求，也可以自定义认证器。
• Authorizer
  • Authorizer即授权器，用户通过认证器认证通过，在访问功能时需要通过授权器判断用户是否有此功能的操作权限。
• Realm
  • Realm即领域，相当于datasource数据源，securityManager进行安全认证需要通过Realm获取用户权限数据，比如：如果用户身份数据在数据库那么realm就需要从数据库获取用户身份信息。
  • 注意：不要把realm理解成只是从数据源取数据，在realm中还有认证授权校验的相关的代码。
• SessionManager
  • sessionManager即会话管理，shiro框架定义了一套会话管理，它不依赖web容器的session，所以shiro可以使用在非web应用上，也可以将分布式应用的会话集中在一点管理，此特性可使它实现单点登录。
• SessionDAO
  • SessionDAO即会话dao，是对session会话操作的一套接口，比如要将session存储到数据库，可以通过jdbc将会话存储到数据库。
• CacheManager
  • CacheManager即缓存管理，将用户权限数据存储在缓存，这样可以提高性能。
• Cryptography
  • Cryptography即密码管理，shiro提供了一套加密/解密的组件，方便开发。比如提供常用的散列、加/解密等功能。

shiro中的认证

• 认证
  • 身份认证，就是判断一个用户是否为合法用户的处理过程。最常用的简单身份认证方式是系统通过核对用户输入的用户名和口令，看其是否与系统中存储的该用户的用户名和口令一致，来判断用
• shiro中认证的关键对象
  • Subject：主体
    • 访问系统的用户，主体可以是用户、程序等，进行认证的都称为主体；
  • Principal：身份信息
    • 是主体（subject）进行身份认证的标识，标识必须具有唯一性，如用户名、手机号、邮箱地址等，一个主体可以有多个身份，但是必须有一个主身份（Primary Principal）。
  • credential：凭证信息
    • 是只有主体自己知道的安全信息，如密码、证书等。
• 认证流程
  

认证的开发

1. 创建项目并引入依赖

    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-core</artifactId>
      <version>1.5.3</version>
    </dependency>

2. 引入shiro配置文件并加入如下配置

shiro的配置文件是以.ini结尾的文件，.ini里面可以写一些比较复杂的数据格式，shiro在解析的时候，也是可以直接解析以.ini结尾的配置文件，只要放在resources文件夹下即可，文件名任意，文件格式必须是.ini文件，使用springboot之后，就可以不适用这个配置文件，这个文件主要是用来我们在学习阶段时，书写我们shiro中相关权限数据,就可以不用连接数据库，直接把权限的数据写死到ini文件中

    [users]
    xiaochen=123
    zhangsan=456

3. 开发认证代码

   public class TestAuthenticator {
    public static void main(String[] args) {

        //1.创建安全管理器对象
        DefaultSecurityManager securityManager = new DefaultSecurityManager();

        //2.给安全管理器设置realm(拿到ini文件中的数据)
        securityManager.setRealm(new IniRealm("classpath:shiro.ini"));

        //3.SerurityUtils 给全局的安全工具类设置安全管理器
        SecurityUtils.setSecurityManager(securityManager);

        //4.关键对象 subject代表主体
        Subject subject = SecurityUtils.getSubject();

        //5.创建令牌
        UsernamePasswordToken token = new UsernamePasswordToken("xiaochen","1234");

        try{
            System.out.println("认证状态:"+subject.isAuthenticated());
            subject.login(token);//用户认证
            System.out.println("认证状态:"+subject.isAuthenticated());
        }catch (UnknownAccountException e){
            e.printStackTrace();
            System.out.println("认证失败,用户名不存在");
        }catch (IncorrectCredentialsException e){
            e.printStackTrace();
            System.out.println("认证失败,密码错误");
        }
    }
}

shiro的异常

• DisabledAccountException（帐号被禁用）
• LockedAccountException（帐号被锁定）
• ExcessiveAttemptsException（登录失败次数过多）
• ExpiredCredentialsException（凭证过期）
• UnknownAccountException（用户名不存在）
• IncorrectCredentialsException（密码错误）等

4.自定义Realm

上边的程序使用的是Shiro自带的IniRealm，IniRealm从ini配置文件中读取用户的信息，大部分情况下需要从系统的数据库中读取用户信息，所以需要自定义realm。

• shiro提供的Realm
  

• 根据认证源码认证使用的是SimpleAccountRealm

SimpleAccountRealm的部分源码中有两个方法一个是 认证 一个是 授权,

    public class SimpleAccountRealm extends AuthorizingRealm {
    		//.......省略
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
            UsernamePasswordToken upToken = (UsernamePasswordToken) token;
            SimpleAccount account = getUser(upToken.getUsername());
    
            if (account != null) {
    
                if (account.isLocked()) {
                    throw new LockedAccountException("Account [" + account + "] is locked.");
                }
                if (account.isCredentialsExpired()) {
                    String msg = "The credentials for account [" + account + "] are expired";
                    throw new ExpiredCredentialsException(msg);
                }
    
            }
    
            return account;
        }
    
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
            String username = getUsername(principals);
            USERS_LOCK.readLock().lock();
            try {
                return this.users.get(username);
            } finally {
                USERS_LOCK.readLock().unlock();
            }
        }
    }

• 自定义realm

/**
 * @Author CDL
 * @Date 2020/12/18 14:54
 * @Desc 自定义realm实现，将认证/授权数据的来源转为数据库的实现
 * @Version 1.0.
 */
public class CustomerRealm extends AuthorizingRealm {
    //授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        return null;
    }

    //认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        //在token中获取用户名
        String principal = token.getPrincipal().toString();
        //根据身份信息查询数据库进行验证,这里使用假数据，模拟数据库
        if("xiaochen".equals(principal)){
            //参数1：返回数据库中正确的用户名，参数2：返回数据库中的正确密码 参数3：提供当前父类的realm的名字，直接使用this.getName()
            // simpleAuthenticationInfo 相当于数据库中拿到的数据
            SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo("xiaochen","123",this.getName());
            return simpleAuthenticationInfo;
        }
        return null;
    }
}

• 使用自定义Realm认证

/**
 * @Author CDL
 * @Date 2020/12/18 14:58
 * @Desc 使用自定义realm,进行认证
 * @Version 1.0.
 */
public class TestCustomerRealmAuthenticator {
    public static void main(String[] args) {
        //创建securityManager
        DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();

        //设置之定义realm
        defaultSecurityManager.setRealm(new CustomerRealm());

        //将安全工具类设置安全管理器
        SecurityUtils.setSecurityManager(defaultSecurityManager);

        //通过安全工具类获取subject
        Subject subject = SecurityUtils.getSubject();

        //创建token,这里的用户名密码就相当于浏览器的登录数据，把这个数据放到token，再去与使用数据库的数据进行认证
        UsernamePasswordToken token = new UsernamePasswordToken("xiaochen", "123");
        try {
            subject.login(token);
        } catch (UnknownAccountException e){
            e.printStackTrace();
            System.out.println("认证失败,用户名不存在");
        }catch (IncorrectCredentialsException e){
            e.printStackTrace();
            System.out.println("认证失败,密码错误");
        }
    }
}

使用MD5和Salt

实际应用是将盐和散列后的值存在数据库中，自动realm从数据库取出盐和加密后的值由shiro完成密码校验。

• 自定义md5+salt的realm

    /**
     * 自定义md5+salt realm
     */
    public class CustomerRealm extends AuthorizingRealm {
        //认证方法
        @Override
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
            return null;
        }
    
        //授权方法
        @Override
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
            String principal = (String) token.getPrincipal();
            if("xiaochen".equals(principal)){
                String password = "3c88b338102c1a343bcb88cd3878758e";
                String salt = "Q4F%";
                return new SimpleAuthenticationInfo(principal,password, 
                                                    ByteSource.Util.bytes(salt),this.getName());
            }
            return null;
        }

• 使用md5 + salt 认证

MD5还可以用来校验两个文件是否相同，生成的结构始终是16进制，长度为32位的字符串

测试MD5加密

public class TestShiroMD5 {
    public static void main(String[] args) {
        //使用MD5
        Md5Hash md5Hash = new Md5Hash("123");
        System.out.println(md5Hash.toHex());
        //使用MD5 + salt 处理,默认把盐加在后面   salt做一个随机字符串即可，这里随意写一个
        Md5Hash md5Hash1 = new Md5Hash("123", "X08*PWQD");
        System.out.println(md5Hash1.toHex());
        //使用MD5 + salt + hash 散列  第三个参数表示散列的次数
        Md5Hash md5Hash2 = new Md5Hash("123", "X08*PWQD", 1024);
        System.out.println(md5Hash2.toHex());
    }
}
/**
202cb962ac59075b964b07152d234b70
67005b4f11230614c9150f6843425f79
78f4452361e7c07ef9cd3d1fcbd5f629
*/

自定义md5+salt的realm

/**
 * @Author CDL
 * @Date 2020/12/18 16:48
 * @Desc 使用自定义realm加入md5,随机盐，
 * @Version 1.0.
 */
public class CustomerMd5Realm extends AuthorizingRealm {
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        return null;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        //获取身份信息
        String principal = token.getPrincipal().toString();

        //根据用户名查询数据库
        if("xiaochen".equals(principal)){
            /**
             *  参数1:数据库的用户名
             *  参数1:数据库MD5+salt之后的密码
             *  参数1:注册时数据库的随即盐
             *  参数1:realm的名字
             */
            return new SimpleAuthenticationInfo(principal,"78f4452361e7c07ef9cd3d1fcbd5f629",
                    ByteSource.Util.bytes("X08*PWQD"),this.getName());
        }
        return null;
    }
}

改造shiro的认证流程，加入MD5和随机盐的处理

   /**
 * @Author CDL
 * @Date 2020/12/18 16:50
 * @Desc 使用md5 + salt 认证
 * @Version 1.0.
 */
public class TestCustomerMd5RealmAuthenticator {
    public static void main(String[] args) {
        //创建安全管理器
        DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();
        //注入realm
        CustomerMd5Realm realm = new CustomerMd5Realm();
        //设置realm使用hash凭证匹配器
        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
        hashedCredentialsMatcher.setHashAlgorithmName("md5");
        //设置散列次数
        hashedCredentialsMatcher.setHashIterations(1024);
        realm.setCredentialsMatcher(hashedCredentialsMatcher);

        defaultSecurityManager.setRealm(realm);
        //将安全管理器注入安全工具列
        SecurityUtils.setSecurityManager(defaultSecurityManager);

        //通过安全工具类获取subjiect
        Subject subject = SecurityUtils.getSubject();

        //认证
        UsernamePasswordToken token = new UsernamePasswordToken("xiaochen", "123");

        try {
            subject.login(token);
            System.out.println("登录成功");
        } catch (UnknownAccountException e){
            e.printStackTrace();
            System.out.println("认证失败,用户名不存在");
        }catch (IncorrectCredentialsException e){
            e.printStackTrace();
            System.out.println("认证失败,密码错误");
        }
    }
}

shiro中的授权

授权

• 授权，即访问控制，控制谁能访问哪些资源。主体进行身份认证后需要分配权限方可访问系统的资源，对于某些资源没有权限是无法访问的。

关键对象

• 授权可简单理解为who对what(which)进行How操作：
• Who，即主体（Subject），主体需要访问系统中的资源。
• What，即资源（Resource)，如系统菜单、页面、按钮、类方法、系统商品信息等。资源包括资源类型和资源实例，比如商品信息为资源类型，类型为t01的商品为资源实例，编号为001的商品信息也属于资源实例。
• How，权限/许可（Permission)，规定了主体对资源的操作许可，权限离开资源没有意义，如用户查询权限、用户添加权限、某个类方法的调用权限、编号为001用户的修改权限等，通过权限可知主体对哪些资源都有哪些操作许可。

授权流程

授权方式

• 基于角色的访问控制
  • RBAC基于角色的访问控制（Role-Based Access Control）
  • 是以角色为中心进行访问控制
    if(subject.hasRole("admin")){
    //操作什么资源
    }
• 基于资源的访问控制
  • RBAC基于资源的访问控制（Resource-Based Access Control）
  • 是以资源为中心进行访问控制
    if(subject.isPermission("user:update:01")){ //资源实例
    //对01用户进行修改
    }
    if(subject.isPermission("user:update:*")){ //资源类型
    //对01用户进行修改
    }

权限字符串

• 权限字符串的规则是：资源标识符：操作：资源实例标识符，意思是对哪个资源的哪个实例具有什么操作，“:”是资源/操作/实例的分割符，权限字符串也可以使用*通配符。

例子：

• 用户创建权限：user:create，或user:create:*
• 用户修改实例001的权限：user:update:001
• 用户实例001的所有权限：user:*：001

shiro中授权编程实现方式

• 编程式

      Subject subject = SecurityUtils.getSubject();
      if(subject.hasRole(“admin”)) {
      	//有权限
      } else {
      	//无权限
      }

• 注解式

      @RequiresRoles("admin")
      public void hello() {
      	//有权限
      }

• 标签式

      JSP/GSP 标签：在JSP/GSP 页面通过相应的标签完成：
      <shiro:hasRole name="admin">
      	<!— 有权限—>
      </shiro:hasRole>
      注意: Thymeleaf 中使用shiro需要额外集成!

开发授权

1.realm的实现

/**
 * @Author CDL
 * @Date 2020/12/18 16:48
 * @Desc 使用自定义realm加入md5,随机盐，
 * @Version 1.0.
 */
public class CustomerMd5Realm extends AuthorizingRealm {
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        String primaryPrincipal = principals.getPrimaryPrincipal().toString();
        System.out.println("身份信息（用户名）"+primaryPrincipal);
        //根据用户名查询数据库的角色信息以及权限信息  假色 xiaochen  admin user
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        //将数据查询的角色信息赋值给权限对象 simpleAuthorizationInfo
        simpleAuthorizationInfo.addRole("admin");
        simpleAuthorizationInfo.addRole("user");
        //将数据库中的查询的权限信息赋值给权限对象
        simpleAuthorizationInfo.addStringPermission("user:*:01");
        simpleAuthorizationInfo.addStringPermission("product:create:01");
        return simpleAuthorizationInfo;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        //获取身份信息
        String principal = token.getPrincipal().toString();

        //根据用户名查询数据库
        if("xiaochen".equals(principal)){
            /**
             *  参数1:数据库的用户名
             *  参数1:数据库MD5+salt之后的密码
             *  参数1:注册时数据库的随即盐
             *  参数1:realm的名字
             */
            return new SimpleAuthenticationInfo(principal,"78f4452361e7c07ef9cd3d1fcbd5f629",
                    ByteSource.Util.bytes("X08*PWQD"),this.getName());
        }
        return null;
    }
}

2.授权

/**
 * @Author CDL
 * @Date 2020/12/18 16:50
 * @Desc 使用md5 + salt 认证
 * @Version 1.0.
 */
public class TestCustomerMd5RealmAuthenticator {
    public static void main(String[] args) {
        //创建安全管理器
        DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();
        //注入realm
        CustomerMd5Realm realm = new CustomerMd5Realm();
        //设置realm使用hash凭证匹配器
        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
        hashedCredentialsMatcher.setHashAlgorithmName("md5");
        //设置散列次数
        hashedCredentialsMatcher.setHashIterations(1024);
        realm.setCredentialsMatcher(hashedCredentialsMatcher);

        defaultSecurityManager.setRealm(realm);
        //将安全管理器注入安全工具列
        SecurityUtils.setSecurityManager(defaultSecurityManager);

        //通过安全工具类获取subjiect
        Subject subject = SecurityUtils.getSubject();

        //认证
        UsernamePasswordToken token = new UsernamePasswordToken("xiaochen", "123");

        try {
            subject.login(token);
            System.out.println("登录成功");
        } catch (UnknownAccountException e){
            e.printStackTrace();
            System.out.println("认证失败,用户名不存在");
        }catch (IncorrectCredentialsException e){
            e.printStackTrace();
            System.out.println("认证失败,密码错误");
        }

        //认证通过的用户进行授权
        if(subject.isAuthenticated()){
            //1.基于角色的权限控制
            boolean admin = subject.hasRole("admin");
            System.out.println(admin);
            //2.基于多角色的权限控制 假如一个用户需要同时有两个权限才能访问
            boolean b = subject.hasAllRoles(Arrays.asList("user", "admin"));
            System.out.println(b);
            //3.是否有其中一个角色
            boolean[] booleans = subject.hasRoles(Arrays.asList("user", "admin", "super"));
            for (boolean aBoolean : booleans) {
                System.out.println(aBoolean);
            }

            //基于权限字符串的访问控制 资源标识符：操作：资源类型
            boolean permitted = subject.isPermitted("user:*:*");//是否具有所有user模块的所有权限
            System.out.println(permitted);

            //分别具有哪些权限
            boolean[] permitted1 = subject.isPermitted("user:*:*", "product:*:*");
            for (boolean b1 : permitted1) {
                System.out.println(b1);
            }

            //同时具有哪些权限
            boolean permittedAll = subject.isPermittedAll("user:*:*", "product:*:*");
            System.out.println(permittedAll);
        }
    }
}

整合SpringBoot项目实战

整合思路

**创建springboot项目 **

1.引入shiro依赖

    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-spring-boot-starter</artifactId>
      <version>1.5.3</version>
    </dependency>

2.配置shiro环境

创建配置类

/**
 * date:
 * Author:CDL
 * desc:用来整合shiro框架相关的配置类
 * version:1.0
 */
@Configuration
public class ShiroConfig {

    //1.创建shiroFilter  负责拦截请求（所以里面传入一个安全管理器）
    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        //给Filter设置安全管理器
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        //配置系统的受限资源 公共资源
        Map<String,String> map = new HashMap<>();
        map.put("/index.jsp","authc");

        //默认的认证界面的路径
        shiroFilterFactoryBean.setLoginUrl("/login.jsp");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);

        return shiroFilterFactoryBean;
    }

    //2.创建安全管理器  安全管理器里面需要传入数据，所以需要创建Realm
    @Bean
    public DefaultWebSecurityManager getDefaultWebSecurityManager(Realm realm){
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        //给安全管理器设置Realm
        defaultWebSecurityManager.setRealm(realm);
        return defaultWebSecurityManager;
    }

    //3.创建自定义Realm
    @Bean
    public Realm getRealm(){

        CustomerRealm customerRealm = new CustomerRealm();
        return customerRealm;
    }
}

自定义Realm

public class CustomerRealm extends AuthorizingRealm {
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        return null;
    }
}

启动springboot应用访问index,会发现index被拦截，默认跳转到login.jsp

常见过滤器

• 注意: shiro提供和多个默认的过滤器，我们可以用这些过滤器来配置控制指定url的权限：

 ssl          |    	SslFilter          |           	需要https请求才能访问 
   user        |     	UserFilter          |          	需要已登录或“记住我”的用户才能访问                      

认证实现

1. 在login.jsp中开发认证界面

    <form action="${pageContext.request.contextPath}/user/login" method="post">
      用户名:<input type="text" name="username" > <br/>
      密码  : <input type="text" name="password"> <br>
      <input type="submit" value="登录">
    </form>

2. 开发controller

@RequestMapping("user")
@Controller
public class UserController {

    //用户登陆的时候，需要进行安全验证
    @RequestMapping("/login")
    public String login(String username,String password){
        //获取主题对象
        Subject subject = SecurityUtils.getSubject();

        try {
            //把用户名密码封装成token，进行认证
            //登录的时候，会调用realm中（数据库）的数据进行比较，所以现在该区realm中进行认证了
            subject.login(new UsernamePasswordToken(username,password));
            return "redirect:/index.jsp";
        } catch (UnknownAccountException e) {
            e.printStackTrace();
            System.out.println("用户名错误!!");
        }catch (IncorrectCredentialsException e){
            e.printStackTrace();
            System.out.println("密码错误!!!");
        }
        return "redirect:/login.jsp";
    }
}

• 在认证过程中使用subject.login进行认证

3.开发realm中返回静态数据(未连接数据库)

public class CustomerRealm extends AuthorizingRealm {
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

        String s = token.getPrincipal().toString();
        if("xiaochen".equals(s)){
            return  new SimpleAuthenticationInfo(s,"123",this.getName());
        }
        return null;
    }
}

4.启动项目以realm中定义静态数据进行认证

• 认证功能没有md5和随机盐的认证就实现啦

退出认证

1.开发页面退出连接

2.开发controller

    //退出登录
    @RequestMapping("/logout")
    public String logout(){
        Subject subject = SecurityUtils.getSubject();
        subject.logout();
        return "redirect:/login.jsp";
    }

3.退出之后访问受限资源立即返回认证界面

MD5、Salt的认证实现(连接数据库)

1.创建数据表结构

0.开发注册界面

    <h1>用户注册</h1>
    <form action="${pageContext.request.contextPath}/user/register" method="post">
      用户名:<input type="text" name="username" > <br/>
      密码  : <input type="text" name="password"> <br>
      <input type="submit" value="立即注册">
    </form>

2.项目引入依赖

    <!--mybatis相关依赖-->
    <dependency>
      <groupId>org.mybatis.spring.boot</groupId>
      <artifactId>mybatis-spring-boot-starter</artifactId>
      <version>2.1.2</version>
    </dependency>
    
    <!--mysql-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.38</version>
    </dependency>
    
    
    <!--druid-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.19</version>
    </dependency>

3.配置application.properties配置文件

server.port=8888

# 应用的上下文路径，也可以称为项目路径，是构成url地址的一部分。 就可以直接以；localhost:8888/shiro/index.jsp直接访问
server.servlet.context-path=/shiro  
spring.application.name=shiro  

# 通过这两个配置把视图换成/和jsp
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/study?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
spring.datasource.username=root
spring.datasource.password=root

mybatis.type-aliases-package=com.cdl.entity
mybatis.mapper-locations=classpath:mapper/*.xml

4.创建entity

    @Data
    @Accessors(chain = true)
    @AllArgsConstructor
    @NoArgsConstructor
    public class User {
        private String  id;
        private String username;
        private String password;
        private String salt;
    }

5.创建DAO接口

    @Mapper
    public interface UserDAO {
        void save(User user);
    }

6.开发mapper配置文件

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.cdl.dao.UserDao">

    <insert id="save">
        insert into user values (#{id},#{username},#{password},#{salt})
    </insert>

</mapper>

7.开发service接口

    public interface UserService {
        //注册用户方法
        void register(User user);
    }

8.创建salt工具类

    public class SaltUtils {
        /**
         * 生成salt的静态方法
         * @param n
         * @return
         */
        public static String getSalt(int n){
            char[] chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567890!@#$%^&*()".toCharArray();
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < n; i++) {
                char aChar = chars[new Random().nextInt(chars.length)];
                sb.append(aChar);
            }
            return sb.toString();
        }
    }

9.开发service实现类

    @Service
    @Transactional
    public class UserServiceImpl implements UserService {
    
        @Autowired
        private UserDAO userDAO;
    
        @Override
        public void register(User user) {
            //处理业务调用dao
            //1.生成随机盐
            String salt = SaltUtils.getSalt(8);
            //2.将随机盐保存到数据
            user.setSalt(salt);
            //3.明文密码进行md5 + salt + hash散列
            Md5Hash md5Hash = new Md5Hash(user.getPassword(),salt,1024);
            user.setPassword(md5Hash.toHex());
            userDAO.save(user);
        }
    }

10.开发Controller

    @Controller
    @RequestMapping("user")
    public class UserController {
    
        @Autowired
        private UserService userService;
    
        /**
         * 用户注册
         */
        @RequestMapping("register")
        public String register(User user) {
            try {
                userService.register(user);
                return "redirect:/login.jsp";
            }catch (Exception e){
                e.printStackTrace();
                return "redirect:/register.jsp";
            }
        }
    }

11.启动项目进行注册--成功

开发数据库认证

0.开发DAO

    @Mapper
    public interface UserDAO {
    
        void save(User user);
    		//根据身份信息认证的方法
        User findByUserName(String username);
    }

1.开发mapper配置文件

    <select id="findByUserName" parameterType="String" resultType="User">
      select id,username,password,salt from user
      where username = #{username}
    </select>

2.开发Service接口

    public interface UserService {
        //注册用户方法
        void register(User user);
        //根据用户名查询业务的方法
        User findByUserName(String username);
    }

3.开发Service实现类

    @Service("userService")
    @Transactional
    public class UserServiceImpl implements UserService {
        @Autowired
        private UserDAO userDAO;
        @Override
        public User findByUserName(String username) {
            return userDAO.findByUserName(username);
        }
    }

4.开发在工厂中获取bean对象的工具类

    @Component
    public class ApplicationContextUtils implements ApplicationContextAware {
    
        private static ApplicationContext context;
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            this.context = applicationContext;
        }
    
    
        //根据bean名字获取工厂中指定bean 对象
        public static Object getBean(String beanName){
            return context.getBean(beanName);
        }
    }

5.修改自定义realm

@Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

        String s = token.getPrincipal().toString();

        //在工厂中获取service对象  因为Realm这个类没有注册到工厂中，所以拿不到工厂中的对象，所以要写一个工具类去拿工厂中的对象
        UserService userService = (UserService) ApplicationContextUtils.getBean("userService");

        User user = userService.findByUserName(s);
        //根据用户名查询密码进行验证
        if(!ObjectUtils.isEmpty(user)){
            //返回数据库信息
            return new SimpleAuthenticationInfo(user.getUsername(),user.getPassword(),
                    ByteSource.Util.bytes(user.getSalt()),this.getName());
        }
        return null;
    }

6.修改ShiroConfig中realm使用凭证匹配器以及hash散列

    @Bean
    public Realm getRealm(){
      CustomerRealm customerRealm = new CustomerRealm();
      //设置hashed凭证匹配器
      HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
      //设置md5加密
      credentialsMatcher.setHashAlgorithmName("md5");
      //设置散列次数
      credentialsMatcher.setHashIterations(1024);
      customerRealm.setCredentialsMatcher(credentialsMatcher);
      return customerRealm;
    }

授权实现

实现权限有三种方式，编程式，注解式，标签式（上面有说到），如果什么写，这不会进行权限验证

0.页面资源授权(以标签的形式授权)

<%@page contentType="text/html; UTF-8" pageEncoding="UTF-8" isELIgnored="false" %>
<%@taglib prefix="shiro" uri="http://shiro.apache.org/tags" %>
<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <h1>系统主页v1.0</h1>
    <a href="${pageContext.request.contextPath}/user/logout">退出用户</a>

    <ul>
        <shiro:hasAnyRoles name="user,admin">
            <li><a href="">用户管理</a>
                <ul>
                    <shiro:hasPermission name="user:add:*">
                        <li><a href="">添加</a></li>
                    </shiro:hasPermission>
                    <shiro:hasPermission name="user:delete:*">
                        <li><a href="">删除</a></li>
                    </shiro:hasPermission>
                    <shiro:hasPermission name="user:update:*">
                        <li><a href="">修改</a></li>
                    </shiro:hasPermission>
                    <shiro:hasPermission name="user:find:*">
                        <li><a href="">查询</a></li>
                    </shiro:hasPermission>
                </ul>
            </li>
        </shiro:hasAnyRoles>

        <shiro:hasRole name="admin">
            <li><a href="">商品管理</a> </li>
            <li><a href="">订单管理</a> </li>
            <li><a href="">物流管理</a> </li>
        </shiro:hasRole>
    </ul>

</body>
</html>

1.代码方式授权

@Controller
@RequestMapping("order")
public class OrderController {

    @RequestMapping("save")
    public String save(){

        //获取主题对象
        Subject subject = SecurityUtils.getSubject();

        //以代码方式控制权限
        if(subject.hasRole("admin")){
            System.out.println("保存订单");
        }else {
            System.out.println("无权访问");
        }
        return "redirect:/index.jsp";
    }
}

2.以注解的方式授权

• @RequiresRoles 用来基于角色进行授权
• @RequiresPermissions 用来基于权限进行授权

    @RequestMapping("save")
//    @RequiresRoles(value = {"user","admin"})  //以注解的形式控制权限  同时具有
    @RequiresPermissions("user:update:01")  //权限字符串
    public String save(){
        return "redirect:/index.jsp";
    }

授权数据持久化

3.创建数据库

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for t_pers
-- ----------------------------
DROP TABLE IF EXISTS `t_pers`;
CREATE TABLE `t_pers` (
  `id` int(6) NOT NULL AUTO_INCREMENT,
  `name` varchar(80) DEFAULT NULL,
  `url` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for t_role
-- ----------------------------
DROP TABLE IF EXISTS `t_role`;
CREATE TABLE `t_role` (
  `id` int(6) NOT NULL AUTO_INCREMENT,
  `name` varchar(60) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for t_role_perms
-- ----------------------------
DROP TABLE IF EXISTS `t_role_perms`;
CREATE TABLE `t_role_perms` (
  `id` int(6) NOT NULL,
  `roleid` int(6) DEFAULT NULL,
  `permsid` int(6) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for t_user
-- ----------------------------
DROP TABLE IF EXISTS `t_user`;
CREATE TABLE `t_user` (
  `id` int(6) NOT NULL AUTO_INCREMENT,
  `username` varchar(40) DEFAULT NULL,
  `password` varchar(40) DEFAULT NULL,
  `salt` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for t_user_role
-- ----------------------------
DROP TABLE IF EXISTS `t_user_role`;
CREATE TABLE `t_user_role` (
  `id` int(6) NOT NULL,
  `userid` int(6) DEFAULT NULL,
  `roleid` int(6) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

SET FOREIGN_KEY_CHECKS = 1;

4.创建dao方法

     //根据用户名查询所有角色
    User findRolesByUserName(String username);
    //根据角色id查询权限集合
    List<Perms> findPermsByRoleId(String id);

5.mapper实现

    <resultMap id="userMap" type="User">
      <id column="uid" property="id"/>
      <result column="username" property="username"/>
      <!--角色信息-->
      <collection property="roles" javaType="list" ofType="Role">
        <id column="id" property="id"/>
        <result column="rname" property="name"/>
      </collection>
    </resultMap>
    
    <select id="findRolesByUserName" parameterType="String" resultMap="userMap">
      SELECT u.id uid,u.username,r.id,r.NAME rname
      FROM t_user u
      LEFT JOIN t_user_role ur
      ON u.id=ur.userid
      LEFT JOIN t_role r
      ON ur.roleid=r.id
      WHERE u.username=#{username}
    </select>
    
    <select id="findPermsByRoleId" parameterType="String" resultType="Perms">
      SELECT p.id,p.NAME,p.url,r.NAME
      FROM t_role r
      LEFT JOIN t_role_perms rp
      ON r.id=rp.roleid
      LEFT JOIN t_perms p ON rp.permsid=p.id
      WHERE r.id=#{id}
    </select>

6.Service接口

    //根据用户名查询所有角色
    User findRolesByUserName(String username);
    //根据角色id查询权限集合
    List<Perms> findPermsByRoleId(String id);

7.Service实现

    @Override
    public List<Perms> findPermsByRoleId(String id) {
      return userDAO.findPermsByRoleId(id);
    }
    
    @Override
    public User findRolesByUserName(String username) {
      return userDAO.findRolesByUserName(username);
    }

8.修改自定义realm

@Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principal) {
        //获取登陆人的身份信息
        String s = principal.getPrimaryPrincipal().toString();
        //根据主身份信息获取角色信息和权限信息
        UserService userService = (UserService) ApplicationContextUtils.getBean("userService");
        User user = userService.findRolesByUserName(s);
        //赋值授权角色
        if(user.getRoles() != null){
            SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
            user.getRoles().forEach(role -> {
                simpleAuthorizationInfo.addRole(role.getName());

                //根据角色信息返回权限信息
                List<Perms> perms = userService.findPermsByRoleId(role.getId());
                if(perms != null){
                    perms.forEach(perm->{
                        simpleAuthorizationInfo.addStringPermission(perm.getName());
                    });
                }
            });
            return simpleAuthorizationInfo;
        }
        return null;

    }

9.启动测试

shiro优化（缓存）

使用CacheManager

1.Cache 作用

• Cache 缓存: 计算机内存中一段数据
• 作用: 用来减轻DB的访问压力,从而提高系统的查询效率
• 流程:
  

2.使用shiro中默认EhCache实现缓存

1.引入依赖

    <!--引入shiro和ehcache-->
    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-ehcache</artifactId>
      <version>1.5.3</version>
    </dependency>

2.开启缓存

 //3.创建自定义Realm
    @Bean
    public Realm getRealm(){
        CustomerRealm customerRealm = new CustomerRealm();
        //设置hashed凭证匹配器
        HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
        //设置md5加密
        credentialsMatcher.setHashAlgorithmName("md5");
        //设置散列次数
        credentialsMatcher.setHashIterations(1024);
        customerRealm.setCredentialsMatcher(credentialsMatcher);

        //开启缓存管理
        customerRealm.setCacheManager(new EhCacheManager());
        customerRealm.setCachingEnabled(true);//开启全局缓存
        customerRealm.setAuthenticationCachingEnabled(true); //开启认证缓存
        customerRealm.setAuthenticationCacheName("authenticationCache"); //给缓存起一个名字
        customerRealm.setAuthorizationCachingEnabled(true);//开启授权缓存
        customerRealm.setAuthorizationCacheName("authorizationCache");

        return customerRealm;
    }

3.启动刷新页面进行测试

• 注意:如果控制台没有任何sql展示说明缓存已经开启

shiro中使用Redis作为缓存实现

1.引入redis依赖

    <!--redis整合springboot-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

2.配置redis连接

    spring.redis.port=6379
    spring.redis.host=localhost
    spring.redis.database=0

3.启动redis服务

    ?  bin ls
    dump.rdb        redis-check-aof redis-cli       redis-server    redis.conf
    redis-benchmark redis-check-rdb redis-sentinel  redis-trib.rb
    ?  bin ./redis-server redis.conf

4.开发RedisCacheManager

//自定义shiro中的缓存管理器
public class RedisCacheManager implements CacheManager {

    //参数：认证或者是授权的缓存的名称
    @Override
    public <K, V> Cache<K, V> getCache(String cacheName) throws CacheException {
        return new RedisCache<K, V>();
    }
}

5.开RedisCache实现

//自定义redis缓存的实现
public class RedisCache<K, V> implements Cache<K, V> {

    @Override
    public V get(K k) throws CacheException {
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
        redisTemplate.setStringSerializer(new StringRedisSerializer());
        return (V) redisTemplate.opsForValue().get(k.toString());
    }

    @Override
    public V put(K k, V v) throws CacheException {
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
        redisTemplate.setStringSerializer(new StringRedisSerializer());
        redisTemplate.opsForValue().set(k.toString(),v);
        return null;
    }

    @Override
    public V remove(K k) throws CacheException {
        return null;
    }

    @Override
    public void clear() throws CacheException {

    }

    @Override
    public int size() {
        return 0;
    }

    @Override
    public Set<K> keys() {
        return null;
    }

    @Override
    public Collection<V> values() {
        return null;
    }
}

6.再次启动测试,发现可以成功放入redis缓存

加入验证码验证

开发页面加入验证码

加入验证码生产的帮助类

package com.cdl.utils;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Random;

/**
 *@创建人  
 *@创建时间  2018/11/27 17:36
 *@描述   验证码生成
 */
public class VerifyCodeUtils{

    //使用到Algerian字体，系统里没有的话需要安装字体，字体只显示大写，去掉了1,0,i,o几个容易混淆的字符
    public static final String VERIFY_CODES = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";
    private static Random random = new Random();


    /**
     * 使用系统默认字符源生成验证码
     * @param verifySize    验证码长度
     * @return
     */
    public static String generateVerifyCode(int verifySize){
        return generateVerifyCode(verifySize, VERIFY_CODES);
    }
    /**
     * 使用指定源生成验证码
     * @param verifySize    验证码长度
     * @param sources   验证码字符源
     * @return
     */
    public static String generateVerifyCode(int verifySize, String sources){
        if(sources == null || sources.length() == 0){
            sources = VERIFY_CODES;
        }
        int codesLen = sources.length();
        Random rand = new Random(System.currentTimeMillis());
        StringBuilder verifyCode = new StringBuilder(verifySize);
        for(int i = 0; i < verifySize; i++){
            verifyCode.append(sources.charAt(rand.nextInt(codesLen-1)));
        }
        return verifyCode.toString();
    }

    /**
     * 生成随机验证码文件,并返回验证码值
     * @param w
     * @param h
     * @param outputFile
     * @param verifySize
     * @return
     * @throws IOException
     */
    public static String outputVerifyImage(int w, int h, File outputFile, int verifySize) throws IOException{
        String verifyCode = generateVerifyCode(verifySize);
        outputImage(w, h, outputFile, verifyCode);
        return verifyCode;
    }

    /**
     * 输出随机验证码图片流,并返回验证码值
     * @param w
     * @param h
     * @param os
     * @param verifySize
     * @return
     * @throws IOException
     */
    public static String outputVerifyImage(int w, int h, OutputStream os, int verifySize) throws IOException{
        String verifyCode = generateVerifyCode(verifySize);
        outputImage(w, h, os, verifyCode);
        return verifyCode;
    }

    /**
     * 生成指定验证码图像文件
     * @param w
     * @param h
     * @param outputFile
     * @param code
     * @throws IOException
     */
    public static void outputImage(int w, int h, File outputFile, String code) throws IOException{
        if(outputFile == null){
            return;
        }
        File dir = outputFile.getParentFile();
        if(!dir.exists()){
            dir.mkdirs();
        }
        try{
            outputFile.createNewFile();
            FileOutputStream fos = new FileOutputStream(outputFile);
            outputImage(w, h, fos, code);
            fos.close();
        } catch(IOException e){
            throw e;
        }
    }

    /**
     * 输出指定验证码图片流
     * @param w
     * @param h
     * @param os
     * @param code
     * @throws IOException
     */
    public static void outputImage(int w, int h, OutputStream os, String code) throws IOException{
        int verifySize = code.length();
        BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
        Random rand = new Random();
        Graphics2D g2 = image.createGraphics();
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
        Color[] colors = new Color[5];
        Color[] colorSpaces = new Color[] { Color.WHITE, Color.CYAN,
                Color.GRAY, Color.LIGHT_GRAY, Color.MAGENTA, Color.ORANGE,
                Color.PINK, Color.YELLOW };
        float[] fractions = new float[colors.length];
        for(int i = 0; i < colors.length; i++){
            colors[i] = colorSpaces[rand.nextInt(colorSpaces.length)];
            fractions[i] = rand.nextFloat();
        }
        Arrays.sort(fractions);

        g2.setColor(Color.GRAY);// 设置边框色
        g2.fillRect(0, 0, w, h);

        Color c = getRandColor(200, 250);
        g2.setColor(c);// 设置背景色
        g2.fillRect(0, 2, w, h-4);

        //绘制干扰线
        Random random = new Random();
        g2.setColor(getRandColor(160, 200));// 设置线条的颜色
        for (int i = 0; i < 20; i++) {
            int x = random.nextInt(w - 1);
            int y = random.nextInt(h - 1);
            int xl = random.nextInt(6) + 1;
            int yl = random.nextInt(12) + 1;
            g2.drawLine(x, y, x + xl + 40, y + yl + 20);
        }

        // 添加噪点
        float yawpRate = 0.05f;// 噪声率
        int area = (int) (yawpRate * w * h);
        for (int i = 0; i < area; i++) {
            int x = random.nextInt(w);
            int y = random.nextInt(h);
            int rgb = getRandomIntColor();
            image.setRGB(x, y, rgb);
        }

        shear(g2, w, h, c);// 使图片扭曲

        g2.setColor(getRandColor(100, 160));
        int fontSize = h-4;
        Font font = new Font("Algerian", Font.ITALIC, fontSize);
        g2.setFont(font);
        char[] chars = code.toCharArray();
        for(int i = 0; i < verifySize; i++){
            AffineTransform affine = new AffineTransform();
            affine.setToRotation(Math.PI / 4 * rand.nextDouble() * (rand.nextBoolean() ? 1 : -1), (w / verifySize) * i + fontSize/2, h/2);
            g2.setTransform(affine);
            g2.drawChars(chars, i, 1, ((w-10) / verifySize) * i + 5, h/2 + fontSize/2 - 10);
        }

        g2.dispose();
        ImageIO.write(image, "jpg", os);
    }

    private static Color getRandColor(int fc, int bc) {
        if (fc > 255)
            fc = 255;
        if (bc > 255)
            bc = 255;
        int r = fc + random.nextInt(bc - fc);
        int g = fc + random.nextInt(bc - fc);
        int b = fc + random.nextInt(bc - fc);
        return new Color(r, g, b);
    }

    private static int getRandomIntColor() {
        int[] rgb = getRandomRgb();
        int color = 0;
        for (int c : rgb) {
            color = color << 8;
            color = color | c;
        }
        return color;
    }

    private static int[] getRandomRgb() {
        int[] rgb = new int[3];
        for (int i = 0; i < 3; i++) {
            rgb[i] = random.nextInt(255);
        }
        return rgb;
    }

    private static void shear(Graphics g, int w1, int h1, Color color) {
        shearX(g, w1, h1, color);
        shearY(g, w1, h1, color);
    }

    private static void shearX(Graphics g, int w1, int h1, Color color) {

        int period = random.nextInt(2);

        boolean borderGap = true;
        int frames = 1;
        int phase = random.nextInt(2);

        for (int i = 0; i < h1; i++) {
            double d = (double) (period >> 1)
                    * Math.sin((double) i / (double) period
                    + (6.2831853071795862D * (double) phase)
                    / (double) frames);
            g.copyArea(0, i, w1, 1, (int) d, 0);
            if (borderGap) {
                g.setColor(color);
                g.drawLine((int) d, i, 0, i);
                g.drawLine((int) d + w1, i, w1, i);
            }
        }

    }

    private static void shearY(Graphics g, int w1, int h1, Color color) {

        int period = random.nextInt(40) + 10; // 50;

        boolean borderGap = true;
        int frames = 20;
        int phase = 7;
        for (int i = 0; i < w1; i++) {
            double d = (double) (period >> 1)
                    * Math.sin((double) i / (double) period
                    + (6.2831853071795862D * (double) phase)
                    / (double) frames);
            g.copyArea(i, 0, 1, h1, 0, (int) d);
            if (borderGap) {
                g.setColor(color);
                g.drawLine(i, (int) d, i, 0);
                g.drawLine(i, (int) d + h1, i, h1);
            }

        }

    }
    public static void main(String[] args) throws IOException {
        //获取验证码
        String s = generateVerifyCode(4);
        //将验证码放入图片中
        outputImage(260,60,new File("/Users/chenyannan/Desktop/安工资料/aa.jpg"),s);
        System.out.println(s);
    }
}

开发控制器

      @RequestMapping("getImage")
      public void getImage(HttpSession session, HttpServletResponse response) throws IOException {
        //生成验证码
        String code = VerifyCodeUtils.generateVerifyCode(4);
        //验证码放入session
        session.setAttribute("code",code);
        //验证码存入图片
        ServletOutputStream os = response.getOutputStream();
        response.setContentType("image/png");
        VerifyCodeUtils.outputImage(220,60,os,code);
      }

在shiro模块放行验证码请求

开发页面

<form action="${pageContext.request.contextPath}/user/login" method="post">
    用户名:<input type="text" name="username" > <br/>
    密码  : <input type="text" name="password"> <br>
    请输入验证码: <input type="text" name="code"><img src="${pageContext.request.contextPath}/user/getImage" ><br>
    <input type="submit" value="登录">
</form>

验证码生成成功

修改认证流程,在验证码校验成功之后，在进行认证

      @RequestMapping("login")
          public String login(String username, String password,String code,HttpSession session) {
              //比较验证码
              String codes = (String) session.getAttribute("code");
              try {
                  if (codes.equalsIgnoreCase(code)){
                      //获取主体对象
                      Subject subject = SecurityUtils.getSubject();
                          subject.login(new UsernamePasswordToken(username, password));
                          return "redirect:/index.jsp";
                  }else{
                      throw new RuntimeException("验证码错误!");
                  }
              } catch (UnknownAccountException e) {
                  e.printStackTrace();
                  System.out.println("用户名错误!");
              } catch (IncorrectCredentialsException e) {
                  e.printStackTrace();
                  System.out.println("密码错误!");
              }catch (Exception e){
                  e.printStackTrace();
                  System.out.println(e.getMessage());
              }
              return "redirect:/login.jsp";
          }

jsp常用标签

# 展示身份信息
<h1><shiro:principal/></h1>
# 认证之后的信息
    <shiro:authenticated>
        认证之后展示内容 <br>
    </shiro:authenticated>
    <shiro:notAuthenticated>
        没有认证在之后展示内容
    </shiro:notAuthenticated>
    

Shiro整合springboot之thymeleaf权限控制

1.引入扩展依赖

    <dependency>
        <groupId>com.github.theborakompanioni</groupId>
        <artifactId>thymeleaf-extras-shiro</artifactId>
        <version>2.0.0</version>
    </dependency>

2.页面中引入命名空间

xmlns:shiro="http://www.pollix.at/thymeleaf/shiro"

    <html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org"
          xmlns:shiro="http://www.pollix.at/thymeleaf/shiro">

3.常见权限控制标签使用

    <!-- 验证当前用户是否为“访客”，即未认证（包含未记住）的用户。 -->
    <p shiro:guest="">Please <a href="login.html">login</a></p>
    
    
    <!-- 认证通过或已记住的用户。 -->
    <p shiro:user="">
        Welcome back John! Not John? Click <a href="login.html">here</a> to login.
    </p>
    
    <!-- 已认证通过的用户。不包含已记住的用户，这是与user标签的区别所在。 -->
    <p shiro:authenticated="">
        Hello, <span shiro:principal=""></span>, how are you today?
    </p>
    <a shiro:authenticated="" href="updateAccount.html">Update your contact information</a>
    
    <!-- 输出当前用户信息，通常为登录帐号信息。 -->
    <p>Hello, <shiro:principal/>, how are you today?</p>
    
    
    <!-- 未认证通过用户，与authenticated标签相对应。与guest标签的区别是，该标签包含已记住用户。 -->
    <p shiro:notAuthenticated="">
        Please <a href="login.html">login</a> in order to update your credit card information.
    </p>
    
    <!-- 验证当前用户是否属于该角色。 -->
    <a shiro:hasRole="admin" href="admin.html">Administer the system</a><!-- 拥有该角色 -->
    
    <!-- 与hasRole标签逻辑相反，当用户不属于该角色时验证通过。 -->
    <p shiro:lacksRole="developer"><!-- 没有该角色 -->
        Sorry, you are not allowed to developer the system.
    </p>
    
    <!-- 验证当前用户是否属于以下所有角色。 -->
    <p shiro:hasAllRoles="developer, 2"><!-- 角色与判断 -->
        You are a developer and a admin.
    </p>
    
    <!-- 验证当前用户是否属于以下任意一个角色。  -->
    <p shiro:hasAnyRoles="admin, vip, developer,1"><!-- 角色或判断 -->
        You are a admin, vip, or developer.
    </p>
    
    <!--验证当前用户是否拥有指定权限。  -->
    <a shiro:hasPermission="userInfo:add" href="createUser.html">添加用户</a><!-- 拥有权限 -->
    
    <!-- 与hasPermission标签逻辑相反，当前用户没有制定权限时，验证通过。 -->
    <p shiro:lacksPermission="userInfo:del"><!-- 没有权限 -->
        Sorry, you are not allowed to delete user accounts.
    </p>
    
    <!-- 验证当前用户是否拥有以下所有角色。 -->
    <p shiro:hasAllPermissions="userInfo:view, userInfo:add"><!-- 权限与判断 -->
        You can see or add users.
    </p>
    
    <!-- 验证当前用户是否拥有以下任意一个权限。  -->
    <p shiro:hasAnyPermissions="userInfo:view, userInfo:del"><!-- 权限或判断 -->
        You can see or delete users.
    </p>
    <a shiro:hasPermission="pp" href="createUser.html">Create a new User</a>

4.加入shiro的方言配置

• 页面标签不起作用一定要记住加入方言处理

    @Bean(name = "shiroDialect")
    public ShiroDialect shiroDialect(){
      return new ShiroDialect();
    }

10.Springboot(十)

原文：https://www.cnblogs.com/cdlszl/p/14192540.html