CAS4.0.0链接Redis4.0.6_cas 自定义abstractdistributedticketregistry

前言

2.5.1、版本信息

CAS服务器版本为4.0.0
Redis数据库版本为4.0.6

2.5.2、Redis相关的配置

    Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。它通常被称为数据结构服务器，因为值（value）可以是 字符串(String), 哈希(Map), 列表(list), 集合(sets) 和 有序集合(sorted sets)等类型。
    本文是基于Java语言的开发，使用Java语言调用Redis的相关服务，需要调用相关jar包——jedis-2.9.0.jar。将该jar包复制到cas服务器工程中，路径 cas/WEB-INF/lib 下。
    Redis数据库的安装略，请自行百度安装。
    建议安装一个Redis客户端——RedisDesktopManager，用来查看数据库信息。

2.5.3、CAS服务器的改造

2.5.3.1、自定义CAS链接Redis类

    在myeclipse中创建Java web工程，工程名随意。将Redis的连接包jedis-2.9.0.jar 和CAS服务的cas-server-core-4.0.0.jar导入到工程中，cas-server-core-4.0.0.jar在你下载的cas-server-4.0.0-release的 .../cas-server-4.0.0/modules下。
在工程中创建名为 org.jasig.cas.ticket 的包，在该包下创建名为RedisTicketRegistry的类，在该类中定义CAS与Redis交互的方法。该类需要继承CAS自身的抽象类——AbstractDistributedTicketRegistry。代码如下：

package org.jasig.cas.ticket;
 
 
import java.io.ByteArrayInputStream;  
import java.io.ByteArrayOutputStream;  
import java.io.ObjectInputStream;  
import java.io.ObjectOutputStream;  
import java.util.Collection;  
  
import org.jasig.cas.ticket.Ticket;  
import org.jasig.cas.ticket.TicketGrantingTicket;  
import org.jasig.cas.ticket.registry.AbstractDistributedTicketRegistry;  
  
 
import redis.clients.jedis.Jedis;  
import redis.clients.jedis.JedisPool;  
import redis.clients.jedis.JedisPoolConfig;  
  
/** 
 * 使用Redis存储Ticket 
 * @author xyong
 */  
public class RedisTicketRegistry extends AbstractDistributedTicketRegistry  
{  
  
    private static int redisDatabaseNum;  
  
    private static String hosts;  
      
    private static int port;  
      
    private static int connTimeout;  
      
    //private static String redisPassword;  
  
    /** 
     * ST最大空闲时间 
     */  
    private static int st_time;  
  
    /** 
     * TGT最大空闲时间 
     */  
    private static int tgt_time;  
  
    private static JedisPool cachePool;  
  
    static  
    {  
        
        
        //redisDatabaseNum = SysPropertiesUtil.getPropertyInt("redis_database_num");  
        redisDatabaseNum = 7;   //选择存储的redis数据库，redis默认有15个数据库。我的幸运数字是7，所以我选用第七个数据库。
        
        //hosts = SysPropertiesUtil.getProperty("redis_hosts");  
        hosts = "10.4.123.100";
                
        //port = SysPropertiesUtil.getPropertyInt("redis_port");  
        port = 6379;
        
        //connTimeout = SysPropertiesUtil.getPropertyInt("redis_conn_timeout");  
 
 
        
        //redisPassword = SysPropertiesUtil.getProperty("redis_password");  
  
        //st_time = SysPropertiesUtil.getPropertyInt("st_time");  
        st_time = 10000;        //10秒
                
        //tgt_time = SysPropertiesUtil.getPropertyInt("tgt_time");  
        tgt_time = 7200000;     //7200秒，2个小时
        
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(1000);
        //config.setTestOnBorrow(true);
        cachePool = new JedisPool(config, hosts, port);  
    }  
  
    @Override  
    public void addTicket(Ticket ticket)  
    {  
        Jedis jedis = cachePool.getResource();  
  
        jedis.select(redisDatabaseNum);  
  
        int seconds = 0;  
  
        String key = ticket.getId();  
  
        if (ticket instanceof TicketGrantingTicket)  
        {  
            seconds = tgt_time / 1000;  
        }  
        else  
        {  
            seconds = st_time / 1000;  
        }  
  
        ByteArrayOutputStream bos = new ByteArrayOutputStream();  
        ObjectOutputStream oos = null;  
  
        try  
        {  
  
            oos = new ObjectOutputStream(bos);  
  
            oos.writeObject(ticket);  
  
        }  
        catch (Exception e)  
        {  
            logger.error("adding ticket to redis error.");  
        }  
        finally  
        {  
            try  
            {  
                if (null != oos)  
                    oos.close();  
  
            }  
            catch (Exception e)  
            {  
                logger.error("oos closing error when adding ticket to redis.");  
            }  
        }  
  
        jedis.set(key.getBytes(), bos.toByteArray());  
        jedis.expire(key.getBytes(), seconds);  //设置redis失效时间
        jedis.close();  
  
    }  
  
    @Override  
    public boolean deleteTicket(String ticketId)  
    {  
        if (ticketId == null)  
        {  
            return false;  
        }  
  
        Jedis jedis = cachePool.getResource();  
        jedis.select(redisDatabaseNum);  
          
        jedis.del(ticketId.getBytes());  
        jedis.close();  
        return true;  
    }  
  
    @Override  
    public Ticket getTicket(String ticketId)  
    {  
        return getProxiedTicketInstance(getRawTicket(ticketId));  
    }  
  
    private Ticket getRawTicket(final String ticketId)  
    {  
        if (null == ticketId)  
        {  
            return null;  
        }  
  
        Jedis jedis = cachePool.getResource();  
        jedis.select(redisDatabaseNum);  
        Ticket ticket = null;  
        byte[] bytes = jedis.get(ticketId.getBytes());  
        if (bytes == null || bytes.length < 1)  
        {  
            return null;  
        }  
        ByteArrayInputStream bais = new ByteArrayInputStream(bytes);  
        ObjectInputStream ois = null;  
  
        try  
        {  
            ois = new ObjectInputStream(bais);  
            ticket = (Ticket) ois.readObject();  
        }  
        catch (Exception e)  
        {  
            e.printStackTrace();  
            logger.error("getting ticket to redis error.");  
        }  
        finally  
        {  
            try  
            {  
                if (null != ois)  
                {  
                    ois.close();  
                }  
            }  
            catch (Exception e)  
            {  
                e.printStackTrace();  
                logger.error("ois closing error when getting ticket to redis.");  
            }  
        }  
  
        jedis.close();  
        return ticket;  
    }  
  
    @Override  
    public Collection<Ticket> getTickets()  
    {  
        throw new UnsupportedOperationException("GetTickets not supported.");    
    }  
  
    @Override  
    protected boolean needsCallback()  
    {  
        return false;  
    }  
  
    @Override  
    protected void updateTicket(Ticket ticket)  
    {  
        this.addTicket(ticket);    
    }  
  
}

    找到myeclipse  workspace中RedisTicketRegistry.class文件，该文件在workspace\CASTransform\WebRoot\WEB-INF\classes\org\jasig\cas\ticket目录下。
右键打开cas-server-core-4.0.0.jar压缩包（不要解压），再按照\org\jasig\cas\ticket\路径打开文件夹，将RedisTicketRegistry.class拖到该文件夹下，结果如图2.5.3.1所示。
    关掉该窗口，用修改后的cas-server-core-4.0.0.jar覆盖CAS服务器cas/WEB-INF/lib下的原cas-server-core-4.0.0.jar包。

2.5.3.2、修改ticketRegistry.xml

    在CAS的cas/WEB-INF/spring-configuration下获取ticketRegistry.xml。打开ticketRegistry.xml，修改id为ticketRegistry的bean的路径，并注释掉ticketRegistry.xml下方的配置信息，修改后的ticketRegistry.xml内容如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<!--
    Licensed to Jasig under one or more contributor license
    agreements. See the NOTICE file distributed with this work
    for additional information regarding copyright ownership.
    Jasig licenses this file to you under the Apache License,
    Version 2.0 (the "License"); you may not use this file
    except in compliance with the License.  You may obtain a
    copy of the License at the following location:
      http://www.apache.org/licenses/LICENSE-2.0
    Unless required by applicable law or agreed to in writing,
    software distributed under the License is distributed on an
    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, either express or implied.  See the License for the
    specific language governing permissions and limitations
    under the License.
-->
<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <description>
        Configuration for the default TicketRegistry which stores the tickets in-memory and cleans them out as specified intervals.
    </description>
       
  <!-- Ticket Registry -->
  <!-- <bean id="ticketRegistry" class="org.jasig.cas.ticket.registry.DefaultTicketRegistry" /> -->
    <bean id="ticketRegistry" class="org.jasig.cas.ticket.RedisTicketRegistry" />
 
 
    <!--Quartz -->
    <!-- TICKET REGISTRY CLEANER -->
  
   
<!-- <bean id="ticketRegistryCleaner" class="org.jasig.cas.ticket.registry.support.DefaultTicketRegistryCleaner"
  p:ticketRegistry-ref="ticketRegistry"
  p:logoutManager-ref="logoutManager" />
<bean id="jobDetailTicketRegistryCleaner" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"
  p:targetObject-ref="ticketRegistryCleaner"
  p:targetMethod="clean" />
<bean id="triggerJobDetailTicketRegistryCleaner" class="org.springframework.scheduling.quartz.SimpleTriggerBean"
  p:jobDetail-ref="jobDetailTicketRegistryCleaner"
  p:startDelay="20000"
  p:repeatInterval="5000000" /> -->
 
 
 
 
</beans>

备注：你可以直接用上面的配置信息覆盖掉你原来的ticketRegistry.xml配置信息。
    用修改后的ticketRegistry.xml覆盖掉CAS服务器中原来的ticketRegistry.xml

2.5.4、测试

    按照以上步骤完成对CAS服务器的配置，重启CAS服务器，浏览器访问CAS登录页面，进行登录操作，登录成功后打开RedisDesktopManager（2.5.2安装的Redis客户端）。发现redis第七个数据中新增了cas ticket数据，如图2.5.4.1，说明配置成功。