produces="application/json;charset=utf-8"

shiro官方架構圖：http://shiro.apache.org/architecture.html

Shiro缓存管理

其缓存管理仍旧是依赖于Redis进行实现。

意为将从数据库取出来的数据放置到Redis缓存中去，如果缓存中有直接取出，没有则去数据库中获取并且放置到Reids缓存中。

步骤：

1. 与之前的Session管理一致。首先创建CacheManager并且实现CacheManager接口。

2. 创建Cache类实现Cache接口，其中有增删改查等方法。同样通过序列化与反序列化、二进制数组键值对等实现其中方法。

3. 在CacheManager类中注入Cache类，并且将其作为返回值写入到实现的唯一方法的返回处。

4. 将CacheManager在Spring.xml中进行配置Bean，并且将次设置到SecurityManager中。

5. 都是通过JedisUtil完成的操作，均是将数据保存到了Redis中，无论是Session还是缓存只是多了一个Redis进行管理。
   

Shiro会话管理

其会话管理主要涉及到了Shiro整体框架的SessionManager与SessionDao模块。

视频中讲的是与Redis相结合，进行对Session的增删改查操作。

当然Shiro管理Session还可以通过别的介质进行管理。

步骤如下：

1. 先加载Redis，在Maven 的pom.xml文件中配置Redis依赖包，坐标如下：

   
   

2. <dependency>
       <groupId>redis.clients</groupId>
       <artifactId>jedis</artifactId>
       <version>2.7.3</version>
   </dependency>

3. 配置Spring与Redis结合的配置文件。新建立Spring-redis.xml文件。

   由于之前也没接触过Redis，这里只能重复视频中的配置。配置JedisPool的bean，

   其中设置属性jedisPoolConfig、host、port信息，其中JedisPoolConfig则需要另外建立bean，然后将此Bean引入到JedisPool中，host则写本机地址，port一般为6379.当然以上的类都是Redis包下的，Redis是依靠Jedis来实现其功能。然后将此文件导入到Spring.xml主文件中，即采用import标签。

   注意：需要下载相应redis server，程序启动的时候，要先启动redis server，否则会报错。

4. 新建util包，建立JedisUtil类，此类中主要是对Redis进行增删改查操作。因为Reids是存放键值对的形式。在JedisUtil中，将JedisPool注入到类中，写入单独方法获取Jedis，即通过JedisPool.getResource()来获取Jedis，此方法用于获取Jedis对象，通过Jedis进行直接对Redis存放值进行增删改查操作。

5. 创建Shiro中SessionDao类，实现AbstractSessionDao，实现其中的增删改查、获取当前活跃的Session等方法。由于redis中存放的是key与value都是二进制的数组形式，所以在修改Redis值的时候需要注意将其转成二进制的数据，并且判断是否存在相应id、session等。

   其中：generateSessionId(session) 生成Serializable序列化的sessionId

             assignSessionId(session,sessionId) 绑定session与相应的Id值

             session.getId 返回的是SessionId值，同理也是Serializable的类型

                 SerializationUtils.serialize (session) 通过序列化将session转成相应的byte[]数组

                 SerializationUtils.deserialize(byte[]) 通过反序列化将字节转成Object类型，可通过强转获取                   Session对象.

     PS:注意session 与 sessionId是否为空的情况判断。另外如果加入前缀，可以在搜索的时候加入前缀+“*”代表搜索前缀是aa的所有匹配的key值。

6.同样JedisUtils中也需要通过Jedis 的get put expire del keys方法进行获取 存储 设置等待时间 删除操作、查询匹配key的值集合。

7.新建类SessionManager 继承 DefaultWebSessionManager类，里面可以什么都不做。

8.在spring.xml文件中，写入SessionManager的Bean 并且写入Sessiondao的bean，将SessionDao的Bean 注入到Sessionmanager中。最后将SessionManager的Bean注入到SecurityManager中即可。

9.此处将5-1与5-2整合在一起了，5-2的例子就不单独写了。

  此处在测试过程中，发现系统会读取Session多次。

  需要在SessionManager中重写，retrieveSession方法。

  a.先通过参数SessionKey获取sessionId，然后判断sessionkey是否为websessionkey，如果是则通过强转将其转为WebSessionKey并且获取ServletRequest。

b.核心是将SessionId 与 Session 放到Reqeust中，如果Request有，则直接拿去，没有在去Redis中拿，如此一来则减少了访问Redis的次数，减轻了Reids 的压力。此时判断request是否为空以及sessionId是否为空，如果同时都不为，则通过sessionId 从request的属性中获取Session，在判断Session是否为空，如果不是空，则返回。

c.当不符合以上条件时候，直接调用父类的方法获取Session，继续判断request是否为空，如果不是空，则将session和sessionId放入到request的属性中即可，方便下次再来寻找直接从request中拿出，不用再多次访问Redis了。

Shiro自动登录，意为记住密码。将用户名与密码记录在Cookie中。

主要通过配置来实现自动登录。步骤：

1. 在Spring.xml文件中进行配置，配置CookieRememberMeManager,并且利用属性cookie，将外边的bean的SimpleCookie注入进去。SimpleCookie用构造方法设置名称，之后通过属性用maxAge设置超时时间即可。

2. 在登录的时候，传入UserNameAndPassowrdToken的时候，其对象可以设置setRememberMe的属性，为true即为记住登录。
   

Shiro过滤器

1. 内建过滤器：roles[a,b,c] 必须权限都符合才可以、perms[a,b,c]必须权限同时具备才可以。

2. anon 代表无需权限

   authc 代表需要认证才能访问

   user 代表需要存在用户对象才能被访问

   logout 登录退出才能被访问

   perms 拥有权限才能被访问

   roles 拥有角色才能被访问

   port 相应端口号才能访问

3. 自定义，分认证与授权，如果是认证则继承认证的类，如果是授权则继承授权的类。然后重写方法，其中参数Object o 即代表存在哪些参数，即perms[a,b,c]中的abc然后判断返回结果true 或者false即可。

4. 在后台xml文件中引入该filter的bean，然后在主过滤器中引入filter的标签，写入entry key 与 value-ref，然后在filter过滤中

5. filterChainDefinitions地方按照之前的规则使用该自定义过滤，写入

6. key值即可。

Shiro通过注解配置授权

1. 引入maven配置，如下：

   
   

2. <dependency>
       <groupId>org.aspectj</groupId>
       <artifactId>aspectjweaver</artifactId>
       <version>1.8.9</version>
   </dependency>

3. 在springmvc.xml文件中开启aop配置，然后引入bean配置，将权限管理注入到Author的bean中即可。

4. 配置如下；

   
   

5. <aop:config proxy-target-class="true"/>
   <bean class="org.apache.shiro.spring.LifecycleBeanPostProcessor" id="lifecycleBeanPostProcessor"/>
   
   <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor"
      id="authorizationAttributeSourceAdvisor">
           <property name="securityManager" ref="securityManager"/>
   </bean>

6. 在需要角色或者权限的方法中引入@RequireRoles或者@RequirePersmisson来判断。
   

shiro集成Spring的数据库连接

步骤：

1. 先从pom.xml文件中引入三个包：mysql的驱动包、spring-jdbc包、druid的数据源包。

2. 在spring下建立spring-dao.xml文件。建立数据源的bean，即DruidDataSource类，并且将属性url、username、password设置值。其次建立jdbctemplate的bean，将数据源注入到相应的bean中。

3. 创建dao层包，按照分层结构，分dao接口层以及dao.impl的实现类层。写入UserDao以及实现类。

4. 在spring.xml文件中使用impor标签导入spring-dao.xml文件，以及扫描com.imooc下的所有文件，把新加的注解扫描上。

5. 调用jdbcTemplate方式：直接使用注解@Resource调动，同理调用接口也是此种方式注入。

6. 实现类必须加入@Compont否则无法被扫描到。接口可以不加入。

7. jdbcTemplate.query方法参数1sql语句2数组参数3RowMapper重写方法mapRow通过方法体的参数ResultSet来获取对应字段的查询值即可。

8. 修改Realm获取值的方式，并且在相应的Controller做判断。
   

Shiro集成Spring，步骤以及注意事项如下：

1. 创建Maven的Web项目，创建完毕之后，按照Maven的规范创建出相应的Java源码文件以及相应的test测试目录。并且将web-info下的文件删除。

2. 设置java文件夹以及resources文件夹分别为源码类型以及资源文件类型，具体可以点击文件夹右键，找到Mark Dirctory as选择。

3. 在resources中创建spring文件夹，并且创建spring.xml以及spring-mvc.xml文件。

4. 在web-info中创建web.xml文件。一般的idea不可创建出web.xml文件，所以此时按照网上给的方法，直接选择菜单中的File---Project Stru----Facts 第一个空白点击处，添加web.xml文件。点击确定即可。路径要写对，是在web-info下。此种方法如果不行，则需要手动写入web.xml文件。

   web.xml代码如下：

5. <?xml version="1.0" encoding="UTF-8"?>
   <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
            version="3.1">
   
   
   
       <!-- 指定Spring Bean的配置文件所在目录。默认配置在WEB-INF目录下 -->
       <context-param>
           <param-name>contextConfigLocation</param-name>
           <param-value>classpath*:spring/spring.xml</param-value>
       </context-param>
   
   
   
       <listener>
           <listener-class>
               org.springframework.web.context.ContextLoaderListener
           </listener-class>
       </listener>
   
       <listener>
           <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
       </listener>
   
   
       <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>
   
   
       <servlet>
           <servlet-name>dispatcherServlet</servlet-name>
           <servlet-class>
               org.springframework.web.servlet.DispatcherServlet
           </servlet-class>
           <init-param>
               <param-name>contextConfigLocation</param-name>
               <param-value>classpath*:spring/spring-mvc.xml</param-value>
           </init-param>
           <load-on-startup>1</load-on-startup>
       </servlet>
       <servlet-mapping>
           <servlet-name>dispatcherServlet</servlet-name>
           <url-pattern>/</url-pattern>
       </servlet-mapping>
   
   
   </web-app>

6. 其次在Maven的pom.xml文件中引入相应的spring、springmvc 、shiro 、shiro-spring、shiro-web的jar包，注意必须版本保持匹配，否则启动容易报404错误，我就是因为这个问题。如下是pom.xml文件引入的包：

7. <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-context</artifactId>
       <version>4.2.4.RELEASE</version>
   </dependency>
   <!-- 2)SpringWeb Dependency -->
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-webmvc</artifactId>
       <version>4.2.4.RELEASE</version>
   </dependency>
   <!-- 3)Shiro Dependency -->
   <dependency>
       <groupId>org.apache.shiro</groupId>
       <artifactId>shiro-core</artifactId>
       <version>1.4.0</version>
   </dependency>
   <!-- 4)ShiroWeb Dependency -->
   <dependency>
       <groupId>org.apache.shiro</groupId>
       <artifactId>shiro-web</artifactId>
       <version>1.4.0</version>
   </dependency>
   <!-- 5)ShiroSpring Dependency -->
   <dependency>
       <groupId>org.apache.shiro</groupId>
       <artifactId>shiro-spring</artifactId>
       <version>1.4.0</version>
   </dependency>

8. 在相应的resources资源文件下建立spring文件夹，在spring-mvc.xml文件中写入扫描文件以及驱动、过滤的标签，如下：

   
   

9. <context:component-scan base-package="com.imooc.controller"/>
   <mvc:annotation-driven />
   <mvc:resources mapping="/*" location="/"/>

10. 在spring.xml文件中，写入相应的自定义的Realm的bean标签、加密的Hashed的bean标签（注入到Realm中）、写入默认的web的权限管理的bean标签（注入Realm）、写入ShiroFilterFactoryBean的bean标签（将web的权限管理注入进去）即可。

    此外ShiroFilter的bean标签里面，还可以规定loginurl的值，即登录的页面，unauthor..登录失败没权限访问的页面，filterChainDefinitions过滤链，（过滤链里面可以以a=b的形式进行过滤，例：/login.html = anon 表示在访问login.html页面的时候不需要任何权限，anon表示无需权限，authc代表必须认证通过才能访问，一般链是从上往下匹配，只要匹配的相应结果，则直接返回。所以一般把/*=authc放在最后。）下面是源码：

11. <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
         <property name="securityManager" ref="securityManager"/>
        <property name="loginUrl" value="login.html"/>
        <property name="unauthorizedUrl" value="403.html"/>
        <property name="filterChainDefinitions">
            <value>
                /login.html = anon
                /subLogin = anon
                /* = authc
            </value>
        </property>
    
    </bean>
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="realm" ref="customRealm"/>
    </bean>
    <bean id="customRealm" class="com.imooc.realm.CustomRealm">
         <property name="credentialsMatcher" ref="hashedCredentialsMatcher"/>
    </bean>
    
    <bean id="hashedCredentialsMatcher" class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
        <property name="hashAlgorithmName" value="md5"/>
        <property name="hashIterations" value="1"/>
    </bean>

12. 之后基本上就是写入controller以及html网页即可。之后启动tomcat自动访问，其中关于编码的问题需要在@RequestMapping中设置produces="application/json;charset=utf-8"的形式即可。
    

继承 AuthorizatrionFilter 自定义Filter,

isAccessAllowed 用来校验权限 , 其中的Object 就是filter 定义时后面中括号里的字符串 , 如 perms[sys:delete,user:add] 里面的部分, 

Shiro加密

1. 通过HashedCredentialsMaster的方式加密，创建对象，并设置加密次数以及加密名称，将此加密对象设置到Realm的setCredentialsMaster的方法中，即该Realm采用此密码加密的方式。

2. 后台的密码采用MD5的Hash码值来存储。如果想将密码转成MD5Hash码可以采用MD5Hash对象，在构造方法中写入密码，

   打印输出其对象的toString方法即时期hash码值。

3. 加盐，实际为在密码中加入相应的其他名称拼接在一起，组成一个新的密码。如果想存储加盐之后的Hash码，仍旧采用MD5Hash对象，在构造方法的第二个参数中加入盐的名称，同样打印toString方法即可显示出来。其次在自定义的Realm认证方法中，返回Simple之前，设置Simple的加盐名称，即采用setCredentailSalt方法写入盐的名称即可。

4. 以上两种加密方式，对Realm改动较小，除非加盐才改动。

5. 在自定义的Realm加盐的时候，需要将字符值转成相应的ByteSource,则需要用ByteSource.Util.bytes(字符)即可，将此值设置到Simple的返回值中。

自定义的Realm，主要注意一下几个步骤：

1. 首先继承并实现类AuthorizingRealm的方法。其中方法

   doGetAuthenticationInfo 主要做认证操作，即可以通过获取其中的

   用户名，查询出相应的密码，然后将用户名与密码一并返回，shiro会自动根据传入的用户名与密码与此Realm返回的用户名和密码作比对，返回你想要的结果。同理doGetAuthorizationInfo主要是用来做角色与权限的验证，也是通过用户名，从数据库中查找到相应的角色或者权限的数据并返回一个Simple的授权类，授权系统会根据传入的参数与返回的结果集对比，存在返回true不存在则抛异常。

2. 两者方法只能获取用户名称，通过用户名称连接数据库获取其他信息。这里只是做数据准备操作，并不做判断是否传入的值与其相符的操作，此操作在此之后进行。

3. 根据两者的返回对象分别返回Simple类型的对象。认证的对象需要将你获取的用户名和密码放到构造方法中。授权的对象需要你set到相应的方法中。

4. 例子中只是从本地写死静态类，之后必须写入相应的数据库连接。
   

JdbcRealm的方式访问数据库，通过与数据库的连接，验证相应的登录用户与授权。

1. jdbcRealm新建其实例，并初始化。

2. Maven中引入mysql的驱动以及相应数据源的类。

3. 新建数据源作为成员变量，并且在静态快中初始化url、username、password等。

4. 将数据源设置到到jdbcrealm中，并且将此realm设置到权限管理中。

5. 之后进行登录等验证，jdbcrealm会在源码的地方写入了默认的进行认证与授权的sql语句，以及表名什么的都规定好了。如果想更改，则写入新的sql语句，并且调用jdbcrealm中的设置认证Query、设置权限Query、设置角色查询的方法，进行修改。

6. 当查询权限的时候，会报错，即便库汇总有次权限，仍旧会报错，因为你需要在jdbcrealm中开启persimisson的为true即可。

7. 其他的与之前的认证与授权的步骤一致。

   Maven的配置：

8. <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>5.1.45</version>
   </dependency>
   <dependency>
       <groupId>com.alibaba</groupId>
       <artifactId>druid</artifactId>
       <version>1.0.12</version>
   </dependency>