Shiro框架-----用来实现认证和授权的操作

<!--1.Shiro处理认证授权逻辑的对象-->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <!--安全管理器-->
        <property name="securityManager" ref="securityManager"/>


        <!--设置Shiro的过滤器-->

        <!--
          过滤的路径问题：
            /index.jsp ：  准确拦截/index.jsp页面
            /user/*  ： 模糊匹配，拦截user根目录下的所有资源（代表一级目录）
            /user/**  : 模糊匹配，拦截user目录下的所有资源（代表任意级目录）

          1. 认证相关的过滤器
             anon: 匿名过滤器，不用认证也可以访问该资源（必须放在authc的前面）
             authc：认证过滤器，必须认证成功才可以访问该资源，如果认证不成功，会自动跳转到login.jsp页面（可以通过loginUrl属性更新登录页面）
        -->
        <property name="filterChainDefinitions">
            <value>
                /css/**=anon
                /img/**=anon
                /make/**=anon
                /plugins/**=anon
                /login.do=anon
                /**=authc
            </value>
        </property>

        <!--修改shrio默认登录页面-->
        <property name="loginUrl" value="/login.jsp"/>

    </bean>

/**
     * 登录方法
     *  1)URL: http://localhost:8080/login.do
     *  2)参数：email=eric&password=123
     *  3）返回：/WEB-INF/pages/home/main.jsp
     */
    @RequestMapping("/login")
    public String login(String email,String password){
        //1.判断是否为空
        if(StringUtils.isEmpty(email) || StringUtils.isEmpty(password)){
            request.setAttribute("error","邮箱和密码不能为空");
            //手动转发到login.jsp页面
            return "forward:/login.jsp";
        }
　　//-----------------------------------------------------一以下是正常做法--------------------------------------------------------
        /*//2.判断email是否存在
        User loginUser = userService.findByEmail(email);

        //3 email不存在，提示"用户名不存在"
        if(loginUser==null){
            request.setAttribute("error","用户名不存在");
            //手动转发到login.jsp页面
            return "forward:/login.jsp";
        }

        //4 email存在，继续判断password是否正确
        if(loginUser.getPassword().equals(password)){
            //5. password正确，登录成功，保存用户数据到session域中，跳转到主页
            session.setAttribute("loginUser",loginUser);

            //查询当前用户拥有的菜单（模块）
            List<Module> menuList = moduleService.findModuleByUser(loginUser);
            //去除重复元素
            removeDuplicate(menuList);
            //菜单必须存入session域
            session.setAttribute("menus",menuList);


            // 路径： /WEB-INF/pages/home/main.jsp
            return "home/main";
        }else{
            //6.password不正确，提示"密码错误"
            request.setAttribute("error","密码错误");
            //手动转发到login.jsp页面
            return "forward:/login.jsp";
        }*/

//---------------------------------------------------以上是正常做法---------------------------------------------------
        //使用Shiro的登录认证逻辑

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

        //2.UsernamePasswordToken 封装需要认证的信息（用户名和密码）
        UsernamePasswordToken token = new UsernamePasswordToken(email,password);

        //3.调用Subject的login方法进行认证
        //4.判断login方法有无异常，有异常代表认证失败，无异常代表认证成功
        try {
            subject.login(token);

            //无异常代表认证成功

            //5.从Shiro的Subject中获取登录用户对象:  subject.getPrincipal()
            User loginUser = (User)subject.getPrincipal();

            //把登录用户对象存入session域 （注意：这里存入的loginUser对象，不是给Shiro使用的，是给我们自己业务使用的）
            session.setAttribute("loginUser",loginUser);

            //查询当前用户拥有的菜单（模块）
            List<Module> menuList = moduleService.findModuleByUser(loginUser);
            //去除重复元素
            //若是已经在sql语句那里加了distinct去重，就不需要这个了
            removeDuplicate(menuList);
            //菜单必须存入session域
            session.setAttribute("menus",menuList);

            //跳转到主页
            return "home/main";
        } catch (UnknownAccountException e) {  //UnknownAccountException: 该异常代表用户名不存在
            request.setAttribute("error","Shrio：用户名不存在");
            return "forward:/login.jsp";
        } catch (IncorrectCredentialsException e) {  //IncorrectCredentialsException: 该异常代表密码错误
            request.setAttribute("error","Shrio：密码输入有误");
            return "forward:/login.jsp";
        } catch (Exception e) {  //其他异常
            request.setAttribute("error","Shrio：服务器错误");
            return "forward:/login.jsp";
        }

    }

/**
 * 自定义Realm
 */
public class AuthRealm extends AuthorizingRealm{
    @Autowired
    private UserService userService;

    //授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("执行授权方法...");
        return null;
    }

    //认证 (subject.login(token)方法固定执行doGetAuthenticationInfo方法)
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //System.out.println("执行认证方法...");

        //1.判断用户名是否存在
        //token传给了AuthenticationToken
        UsernamePasswordToken token = (UsernamePasswordToken)authenticationToken;
        String email = token.getUsername();

        User loginUser = userService.findByEmail(email);
        if(loginUser==null){
            //用户名不存在
            //我们只需要return null即可，Shiro底层判断为null则抛出UnKnowAccountException异常
            return null;
        }

        //2.返回数据库保存密码给Shiro，让Shiro判断密码是否正确
        /**
         * Shiro底层获取SimpleAuthenticationInfo的参数，例如获取password判断和用户输入的密码是否一致
         *    1）如果密码不一致，抛出IncorrectCredentialsException异常
         *    2）如果密码一致， 把principal存入session域
          */    

        //SimpleAuthenticationInfo： 封装认证数据对象
        /**
         * 参数一： principal  登录用户对象，用于Subject.getPrincipal()方法获取
         * 参数二： password   数据库的密码
         * 参数三： realm的别名， 在多个Realm的情况下使用，用于区分用户表的。只有一张用户表不需要别名
         */
        return new SimpleAuthenticationInfo(loginUser,loginUser.getPassword(),"");
    }
}

 <!--创建Shiro自带的凭证匹配器-->
    <bean id="credentialsMatcher" class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
        <!--指定需要加密的算法名称-->
        <property name="hashAlgorithmName" value="md5"/>
    </bean>

public class Demo {

    public static void main(String[] args) {
        //1.原密码
        String password = "123";

        //2.盐
        String salt = "lw@export.com";

        //3.加盐加密
        /**
         * 参数一：原密码
         * 参数二：盐
         * 参数三（可选）：加密次数，默认1次
         */
        Md5Hash md5Hash = new Md5Hash(password,salt);

        System.out.println(md5Hash.toString());
    }

}

public class CustomCredentialsMatcher extends SimpleCredentialsMatcher{

    /**
     * 完成密码判断的逻辑
     * @param token  包含了用户输入的密码
     * @param info   包含了数据库的密码
     * @return 密码判断结果
     *       true： 代表数据库的密码和用户输入的密码一致的
     *       false：代表数据库的密码和用户输入的密码不一致的
     */
    
    //打个do就能出来这个方法
    @Override
    public boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) {

        //1.获取用户输入的密码
        UsernamePasswordToken userToken = (UsernamePasswordToken)token;
        
        //UsernamePasswordToken 是用来封装用户名和密码,用户名用字符串封装,密码用字符数组封装
        //userToken.getPassword()['1','2','3']
        String userPassword = new String(userToken.getPassword()); // ['1','2','3']

        //获取用户邮箱
        String email = userToken.getUsername();

        //2.对用户输入的密码进行加盐加密
        Md5Hash md5Hash = new Md5Hash(userPassword,email);
        String encodePwd = md5Hash.toString();

        //3.获取数据库的密码
        String dbPwd = (String)info.getCredentials();

        //4.判断数据库的密 码和第二步产生的密码是否一致，一致返回true，不一致返回false
        return dbPwd.equals(encodePwd);
    }
}

 <!--3.配置Realm-->
    <bean id="myRealm" class="cn.itcast.web.shiro.AuthRealm">
        <!--配置凭证匹配器-->
        <property name="credentialsMatcher" ref="credentialsMatcher"/>
    </bean>
    
    <!--创建自定义凭证匹配器-->
    <bean id="credentialsMatcher" class="cn.itcast.web.shiro.CustomCredentialsMatcher"/>

 @Override
    public void save(User user) {
        //生成主键
        user.setId(UUID.randomUUID().toString());
        
        //对密码加盐加密
        Md5Hash md5Hash = new Md5Hash(user.getPassword(),user.getEmail());
        user.setPassword(md5Hash.toString());
        
        userDao.save(user);
    }

  @RequestMapping("/logout")
    public String logout(){
        //删除session的登录数
        session.removeAttribute("loginUser");
        session.removeAttribute("menus");

        //Shiro登录注销（底层：删除之前Shiro存入的session的key）
        //防止浏览器记住登录认证
        Subject subject = SecurityUtils.getSubject();
        subject.logout();

        return "redirect:/login.jsp";
    }

 //授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //System.out.println("执行授权方法...");

        //1、获取当前登录用户拥有的权限
        //从Subject获取当前登录用户
        Subject subject = SecurityUtils.getSubject();
        User loginUser = (User)subject.getPrincipal();

        List<Module> moduleList = moduleService.findModuleByUser(loginUser);

        //2、把当前登录用户的权限告诉Shiro框架
        //2.1 创建授权对象
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //2.2 把模块存入授权对象
        if(moduleList!=null && moduleList.size()>0){
            for(Module module:moduleList){
                if(!StringUtils.isEmpty(module.getName())) {
                    //往授权对象存入授权信息（授权信息存入什么字符串？ 字符串必须唯一的）
                    info.addStringPermission(module.getName());
                }
            }

        }
        return info;
    }

  <!--====开启Shiro的注解====-->
    <!--
        Shiro注解借助了Spring的AOP来实现授权校验
    -->
    <bean id="lifecycleBeanPostProcessor"
          class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
          depends-on="lifecycleBeanPostProcessor"/>
    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
        <property name="securityManager" ref="securityManager"/>
    </bean>

<!--6. 开启Aop自动代理-->
<aop:aspectj-autoproxy/>

<%@ taglib prefix="shiro" uri="http://shiro.apache.org/tags" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>测试Shiro的jsp标签</title>
</head>
<body>

<shiro:hasPermission name="企业管理">
<a href="">企业管理</a>
</shiro:hasPermission>

<hr/>

<shiro:hasPermission name="用户管理">
<a href="">用户管理</a>
</shiro:hasPermission>

</body>
</html>