shiro框架初步学习

shiro框架学习

一：RBAC模型
RBAC模型是一种基于角色的权限控制模型，如下图：

首先我们想一下为什么做权限控制需要设计角色？最简单的思考方式，假如没有角色会出现什么情况。
如果没有角色，1：需要给用户增加权限的时候要给所有人都加权限，当用户量很大的时候这是一件很痛苦的事。2：当你需要给某一类人添加权限的时候，也会是一件比较痛苦的事。所以角色一方面是为了使得添加权限更加方便，另一方面是标识一类共同特征的人。所以当角色很多，整个数据库很繁琐的时候，我们又可以引入组的概念了。

二：shiro是什么？
shiro是一个安全框架，它具有以下功能：

1：认证（可以理解成处理用户登录）
2：授权 （赋予用户权限）
3：会话管理（shiro提供了session）
4：加密 （session提供了加密机制）
同时shiro支持缓存，测试，并发验证等等，具体的内容我没有去了解。
三：一个简单的shiro的demo（附上代码）
首先我们需要搭建一个ssm框架，好久没搭过了，也是碰到了一些坑。所以这里也讲一下ssm框架搭建。
先附上pom文件：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.wsy.shiro</groupId>
    <artifactId>shiro-demo</artifactId>
    <packaging>war</packaging>
    <version>0.0.1-SNAPSHOT</version>
    <name>shiro-demo Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <!-- shiro需要的架包 -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.2.4</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-ehcache</artifactId>
            <version>1.2.4</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-web</artifactId>
            <version>1.2.4</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.2.4</version>
        </dependency>

        <!-- spring需要的jar包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>3.2.8.RELEASE</version>
            <type>jar</type>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>3.2.8.RELEASE</version>
            <type>jar</type>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>3.2.8.RELEASE</version>
            <type>jar</type>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>3.2.8.RELEASE</version>
            <type>jar</type>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>3.2.8.RELEASE</version>
            <type>jar</type>
        </dependency>
        <!-- mybatis相关架包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.2.1</version>
        </dependency>
        <!-- jdbc相关架包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.28</version>
        </dependency>
        <!-- 数据库连接池相关配置 -->
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.2.2</version>
        </dependency>
        <!--NoClassDefFoundError: com/fasterxml/jackson/core/JsonProcessingException -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.1.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.1.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-oxm -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-oxm</artifactId>
            <version>3.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.thoughtworks.xstream</groupId>
            <artifactId>xstream</artifactId>
            <version>1.4.6</version>
        </dependency>
        <!-- jstl-jsp需要使用 -->
            <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>
    <build>
        <finalName>shiro-demo</finalName>
    </build>
</project>

从tomcat加载开始说吧：tomcat加载一个web工程的时候首先会去加载web.xml文件，所以先要在web.xml中配置。主要配置监听器，过滤器，DispatcherServlet。我的代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    version="2.5">
    <display-name>shiro-demo</display-name>
    <!-- 编码 -->
    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!-- shiro配置 -->
    <filter>
        <filter-name>shiroFilter</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>shiroFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- springmvc 配置 -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <!-- <param-value>classpath:spring/conf-springmvc.xml</param-value> -->
            <param-value>WEB-INF/applicationContext.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>


    <!-- 首页 -->
    <welcome-file-list>
        <welcome-file>index.html</welcome-file>
    </welcome-file-list>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
</web-app>

tomcat加载完web.xml会根据DispatcherServlet的contextConfigLocation参数配置去加载相应的文件：WEB-INF/applicationContext.xml。内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"
    default-autowire="byName">


    <!-- 配置文件 -->
    <context:property-placeholder location="classpath:*.properties"/>
    <!-- 加载Spring配置文件 -->
    <import resource="classpath*:spring/*.xml" />
</beans>

这里不介绍相关配置内容了。接着会加载classpath路径（resources）下的spring文件夹下的spring相关的配置文件。一共涉及到4个配置文件，如下图：

这里就仅仅粘贴con-shiro.xml文件的内容了，其余文件是SpringMVC，Spring，Mybatis的配置文件。大多都是差不多的。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context-4.0.xsd"
    default-lazy-init="true">

    <description>Shiro Configuration</description>

    <!-- 加载配置属性文件 -->
    <context:property-placeholder ignore-unresolvable="true" location="classpath:shiro.properties" />

    <!-- Shiro权限过滤过滤器定义 -->
    <bean name="shiroFilterChainDefinitions" class="java.lang.String">
        <constructor-arg>
            <value>
<!--                 /static/** = anon      anon不需要进行拦截  -->
<!--                 ${adminPath}/login = authc authc需要认证才能使用 -->
<!--                 ${adminPath}/logout = logout 调用logoutFilter，清除缓存退出 -->
<!--                 ${adminPath}/** = user,perms 所有请求都要用户登录 -->
<!--                 /** = authc -->
            </value>
        </constructor-arg>
    </bean>

    <!-- 安全认证过滤器 -->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager" />
        <property name="loginUrl" value="/jsp/login.jsp" />
        <property name="successUrl" value="/shiro/login" />
        <property name="unauthorizedUrl" value="/jsp/refuse.jsp" />
<!--         <property name="filters"> -->
<!--             <map> -->
<!--                 <entry key="cas" value-ref="casFilter"/> -->
<!--                 <entry key="authc" value-ref="formAuthenticationFilter"/> -->
<!--             </map> -->
<!--         </property> -->
        <property name="filterChainDefinitions">
            <ref bean="shiroFilterChainDefinitions"/>
        </property>
    </bean>


    <!-- 定义Shiro安全管理配置 -->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="realm" ref="sysRealm" />
        <property name="sessionManager" ref="sessionManager" />
        <!-- 讲解用不着 -->
<!--         <property name="cacheManager" ref="shiroCacheManager" /> -->
    </bean>

    <!-- 会话管理器 -->
      <bean id="sessionManager"
          class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
         <!-- session的失效时长，单位毫秒 -->
          <property name="globalSessionTimeout" value="600000" />
         <!-- 删除失效的session -->
          <property name="deleteInvalidSessions" value="true" />
     </bean>

    <!-- 指定本系统SESSIONID, 默认为: JSESSIONID 问题: 与SERVLET容器名冲突, 如JETTY, TOMCAT 等默认JSESSIONID,
        当跳出SHIRO SERVLET时如ERROR-PAGE容器会为JSESSIONID重新分配值导致登录会话丢失! -->
    <bean id="sessionIdCookie" class="org.apache.shiro.web.servlet.SimpleCookie">
        <constructor-arg name="name" value="hotusm.session.id"/>
    </bean>

    <!-- 定义授权缓存管理器 -->
<!--     <bean id="shiroCacheManager" class="com.thinkgem.jeesite.common.security.shiro.cache.SessionCacheManager" /> -->
    <bean id="shiroCacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
        <property name="cacheManager" ref="cacheManager"/>
    </bean>

    <!-- 保证实现了Shiro内部lifecycle函数的bean执行 -->
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>

    <!-- AOP式方法级权限检查  -->
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" depends-on="lifecycleBeanPostProcessor">
        <property name="proxyTargetClass" value="true" />
    </bean>
    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
        <property name="securityManager" ref="securityManager"/>
    </bean>

    <!-- 凭证匹配器,md5加密需要用到-->
<!--  73     <bean id="credentialsMatcher" -->
<!--  74         class="org.apache.shiro.authc.credential.HashedCredentialsMatcher"> -->
<!--  75         选用MD5散列算法 -->
<!--  76         <property name="hashAlgorithmName" value="md5" /> -->
<!--  77         进行一次加密 -->
<!--  78         <property name="hashIterations" value="1" /> -->
<!--  79     </bean> -->

</beans>

首先其中最重要当然是shiroFilter，类似我们拦截器的过滤器我们也可以指定哪些请求需要拦截，哪些请求不需要拦截。如下：

anon代表不要拦截，authc表示需要认证。user,perm表示需要相应的权限，其中perms[],roles[]没有在图中展示，但是是非常重要的概念。perms[]分别表示权限集合,比如perms[A,B,C]表示用户必须同时具有A,B,C权限才能访问该路径。同理roles[]表示必须同时具有相应的角色才可以访问该路径。这里有人会想：如果我想用或者关系该怎么做，最直接的做法就是多写几个规则，或者重写相关的代码（网上有不少方案，时间问题我没去研究）。这里除了在配置文件中设置权限路径，还可以通过代码和标签的方式进行权限控制。这里介绍一下标签的方式，代码的方式就不介绍了（太low了）。如下：

    @RequiresRoles("admin1")
    @RequestMapping(value = "/test", method = RequestMethod.GET)
    @ResponseBody
    public String test() {
        return "success";
    }

@RequiresRoles(“admin1”)表示访问该链接需要admin1角色才能访问，聪明的小伙伴直接就想到这里能配置角色当然也能配置权限了。如下：

    @RequiresPermissions("admin1-permission1")
    @RequestMapping(value = "/test", method = RequestMethod.GET)
    @ResponseBody
    public String test() {
        return "success";
    }

综上所述我们比较常用的配置url权限的方式有2种，一种是在配置文件中批量配置，另一种就是在控制器上配置标签。2者可以综合使用，如果配置文件和标签冲突了，那么会取2者的并集。在配置文件中如果权限控制出现冲突，会按后面设置的为主。
successUrl表示登录成功跳转的页面，其他就不一一介绍了。分别表示不同的结果跳转的页面。这里配置的时候出了问题，发现并不能按照配置去跳转，而是出现了如下异常：

org.apache.shiro.authz.AuthorizationException是授权失败出现的异常，还有一个是认证失败的异常：
org.apache.shiro.authz.AuthoricationException。也就是说我们想要跳转的时候，却抛出了异常。我没有选择去解决这个问题，而是直接利用了Spring MVC的捕获异常跳转的功能。在Spring MVC相关的配置文件中加一个bean，如下：

<bean  
    class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">  
    <property name="exceptionMappings">  
        <props>  
            <prop key="org.apache.shiro.authz.UnauthorizedException"> 
                /refuseNoPermission <!-- 捕获该异常时跳转的页面 --> 
            </prop>  
            <prop key="org.apache.shiro.authz.UnauthenticatedException">  
                /refuseNotLogin <!-- 捕获该异常时跳转的路径 -->
            </prop>  
        </props>  
    </property>  
</bean> 

继续回到shiro的文件配置中来，接下来的配置文件是和缓存，md5加密相关的，就不介绍了。那么shiro的配置就简单说到这里，接下来讲一个shiro的demo。
demo-1：首先按照RBAC模型设计数据库，如下：

用户表，角色表，权限表，用户角色关联表，角色权限关联表，一共是5章表。
demo-2：接着写相关代码，结构如下：

在讲解代码之前我们需要先了解shiro框架的结构。如图：

demo-2-1应用代码直接交互的对象是subject，Shiro SecurityManager就是框架的管家，Realm就是一个DataSources。管家在realm中取数据与当前用户进行校验。
先解释一下什么叫做应用代码与与subject直接交互，看如下代码：

public User login(String userName, String password){
        try{
        validate(userName,password);
        //subject代表当前与系统交互的对象
        Subject subject = SecurityUtils.getSubject();
        //将获得的用户名，密码封装成shiro框架校验需要的token
        UsernamePasswordToken token = new UsernamePasswordToken(userName, password);
        try{
            //对当前对象进行校验
            subject.login(token);
            //校验成功，返回当前用户具体信息
            Session session = subject.getSession(); 
            User user = (User)session.getAttribute("user");
            return user;
        }catch(Exception e){
            throw new RuntimeException(e.getMessage());
        }
        }catch(Exception e){
            e.printStackTrace();
            User user = new User();
            user.setMessage(e.getMessage());
            return user;
        }
    }

代码中直接将获得的用户名密码封装成token交给subject处理，又直接在subject中获得session，并获得用户返回给请求者。这就是直接交互。subject即可看做当前与系统交互的对象。
demo-2-2：SecurityManager（安全管理器）负责管理所有subject，所有subject与其他组件的交互都由它控制，它就像Spring MVC的DispatcherServlet，管理所有请求。
demo-2-3：Realm：域，Shiro从从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源

demo-3：编写认证，授权代码。

package com.wsy.shiro.serviceImpl;

import java.util.ArrayList;
import java.util.List;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authc.UsernamePasswordToken;
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 org.springframework.stereotype.Service;

import com.wsy.shiro.model.Permission;
import com.wsy.shiro.model.Role;
import com.wsy.shiro.model.User;
import com.wsy.shiro.service.LoginService;

/**
 * shiro是从这里获得用户详角色，权限
 * 
 * @author shuyweng
 * 
 */
@Service("sysRealm")
public class AuthRealm extends AuthorizingRealm {

    // 设置realm的名称
    @Override
    public void setName(String name) {
        super.setName("customRealm");
    }

    @Autowired
    private LoginService loginServiceImpl;

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(
            PrincipalCollection principals) {
        // 获得真实的用户的信息，与doGetAuthenticationInfo方法中传入的object类型有关
        User user = (User) principals.getPrimaryPrincipal();
        // 根据用户id获得用户角色列表
        List<Role> roleList = user.getRole();
        List<Permission> permList = user.getPermission();
        //拼接权限，角色字符串
        List<String> permissionList = new ArrayList<>();
        // 根据角色列表获得权限名称列表
        for(Permission perm:permList){
            permissionList.add(perm.getPermssionName());
        }
        // 获得角色名称列表
        List<String> roleStringList = new ArrayList<String>();
        for (Role role : roleList) {
            roleStringList.add(role.getRoleName());
        }
        // 创建授权对象
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        // 为当前对象创建角色列表
        simpleAuthorizationInfo.addRoles(roleStringList);
        // 为当前用户添加权限列表
        simpleAuthorizationInfo.addStringPermissions(permissionList);
        // 登录成功获取当前对象，并获得当前对象的session，往里放入user
        return simpleAuthorizationInfo;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(
            AuthenticationToken token) throws AuthenticationException {
        // 从token中获取账号密码
        token = (UsernamePasswordToken) token;
        String userName = (String) token.getPrincipal();
        char[] pwd = (char[]) token.getCredentials();
        String stringPwd = String.valueOf(pwd);
        //调用我们自己写的service来处理登录
        User user = loginServiceImpl.login(userName, stringPwd);
        //登录成功往session中存值
        Subject subject = SecurityUtils.getSubject();
        Session session = subject.getSession();
        session.setAttribute("user", user);
        AuthenticationInfo info = new SimpleAuthenticationInfo(user, pwd,
                this.getName());
        // <span style="color:#ff0000;">SimpleAuthenticationInfo authcInfo = new
        // SimpleAuthenticationInfo(adminUser,
        // password,ByteSource.Util.bytes(salt), this.getName());</span>
        // 此处可以进行md5的多次加密
        return info;
    }
}

这么理解在调用subject.login()方法时会调用doGetAuthenticationInfo方法，在执行权限校验时会执行doGetAuthentizationInfo。可以回顾之前的login方法就调用了subject.login()。只要进行权限校验就会调用doGetAuthentizationInfo方法，所以显然每次从数据库获取用户权限是不合理的，这里我每次都是从session中取。
demo-4：结果展示
如图在数据库中赋予wsy角色1，赋予yangrui角色2。给test路径加上标签@RequiresRoles(“admin1”)。如下：

@RequiresRoles("admin1")
    @RequestMapping(value = "/test", method = RequestMethod.GET)
    @ResponseBody
    public String test() {
        return "success";
    }

由于shiro默认选择的是字符串匹配，所以设计的时候给角色1命名admin1，角色2命名admin2。在数据库初始化完毕之后，我们首先在没有登录的情况下访问test路径，结果如下：

接着我们以yangrui的身份登录，结果如下：

此时shiro的session中已经包含用户信息了，可以看到我们拥有的角色2权限，并不是标签中要求的角色1。也就是说我们已经登录成功了，但是权限不相符。我们再次访问，结果如下：

如图显示杨锐没有相关权限。
最后创建一个角色翁澍瑜，该用户具有角色1权限。登录成功如下：

可以看到翁澍瑜是具有admin1角色权限的，再次访问测试路径，结果如下：

这次就成功了。
简单学习shiro除了学习配置其实就是利用shiro的四个主要的API：
1：Authentication —— 认证，用户身份识别，常被称为用户“登录”，who are you?
2：Authorization —— 授权，访问控制过程，决定“谁”访问“什么”，who can do what?
3：Session Management —— 会话管理，用户session管理器，用户相关的时间敏感的状态
4：Cryptography —— 密码加密，把JDK中复杂的密码加密方式进行封装，保护或隐藏数据防止被偷窥
我的代码中并没有用到shiro的加密功能，这里简单说一下：shiro提供了md5加密和aes加密的接口，使我们使用加密更加简单。如下是使用md5加密的过程：

DefaultHashService hashService = new DefaultHashService();
        HashRequest request = new HashRequest.Builder().setAlgorithmName("MD5")
                .setSource(ByteSource.Util.bytes("123456"))
                .setSalt(ByteSource.Util.bytes("123")).setIterations(2).build();
        String hex = hashService.computeHash(request).toHex();

md5加密算法是一种非常简单的不可逆 的加密算法。这里就不介绍了，我所说的简单并不是这种算法的实现简单，而是使用相当简单。推荐一种更加好的加密方式，AES加密。shiro也提供了AES加密算法的相关接口。这里说一下md5和AES加密算法的应用场景，往往md5是用于数字签名（数字签名用于验证消息发送发是否可靠，验证数据是否有误），AES用于加密数据的传输。
这是一个关于shiro的简单介绍，详细的介绍，推荐一个网址：http://jinnianshilongnian.iteye.com/blog/2018936
这里有比较的系统介绍shiro框架，包括加密，缓存等其他功能。