shiro延伸

shiro延伸

spring-异常处理

关于异常处理有四种方法：

第一种：使用SimpleMappingExceptionResolver解析器

　　在mvc的配置文件中配置异常处理解析器

异常处理解析器
    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        <!--默认的错误视图-->
        <property name="defaultErrorView" value="error"/>
        <!--异常属性-->
        <property name="exceptionAttribute" value="ex">
            <!--<props>-->
                <!--<prop key="异常类型1">-->
                    <!--error1-->
                <!--</prop>-->
                <!--<prop key="异常类型2">-->
                    <!--error2-->
                <!--</prop>-->
            <!--</props>-->
        </property>
    </bean>

第二种：

　　新建一个BaseController类，并在方法前使用@ExceptionHandler注解

package com.aaa.controller;

/**
 * @Author 刘其佳
 * 2019/8/14 -- 10:56
 * @Version 1.0
 */

import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authz.AuthorizationException;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ExceptionHandler;

/**
 * 异常处理的第二种方法
 */
public class BaseController {
    @ExceptionHandler(RuntimeException.class)
    public String handler1(RuntimeException ex, Model model){
        if(ex instanceof AuthenticationException){
            System.out.println("处理方案1");
            model.addAttribute("ex",ex);
            return "error";
        }else if(ex instanceof AuthorizationException){
            System.out.println("处理方案2");
            model.addAttribute("ex",ex);
            return "error";
        }
        return "error";
    }
}

　　控制器继承BaseController

package com.aaa.controller;

import com.aaa.service.UserService;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @Author 刘其佳
 * 2019/8/12 -- 16:43
 * @Version 1.0
 */
@Controller
//@RequestMapping("/user")
public class UserController extends BaseController{
    public class UserController{
    @Autowired
    private  UserService userService;
    //获取日志对象
    private static final transient Logger log = LoggerFactory.getLogger(UserController.class);

    @RequestMapping("/login")
    public String login(String username,String password){
        //创建subject
        Subject currentUser= SecurityUtils.getSubject();
        // currentUser.isAuthenticated()当前用户是否被认证
        // 如果当前用户被认证了，说明用户还是处于登录状态
        if (!currentUser.isAuthenticated()) {
            //用户名密码令牌：将表单中的用户名和密码封装进token中
            UsernamePasswordToken token = new UsernamePasswordToken(username, password);
            //记住我
//            token.setRememberMe(true);
            try {
                // 调用subject中的login方法来进行匹配用户是否可以登录成功
                // login方法的参数需要接收shiro的UsernamePasswordToken类型
                currentUser.login(token);//找到xml文件中id=shiroFilter对应的realm
            } catch (UnknownAccountException uae) {//账号不存在
                log.info("There is no user with username of " + token.getPrincipal());
                throw new UnknownAccountException("账号不存在");
//                return "login";
            } catch (IncorrectCredentialsException ice) {//密码错误
                log.info("Password for account " + token.getPrincipal() + " was incorrect!");
                throw new IncorrectCredentialsException("密码错误");
//                return "login";
            } catch (LockedAccountException lae) {//账号锁死
                log.info("The account for username " + token.getPrincipal() + " is locked.  " +
                        "Please contact your administrator to unlock it.");
            }
            catch (AuthenticationException ae) {
            }
        }
        return "front/ok";
    }

    @GetMapping("/delete/{id}")
    @ResponseBody
    @RequiresPermissions("emp/delete")
    public boolean delete(@PathVariable("id") Integer id){
        int result=userService.deleteByPrimaryKey(id);
        return result>0?true:false;
    }
}

第三种：使用 @ControllerAdvice+ @ ExceptionHandler 注解 （推荐使用）

　　同步方式：

package com.aaa.controller;

import com.aaa.entity.Result;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authz.AuthorizationException;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @Author 刘其佳
 * 2019/8/14 -- 11:08
 * @Version 1.0
 */

//处理异常的第三种方法之同步方式
    @ControllerAdvice
public class ExceptionController {
    @ExceptionHandler(RuntimeException.class)
    public String handler1(RuntimeException ex, Model model){
        if(ex instanceof AuthenticationException){
            System.out.println("处理方案1");
            model.addAttribute("ex",ex);
            return "error";
        }else if(ex instanceof AuthorizationException){
            System.out.println("处理方案2");
            model.addAttribute("ex",ex);
            return "error";
        }
        return "error";
    }

　　异步方式：返回的是json数据

　　步骤：1、自定义实体类型（状态码，错误信息）

　　　　　2、处理异常时返回该类型的数据

实体类：

package com.aaa.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

/**
 * @Author 刘其佳
 * 2019/8/14 -- 11:12
 * @Version 1.0
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class Result {
    private Integer statusCode;
    private String message;
}

此处说明一下，该实体类使用了lombok的注解：

　　首先导入Lombok的jar包：

    <!--lombok:简化实体类的编写-->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.8</version>
    </dependency>

　　然后在setting中的plugins下载Lombok的插件

异常处理：

//处理异常的第三种方法之异步方式
    @ExceptionHandler(RuntimeException.class)
    @ResponseBody
    public Result handler1(RuntimeException ex){
        Result result=new Result();
        if(ex instanceof AuthenticationException){
            result.setStatusCode(501);
            result.setMessage("认证异常："+ex.getMessage());
            System.out.println("处理方案1");
        }else if(ex instanceof AuthorizationException){
            result.setStatusCode(502);
            result.setMessage("授权异常："+ex.getMessage());
            System.out.println("处理方案2");
        }
        return result;
    }

第四种方法：

　　实现HandlerExceptionResolver接口

---

定时任务

 借助Scheduled来实现定时任务

1、配置注解

4     <!--启用定时任务-->
    <task:annotation-driven/>

 2、创建定时任务

package com.aaa.controller;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Controller;

/**
 * @Author 刘其佳
 * 2019/8/14 -- 17:00
 * @Version 1.0
 */

@Controller
public class SchController {
　　　　//每隔5秒执行一次
    @Scheduled(cron = "0/5 * * * * ?")
    public static void task() {
        System.out.println("每一个不曾起舞的日子，都是对生命的辜负");
    }
}

 

对于Scheduled属性的说明：

字段	允许值	允许的特殊符号
秒	0-59	,-*/
分	0-59	,-*/
小时	0-23	,-*/
日期	1-31	,-*?/LWC
月份	1-12	,-*/
星期	0-7或SUN-SAT 0 7是SUN	,-*?/LC#

 特殊符号的释义如下：

特殊符号	代表含义
,	枚举
-	区间
*	任意
/	步长
?	日/星期冲突匹配
L	最后
W	工作日
C	和Calendar联系后计算过的值
#	星期 4#2 第2个星期四

 

示例：

　　0 0 0 * * * -- 每天零时执行一次
　　0 0/15 14,18 * * ? -- 每天14点整和18点整，每隔15分钟执行一次
　　0 15 10 ? * 1-6 -- 每个月的周一到周六 10:15分执行一次
　　0 0 2 ? * 6L -- 每个月的最后一个周六凌晨2点执行一次
　　0 0 2 LW * ? -- 每个月的最后一个工作日凌晨2点执行一次
　　0 0 2-4 ? * 1#1 -- 每个月的第一个周一凌晨2点到4点期间，每个整点都执行一次

---

补充注解：

 关于@ResponseBody和@RequestBody的区别：

正常情况下，在控制成的方法一般返回字符串，然后根据配置文件中相关配置，为返回的字符串加上响应的前缀和后缀，组成一个路径；

但是，当在方法前加上@responseBody，返回的是json格式的数据，并不能跳转。即@ResponseBody:将数据转换成json并输出到响应流中

@ResponseBody:

@GetMapping("/{empno}")
    @ResponseBody
    public Emp queryById( @PathVariable("empno") Integer empno){
        return empService.selectByPrimaryKey(empno);
    }

而@ResponseBody:将请求中的json数据转换成Java对象，一般用来处理复杂类型的数据；

@ResponseBody:

//    requestBody测试
    function test1() {
        //数组
        var emps=[];
        emps.push({job:"经理1",hiredate:"2018-1-1"});
        emps.push({job:"经理2",hiredate:"2018-1-2"});
        emps.push({job:"经理3",hiredate:"2018-1-3"});
        $.ajax({
            type:"post",
            url:"${pageContext.request.contextPath}/emp/test1",
            data:JSON.stringify(emps),//转成json的字符串传过去
            contentType:'application/json',//内容的类型是：json数据
            success:function (data) {
                alert(data);
            },
            error:function (msg) {
                alert('test1函数发生错误:'+msg);
            }
        })
    }

//在控制层的方法中：
    @RequestMapping("/test1")
    @ResponseBody
    public String test1(@RequestBody List<Emp> emps){//借用@RequestBody将传过来的json转换成Emp对象类型
        System.out.println(emps);
        return "ok";
    }

 在进行@RequestBody的测试中，Ajax中将一个Emp对象转换成json格式，再作为参数传递：

注意书写：1、JSON.stringify(emps)：转换成json格式的字符串类型

　　　　　2、contentType:'application/json'：声明一下内容的类型为json格式数据

---

shiro--rememberMe

 在shiro中有一个属性为setRememberMe();即将当前登录用户的信息保存进cookie中；然后可以在shiro的配置文件中指定

如果将信息保存进cookie中了，关闭浏览器再次打开次地址，可以在不登录的情况下访问定义为user的路径（关闭浏览器不将cookie清空），

但是如果注销了当前用户的话（在shiro的配置文件里可以定义某路径的属性为logout，即为注销），那么会讲cookie清空。

  先在shiro的配置文件中配置cookie

<!--+++++++++++++++++ 配置cookies -++++++++++++++++++-->
    <bean id="rememberCookies" class="org.apache.shiro.web.servlet.SimpleCookie">
        <constructor-arg value="rememberMe"></constructor-arg>
        <property name="httpOnly" value="true"></property>
        <property name="maxAge" value="#{60*60*24}"></property>
    </bean>
    <!--++++++++++++++++配置记住我管理器+++++++++++++++++++++-->
    <bean id="rememberMeManager" class="org.apache.shiro.web.mgt.CookieRememberMeManager">
        <property name="cipherKey" value="#{T(org.apache.shiro.codec.Base64).decode('6ZmI6I2j5Y+R5aSn5ZOlAA==')}"/>
        <property name="cookie" ref="rememberCookies"/>
    </bean>

 在shiro中的安全管理器中进行声明

<!--+++++++++++++++++++安全管理器+++++++++++++++-->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <!--缓存管理器-->
        <property name="cacheManager" ref="cacheManager"/>

        <!--会话的模式；native：本地-->
        <property name="sessionMode" value="native"/>

        <!--配置realm-->
        <property name="realm" ref="myRealm"/>

        <!--rememberMe管理器-->
        <property name="rememberMeManager" ref="rememberMeManager"/>
    </bean>

 定义路径

<!--filterChainDefinitions：过滤器的规则声明-->
        <property name="filterChainDefinitions">
            <value>
                <!--对某些路径进行何种方式的验证，存在先后顺序，不会覆盖，有重复声明的话按照先声明的来-->
                <!--anon:匿名过滤器，不需要登录     authc:需要进行认证登录
                    uesr:使用了rememberMe后可以直接进入此路径-->
                /index.jsp = anon
                /emp/delete = anon
                /logout=logout
                /*.jar = anon
                /common/**=anon
                /static/** =anon
                /emp/**=authc
                /admin/**=authc
                /user1/**=user
            </value>
        </property>

package com.aaa.controller;

import com.aaa.service.UserService;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @Author 刘其佳
 * 2019/8/12 -- 16:43
 * @Version 1.0
 */
@Controller
//@RequestMapping("/user")
    public class UserController{
    @Autowired
    private  UserService userService;
    //获取日志对象
    private static final transient Logger log = LoggerFactory.getLogger(UserController.class);

    @RequestMapping("/login")
    public String login(String username,String password,String remFlag){
        //创建subject
        Subject currentUser= SecurityUtils.getSubject();
        // currentUser.isAuthenticated()当前用户是否被认证
        // 如果当前用户被认证了，说明用户还是处于登录状态
        if (!currentUser.isAuthenticated()) {
            //用户名密码令牌：将表单中的用户名和密码封装进token中
            UsernamePasswordToken token = new UsernamePasswordToken(username, password);
            //记住我
            41                 token.setRememberMe(true);
43             try {
                // 调用subject中的login方法来进行匹配用户是否可以登录成功
                // login方法的参数需要接收shiro的UsernamePasswordToken类型
                currentUser.login(token);//找到xml文件中id=shiroFilter对应的realm
            } catch (UnknownAccountException uae) {//账号不存在
                log.info("There is no user with username of " + token.getPrincipal());
                throw new UnknownAccountException("账号不存在");
//                return "login";
            } catch (IncorrectCredentialsException ice) {//密码错误
                log.info("Password for account " + token.getPrincipal() + " was incorrect!");
                throw new IncorrectCredentialsException("密码错误");
//                return "login";
            } catch (LockedAccountException lae) {//账号锁死
                log.info("The account for username " + token.getPrincipal() + " is locked.  " +
                        "Please contact your administrator to unlock it.");
                throw new LockedAccountException("账号锁死");
            }
            catch (AuthenticationException ae) {
                log.info(("The account form username"+token.getPrincipal()+"is locked!"));
                throw new AuthenticationException("账号锁死");
            }
        }
        return "front/ok";
    }

    @GetMapping("/delete/{id}")
    @ResponseBody
    @RequiresPermissions("emp/delete")
    public boolean delete(@PathVariable("id") Integer id){
        int result=userService.deleteByPrimaryKey(id);
        return result>0?true:false;
    }
}

---

shiro的多次登录错误下账号锁死

思路：利用缓存记录登录的信息，如果错误次数达到指定数，就抛出异常

实现：

1、在资源文件目录下新建一个定义缓存的xml:ehcache.xml，定义缓存的相关信息

　　正常情况下的默认缓存是：

<!-- 默认缓存 -->
    <defaultCache
            maxEntriesLocalHeap="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            maxEntriesLocalDisk="10000000"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU"/>

　　自定义缓存

 <!-- 登录记录缓存 锁定10分钟 -->
    <cache name="passwordRetryCache"
           maxEntriesLocalHeap="2000"
           eternal="false"
           timeToIdleSeconds="360"
           timeToLiveSeconds="360"
           overflowToDisk="false"
           statistics="true">
    </cache>

以上属性的含义：

maxEntriesLocalHeap：是用来限制当前缓存在堆内存上所能保存的最大元素数量
eternal:false 设定缓存的elemen是否永远不过期
timeToLiveSeconds:对象存活时间，指对象从创建到失效所需要的时间。只对eternal为false的有效。默认值为0，表示一直可以访问。（单位：秒）
timeToIdleSeconds:对象空闲时，指对象在多长时间没有被访问就会失效。只对eternal为false的有效。默认值为0。（单位：秒）
新定义一个类

package com.aaa.credentials;

import com.aaa.entity.Result;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.ExcessiveAttemptsException;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheManager;

import java.util.concurrent.atomic.AtomicInteger;

public class MyMatcher extends HashedCredentialsMatcher {

    //Map:key,value
    //key:存用户名 value:次数
    private Cache<String, AtomicInteger> passwordCache;

    public MyMatcher(CacheManager cacheManager) {
        this.passwordCache = cacheManager.getCache("passwordRetryCache");
    }

    //密码匹配
    @Override
    public boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) {
        //获取用户名
        String username= (String) token.getPrincipal();
        //先去缓存中查找是否有该信息
        AtomicInteger retryCount= passwordCache.get(username);
        //第一次是null
        if(retryCount==null){
            //初始话：0
            retryCount=new AtomicInteger(0);
            //存入缓存中
            passwordCache.put(username,retryCount);
        }
        //在retryCount上增加1,并获取该值，当第3次仍然输入错误则锁死账号
        if(retryCount.incrementAndGet()>2){
            throw new ExcessiveAttemptsException("该账号已锁定");
        }
        //密码匹配
        boolean matcher=super.doCredentialsMatch(token,info);
        //如果登录成功
        if(matcher){
            //清空缓存数据
            passwordCache.remove(username);
        }
        return matcher;
    }
}

控制类中

package com.aaa.controller;

import com.aaa.service.UserService;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @Author 刘其佳
 * 2019/8/12 -- 16:43
 * @Version 1.0
 */
@Controller
//@RequestMapping("/user")
//public class UserController extends BaseController{
    public class UserController{
    @Autowired
    private  UserService userService;
    //获取日志对象
    private static final transient Logger log = LoggerFactory.getLogger(UserController.class);

    @RequestMapping("/login")
    public String login(String username,String password,String remFlag){
        //创建subject
        Subject currentUser= SecurityUtils.getSubject();
        // currentUser.isAuthenticated()当前用户是否被认证
        // 如果当前用户被认证了，说明用户还是处于登录状态
        if (!currentUser.isAuthenticated()) {
            //用户名密码令牌：将表单中的用户名和密码封装进token中
            UsernamePasswordToken token = new UsernamePasswordToken(username, password);
            //记住我(如果有值，就存入cookie)
            if(remFlag.equals("1")){
                token.setRememberMe(true);
            }
            try {
                // 调用subject中的login方法来进行匹配用户是否可以登录成功
                // login方法的参数需要接收shiro的UsernamePasswordToken类型
                currentUser.login(token);//找到xml文件中id=shiroFilter对应的realm
            } catch (UnknownAccountException uae) {//账号不存在
                log.info("There is no user with username of " + token.getPrincipal());
                throw new UnknownAccountException("账号不存在");
//                return "login";
            } catch (IncorrectCredentialsException ice) {//密码错误
                log.info("Password for account " + token.getPrincipal() + " was incorrect!");
                throw new IncorrectCredentialsException("密码错误");
//                return "login";
            } catch (LockedAccountException lae) {//账号锁死
                log.info("The account for username " + token.getPrincipal() + " is locked.  " +
                        "Please contact your administrator to unlock it.");
                throw new LockedAccountException("账号锁死");
            }
            catch (AuthenticationException ae) {
                log.info(("The account form username"+token.getPrincipal()+"is locked!"));
                throw new AuthenticationException("账号锁死");
            }
        }
        return "front/ok";
    }

    @GetMapping("/delete/{id}")
    @ResponseBody
    @RequiresPermissions("emp/delete")
    public boolean delete(@PathVariable("id") Integer id){
        int result=userService.deleteByPrimaryKey(id);
        return result>0?true:false;
    }
}

realm：

package com.aaa.realm;

import com.aaa.service.UserService;
import org.apache.shiro.authc.*;
import org.apache.shiro.crypto.hash.SimpleHash;
import org.apache.shiro.realm.AuthenticatingRealm;
import org.apache.shiro.util.ByteSource;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @Author 刘其佳
 * 2019/8/12 -- 16:28
 * @Version 1.0
 */


public class MyRealm extends AuthenticatingRealm {

    @Autowired
    private UserService userService;

    /**
     * @param authenticationToken:封装的身份信息（表单中传过来的）
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        /**
         * 1、获取subject传递过来的token
         * 2、根据token的用户名找到数据库中对应的密码
         * 3、返回认证对象
         */
        UsernamePasswordToken usernamePasswordToken= (UsernamePasswordToken) authenticationToken;
        //获取令牌中的用户名
        String username=usernamePasswordToken.getUsername();
        //连接数据库根据用户名查询密码
        String password=userService.selectByName(username);
//        加盐
        ByteSource salt=ByteSource.Util.bytes(username);
        //返回认证信息:最后一个参数是当前realm的名字，两种写法
//        SimpleAuthenticationInfo info=new SimpleAuthenticationInfo(username,password,"MyRealm");
        SimpleAuthenticationInfo info=new SimpleAuthenticationInfo(username,password,salt,getName());


        return info;
    }

    public static void main(String[] args){
        //盐：salt
        String username="admin";
        String password="123456";
        ByteSource salt=ByteSource.Util.bytes(username);
        SimpleHash simpleHash=new SimpleHash("MD5",password,salt);
        String str=simpleHash.toHex();
        System.out.println(str);
    }
}